python建立多個對象

① python可以建立多個游標嗎

cursor就是一個Cursor對象，這個cursor是一個實現了迭代器（def__iter__()）和生成器（yield）的MySQLdb對象，這個時候cursor中還沒有數據，只有等到fetchone()或fetchall()的時候才返回一個元組tuple，才支持len()和index()操作，這也是它是迭代器的原因。但同時為什麼說它是生成器呢？因為cursor只能用一次，即每用完一次之後記錄其位置，等到下次再取的時候是從游標處再取而不是從頭再來，而且fetch完所有的數據之後，這個cursor將不再有使用價值了，即不再能fetch到數據了。

資料庫支持
使用簡單的純文本只能實現有退限的功能，所需要引入資料庫，完成更強大的功能，本節使用的簡單資料庫SQLite 。
SQLite 和PySQLite
sqlite是非常著名的開源嵌入式資料庫軟體，它可以嵌入到其他程序中使用，並且提供SQL介面用來查詢，非常方便。它的官方站點為http://www.sqlite.org。
而pysqlite 則是一個sqlite 為 python 提供的 api 介面，它讓一切對於 sqlite 的操作都變得異常簡單
在python2.5版本這後，SQLite的優勢在於它的一個包裝（PySQLite）已經被包括在標准庫內，所以我們可以直接使用。
入門操作
可以將SQLite作為名為sqlite3的模塊導入。之後就可以創建一個到資料庫文件的連接----如果文件不存在就會被創建----通過提供一個文件名：

>>> import sqlite3
>>> conn= sqlite3.connect('somedatabase.db') # 創建資料庫
>>>cu =conn.cursor() #能獲得連接的游標

#創建數據表
>>>cu.execute("""create table catalog (
id integer primary key,
pid integer,
name varchar(10) UNIQUE
)""")

#插入兩條數據
>>>cu.execute("insert into catalog values(0,0,'name1')")
>>>cu.execute("insert into catalog values(1,0,'name2')")
>>>conn.commit()

#選擇（select）
>>>cu.execute("select * from catalog")
>>>cu.fetchall()
[(0, 0, 'name1'), (1, 0, 'name2')]
>>>cu.execute("select * from catalog where id = 1")
>>>cu.fetchall()
[(1, 0, 'name2')]

#修改（update）
>>>cu.execute(「update catalog set name=』name2′ where id = 0″)
>>> cx.commit()
>>> cu.execute(「select * from catalog」)
>>> cu.fetchone()
(0, 0, 『name2′)

#刪除（delete）
>>>cu.execute(「delete from catalog where id= 1″)
>>> cx.commit()
>>> cu.execute(「select * from catalog」)
>>> cu.fetchall()
[(0, 0, 'name2')]

連接
為了使用基礎資料庫系統，首先必須連接到它，這個時候需要使用具有名稱的connect函數，該函數有多個參數，而具體用哪個參數取決於資料庫。
connect函數的常用參數：
connect函數返回連接對象。這個對象表示目前和資料庫的會話。連接對象支持的方法如下；
連接對象方法：
commit 方法總是可用的，但如果資料庫不支持事務，它就沒有任何作用。如果關閉了連接但還有未提交的事務，它們會隱式地回滾---但是只有在資料庫支持持回滾的時候才可以。
rollback 方法可能不可用，因為不是所有的資料庫都支持事務（事務是一系列動作）。如果可用，那麼就可以「撤銷」所有未提交的事務。
cursor 方法將我們引入另外一個主題：游標對象。通過游標掃行SQL 查詢並檢查結果。游標連接支持更多的方法，而且可能在程序中更好用。
游標：
cu = conn.cursor()
能獲得連接的游標，這個游標可以用來執行SQL查詢。
conn.commit()
完成插入並且做出某些更改後確保已經進行了提交，這樣才可以將這些修改真正地保存到文件中。
游標對象方法：
游標對象特性：
cu.fetchone()
fetchall()返回結果集中的全部數據，結果為一個tuple的列表。每個tuple元素是按建表的欄位順序排列。注意，游標是有狀態的，它可以記錄當前已經取到結果的第幾個記錄了，因此，一般你只可以遍歷結果集一次。在上面的情況下，如果執行fetchone()會返回為空。這一點在測試時需要注意。
conn.close()
可以在每次修改資料庫後都進行提交，而不是僅僅在准備關閉才提交，准備關閉數據時，使用close 方法。

② 如何創建對象和使用對象

一、打開JUPYTER NOTEBOOK，新建一個PYTHON3文檔。

③ 怎麼讓python在內存中運行

對象的內存使用
賦值語句是語言最常見的功能了。但即使是最簡單的賦值語句，也可以很有內涵。Python的賦值語句就很值得研究。
a = 1

整數1為一個對象。而a是一個引用。利用賦值語句，引用a指向對象1。Python是動態類型的語言(參考動態類型)，對象與引用分離。Python像使用「筷子」那樣，通過引用來接觸和翻動真正的食物——對象。

引用和對象

為了探索對象在內存的存儲，我們可以求助於Python的內置函數id()。它用於返回對象的身份(identity)。其實，這里所謂的身份，就是該對象的內存地址。
a = 1

print(id(a))
print(hex(id(a)))

在我的計算機上，它們返回的是:
11246696
'0xab9c68'
分別為內存地址的十進制和十六進製表示。

在Python中，整數和短小的字元，Python都會緩存這些對象，以便重復使用。當我們創建多個等於1的引用時，實際上是讓所有這些引用指向同一個對象。
a = 1
b = 1

print(id(a))
print(id(b))

上面程序返回
11246696
11246696
可見a和b實際上是指向同一個對象的兩個引用。

為了檢驗兩個引用指向同一個對象，我們可以用is關鍵字。is用於判斷兩個引用所指的對象是否相同。

# True
a = 1
b = 1
print(a is b)

# True
a = "good"
b = "good"
print(a is b)

# False
a = "very good morning"
b = "very good morning"
print(a is b)

# False
a = []
b = []
print(a is b)

上面的注釋為相應的運行結果。可以看到，由於Python緩存了整數和短字元串，因此每個對象只存有一份。比如，所有整數1的引用都指向同一對象。即使使用賦值語句，也只是創造了新的引用，而不是對象本身。長的字元串和其它對象可以有多個相同的對象，可以使用賦值語句創建出新的對象。

在Python中，每個對象都有存有指向該對象的引用總數，即引用計數(reference count)。
我們可以使用sys包中的getrefcount()，來查看某個對象的引用計數。需要注意的是，當使用某個引用作為參數，傳遞給getrefcount()時，參數實際上創建了一個臨時的引用。因此，getrefcount()所得到的結果，會比期望的多1。

from sys import getrefcount

a = [1, 2, 3]
print(getrefcount(a))

b = a
print(getrefcount(b))

由於上述原因，兩個getrefcount將返回2和3，而不是期望的1和2。

對象引用對象
Python的一個容器對象(container)，比如表、詞典等，可以包含多個對象。實際上，容器對象中包含的並不是元素對象本身，是指向各個元素對象的引用。
我們也可以自定義一個對象，並引用其它對象:

class from_obj(object):
def __init__(self, to_obj):
self.to_obj = to_obj

b = [1,2,3]
a = from_obj(b)
print(id(a.to_obj))
print(id(b))

可以看到，a引用了對象b。

對象引用對象，是Python最基本的構成方式。即使是a = 1這一賦值方式，實際上是讓詞典的一個鍵值"a"的元素引用整數對象1。該詞典對象用於記錄所有的全局引用。該詞典引用了整數對象1。我們可以通過內置函數globals()來查看該詞典。

當一個對象A被另一個對象B引用時，A的引用計數將增加1。

from sys import getrefcount

a = [1, 2, 3]
print(getrefcount(a))

b = [a, a]
print(getrefcount(a))

由於對象b引用了兩次a，a的引用計數增加了2。

容器對象的引用可能構成很復雜的拓撲結構。我們可以用objgraph包來繪制其引用關系，比如
x = [1, 2, 3]
y = [x, dict(key1=x)]
z = [y, (x, y)]

import objgraph
objgraph.show_refs([z], filename='ref_topo.png')

objgraph是Python的一個第三方包。安裝之前需要安裝xdot。
sudo apt-get install xdot
sudo pip install objgraph

objgraph官網

兩個對象可能相互引用，從而構成所謂的引用環(reference cycle)。
a = []
b = [a]
a.append(b)

即使是一個對象，只需要自己引用自己，也能構成引用環。
a = []
a.append(a)
print(getrefcount(a))

引用環會給垃圾回收機制帶來很大的麻煩，我將在後面詳細敘述這一點。

引用減少
某個對象的引用計數可能減少。比如，可以使用del關鍵字刪除某個引用:

from sys import getrefcount

a = [1, 2, 3]
b = a
print(getrefcount(b))

del a
print(getrefcount(b))

del也可以用於刪除容器元素中的元素，比如:

a = [1,2,3]
del a[0]
print(a)

如果某個引用指向對象A，當這個引用被重新定向到某個其他對象B時，對象A的引用計數減少:

from sys import getrefcount

a = [1, 2, 3]
b = a
print(getrefcount(b))

a = 1
print(getrefcount(b))

垃圾回收
吃太多，總會變胖，Python也是這樣。當Python中的對象越來越多，它們將占據越來越大的內存。不過你不用太擔心Python的體形，它會乖巧的在適當的時候「減肥」，啟動垃圾回收(garbage collection)，將沒用的對象清除。在許多語言中都有垃圾回收機制，比如Java和Ruby。盡管最終目的都是塑造苗條的提醒，但不同語言的減肥方案有很大的差異 (這一點可以對比本文和Java內存管理與垃圾回收
)。

從基本原理上，當Python的某個對象的引用計數降為0時，說明沒有任何引用指向該對象，該對象就成為要被回收的垃圾了。比如某個新建對象，它被分配給某個引用，對象的引用計數變為1。如果引用被刪除，對象的引用計數為0，那麼該對象就可以被垃圾回收。比如下面的表:
a = [1, 2, 3]
del a

del a後，已經沒有任何引用指向之前建立的[1, 2, 3]這個表。用戶不可能通過任何方式接觸或者動用這個對象。這個對象如果繼續待在內存里，就成了不健康的脂肪。當垃圾回收啟動時，Python掃描到這個引用計數為0的對象，就將它所佔據的內存清空。

然而，減肥是個昂貴而費力的事情。垃圾回收時，Python不能進行其它的任務。頻繁的垃圾回收將大大降低Python的工作效率。如果內存中的對象不多，就沒有必要總啟動垃圾回收。所以，Python只會在特定條件下，自動啟動垃圾回收。當Python運行時，會記錄其中分配對象(object allocation)和取消分配對象(object deallocation)的次數。當兩者的差值高於某個閾值時，垃圾回收才會啟動。
我們可以通過gc模塊的get_threshold()方法，查看該閾值:
import gc
print(gc.get_threshold())

返回(700, 10, 10)，後面的兩個10是與分代回收相關的閾值，後面可以看到。700即是垃圾回收啟動的閾值。可以通過gc中的set_threshold()方法重新設置。

我們也可以手動啟動垃圾回收，即使用gc.collect()。

分代回收
Python同時採用了分代(generation)回收的策略。這一策略的基本假設是，存活時間越久的對象，越不可能在後面的程序中變成垃圾。我們的程序往往會產生大量的對象，許多對象很快產生和消失，但也有一些對象長期被使用。出於信任和效率，對於這樣一些「長壽」對象，我們相信它們的用處，所以減少在垃圾回收中掃描它們的頻率。

小傢伙要多檢查

Python將所有的對象分為0，1，2三代。所有的新建對象都是0代對象。當某一代對象經歷過垃圾回收，依然存活，那麼它就被歸入下一代對象。垃圾回收啟動時，一定會掃描所有的0代對象。如果0代經過一定次數垃圾回收，那麼就啟動對0代和1代的掃描清理。當1代也經歷了一定次數的垃圾回收後，那麼會啟動對0，1，2，即對所有對象進行掃描。
這兩個次數即上面get_threshold()返回的(700, 10, 10)返回的兩個10。也就是說，每10次0代垃圾回收，會配合1次1代的垃圾回收；而每10次1代的垃圾回收，才會有1次的2代垃圾回收。
同樣可以用set_threshold()來調整，比如對2代對象進行更頻繁的掃描。
import gc
gc.set_threshold(700, 10, 5)

孤立的引用環
引用環的存在會給上面的垃圾回收機制帶來很大的困難。這些引用環可能構成無法使用，但引用計數不為0的一些對象。
a = []
b = [a]
a.append(b)

del a
del b

上面我們先創建了兩個表對象，並引用對方，構成一個引用環。刪除了a，b引用之後，這兩個對象不可能再從程序中調用，就沒有什麼用處了。但是由於引用環的存在，這兩個對象的引用計數都沒有降到0，不會被垃圾回收。

孤立的引用環

為了回收這樣的引用環，Python復制每個對象的引用計數，可以記為gc_ref。假設，每個對象i，該計數為gc_ref_i。Python會遍歷所有的對象i。對於每個對象i引用的對象j，將相應的gc_ref_j減1。

遍歷後的結果

在結束遍歷後，gc_ref不為0的對象，和這些對象引用的對象，以及繼續更下游引用的對象，需要被保留。而其它的對象則被垃圾回收。

④ 能具體說一下嗎

變數是保存存儲值的內存位置。也就是說，當創建一個變數時，可以在內存中保留一些空間。

基於變數的數據類型，解釋器分配內存並決定可以存儲在保留的存儲器中的內容。 因此，通過為變數分配不同的數據類型，可以在這些變數中存儲的數據類型為整數，小數或字元等等。

將值分配給變數

在Python中，變數不需要明確的聲明類型來保留內存空間。當向變數分配值時，Python會自動發出聲明。 等號(=)用於為變數賦值。

=運算符左側的操作數是變數的名稱，而=運算符右側的操作數是將在存儲在變數中的值。 例如 -

#!/usr/bin/python3counter = 100 # 一個整型數miles = 999.99 # 一個浮點數name = "Maxsu" # 一個字元串site_url = "http://www.yii.com" # 一個字元串print (counter)print (miles)print (name)print (site_url)Python

這里，100,999.99和「Maxsu」分別是分配給counter，miles和name變數的值。執行上面代碼將產生以下結果 -

100
999.99
Maxsu
http://www.yii.comShell

多重賦值

Python允許同時為多個變數分配單個值。

例如 -

a = b = c = 1Python

這里，創建一個整數對象，其值為1，並且所有三個變數都分配給相同的內存位置。還可以將多個對象分配給多個變數。 例如 -

a, b, c = 10, 20, "maxsu"Python

這里，將兩個值為10和20的整數對象分別分配給變數a和b，並將一個值為「maxsu」的字元串對象分配給變數c。

標准數據類型

存儲在內存中的數據可以是多種類型。 例如，一個人的年齡可存儲為一個數字值，他的地址被存儲為字母數字字元串。 Python具有各種標准數據類型，用於定義可能的操作以及每個標准數據類型的存儲方法。

Python有五種標准數據類型 -

• 1.數字

• 2.字元串

• 3.列表

• 4.元組

• 5.字典

1.Python數字

數字數據類型存儲數字值。當為其分配值時，將創建數字對象。 例如 -

• var1 = 10var2 = 20Python



可以使用del語句刪除對數字對象的引用。del語句的語法是 -

• del var1[,var2[,var3[....,varN]]]]Python



可以使用del語句刪除單個對象或多個對象。

例如 -

• del vardel var_a, var_bPython



Python支持三種不同的數值類型 -

• int(有符號整數)

• float(浮點實值)

• complex(復數)

Python3中的所有整數都表示為長整數。 因此，長整數沒有單獨的數字類型。

例子

以下是一些數字示例 -

int

float

complex

10 0.0 3.14j

100 15.20 45.j

-786 -21.9 9.322e-36j

080 32.3+e18 .876j

-0490 -90. -.6545+0J

-0x260 -32.54e100 3e+26J

0x69 70.2-E12 4.53e-7j

復數是由x + yj表示的有序對的實數浮點數組成，其中x和y是實數，j是虛數單位。

2.Python字元串

Python中的字元串被標識為在引號中表示的連續字元集。Python允許雙引號或雙引號。 可以使用片段運算符([]和[:])來獲取字元串的子集(子字元串)，其索引從字元串開始處的索引0開始，並且以-1表示字元串中的最後一個字元。

加號(+)是字元串連接運算符，星號(*)是重復運算符。例如 -

• #!/usr/bin/python3#coding=utf-8# save file: variable_types_str1.pystr = 'yii.com'print ('str = ', str) # Prints complete stringprint ('str[0] = ',str[0]) # Prints first character of the stringprint ('str[2:5] = ',str[2:5]) # Prints characters starting from 3rd to 5thprint ('str[2:] = ',str[2:]) # Prints string starting from 3rd characterprint ('str[-1] = ',str[-1]) # 最後一個字元，結果為：'!'print ('str * 2 = ',str * 2) # Prints string two timesprint ('str + "TEST" = ',str + "TEST") # Prints concatenated stringPython



將上面代碼保存到variable_types_str1.py文件中，執行將產生以下結果 -

• F:worksppython>python variable_types_str1.py


• str = yii.com


• str[0] = y


• str[2:5] = iba


• str[2:] = i.com


• str[-1] = m


• str * 2 = yii.comyii.com


• str + "TEST" = yii.comTEST



• F:worksppython>Shell



2.Python列表

列表是Python復合數據類型中最多功能的。 一個列表包含用逗號分隔並括在方括弧([])中的項目。在某種程度上，列表類似於C語言中的數組。它們之間的區別之一是Python列表的所有項可以是不同的數據類型，而C語言中的數組只能是同種類型。

存儲在列表中的值可以使用切片運算符([]和[])來訪問，索引從列表開頭的0開始，並且以-1表示列表中的最後一個項目。 加號(+)是列表連接運算符，星號(*)是重復運算符。例如 -

• #!/usr/bin/python3#coding=utf-8# save file: variable_types_str1.pylist = [ 'yes', 'no', 786 , 2.23, 'minsu', 70.2 ]tinylist = [100, 'maxsu']print ('list = ', list) # Prints complete listprint ('list[0] = ',list[0]) # Prints first element of the listprint ('list[1:3] = ',list[1:3]) # Prints elements starting from 2nd till 3rd print ('list[2:] = ',list[2:]) # Prints elements starting from 3rd elementprint ('list[-3:-1] = ',list[-3:-1]) print ('tinylist * 2 = ',tinylist * 2) # Prints list two timesprint ('list + tinylist = ', list + tinylist) # Prints concatenated listsPython



將上面代碼保存到variable_types_str1.py文件中，執行將產生以下結果 -

• F:worksppython>python variable_types_list.py


• list = ['yes', 'no', 786, 2.23, 'minsu', 70.2]


• list[0] = yes


• list[1:3] = ['no', 786]


• list[2:] = [786, 2.23, 'minsu', 70.2]


• list[-3:-1] = [2.23, 'minsu']


• tinylist * 2 = [100, 'maxsu', 100, 'maxsu']


• list + tinylist = ['yes', 'no', 786, 2.23, 'minsu', 70.2, 100, 'maxsu']



• F:worksppython>Shell



3.Python元組

元組是與列表非常類似的另一個序列數據類型。元組是由多個值以逗號分隔。然而，與列表不同，元組被括在小括弧內(())。

列表和元組之間的主要區別是 - 列表括在括弧([])中，列表中的元素和大小可以更改，而元組括在括弧(())中，無法更新。元組可以被認為是只讀列表。 例如 -

• #!/usr/bin/python3#coding=utf-8# save file : variable_types_tuple.pytuple = ( 'maxsu', 786 , 2.23, 'yii', 70.2 )tinytuple = (999.0, 'maxsu')# tuple[1] = 'new item value' 不能這樣賦值print ('tuple = ', tuple) # Prints complete tupleprint ('tuple[0] = ', tuple[0]) # Prints first element of the tupleprint ('tuple[1:3] = ', tuple[1:3]) # Prints elements starting from 2nd till 3rd print ('tuple[-3:-1] = ', tuple[-3:-1]) # 輸出結果是什麼？print ('tuple[2:] = ', tuple[2:]) # Prints elements starting from 3rd elementprint ('tinytuple * 2 = ',tinytuple * 2) # Prints tuple two timesprint ('tuple + tinytuple = ', tuple + tinytuple) # Prints concatenated tuplePython



將上面代碼保存到variable_types_tuple.py文件中，執行將產生以下結果 -

• F:worksppython>python variable_types_tuple.py


• tuple = ('maxsu', 786, 2.23, 'yii', 70.2)


• tuple[0] = maxsu


• tuple[1:3] = (786, 2.23)


• tuple[-3:-1] = (2.23, 'yii')


• tuple[2:] = (2.23, 'yii', 70.2)


• tinytuple * 2 = (999.0, 'maxsu', 999.0, 'maxsu')


• tuple + tinytuple = ('maxsu', 786, 2.23, 'yii', 70.2, 999.0, 'maxsu')



• F:worksppython>Shell



以下代碼對於元組無效，因為嘗試更新元組，但是元組是不允許更新的。類似的情況可能與列表 -

• #!/usr/bin/python3tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]tuple[2] = 1000 # 無法更新值，程序出錯list[2] = 1000 # 有效的更新，合法Python



Python字典

Python的字典是一種哈希表類型。它們像Perl中發現的關聯數組或散列一樣工作，由鍵值對組成。字典鍵幾乎可以是任何Python數據類型，但通常為了方便使用數字或字元串。另一方面，值可以是任意任意的Python對象。

字典由大括弧({})括起來，可以使用方括弧([])分配和訪問值。例如 -

• #!/usr/bin/python3#coding=utf-8# save file : variable_types_dict.pydict = {}dict['one'] = "This is one"dict[2] = "This is my"tinydict = {'name': 'maxsu', 'code' : 1024, 'dept':'IT Dev'}print ("dict['one'] = ", dict['one']) # Prints value for 'one' keyprint ('dict[2] = ', dict[2]) # Prints value for 2 keyprint ('tinydict = ', tinydict) # Prints complete dictionaryprint ('tinydict.keys() = ', tinydict.keys()) # Prints all the keysprint ('tinydict.values() = ', tinydict.values()) # Prints all the valuesPython



將上面代碼保存到variable_types_dict.py文件中，執行將產生以下結果 -

• F:worksppython>python variable_types_dict.py


• dict['one'] = This is one


• dict[2] = This is my


• tinydict = {'name': 'maxsu', 'code': 1024, 'dept': 'IT Dev'}


• tinydict.keys() = dict_keys(['name', 'code', 'dept'])


• tinydict.values() = dict_values(['maxsu', 1024, 'IT Dev'])Shell



字典中的元素沒有順序的概念。但是說這些元素是「亂序」是不正確的; 它們是無序的。

數據類型轉換

有時，可能需要在內置類型之間執行轉換。要在類型之間進行轉換，只需使用類型名稱作為函數即可。

有以下幾種內置函數用於執行從一種數據類型到另一種數據類型的轉換。這些函數返回一個表示轉換值的新對象。它們分別如下所示 -

編號

函數

描述

1 int(x [,base]) 將x轉換為整數。如果x是字元串，則要base指定基數。

2 float(x) 將x轉換為浮點數。

3 complex(real [,imag]) 創建一個復數。

4 str(x) 將對象x轉換為字元串表示形式。

5 repr(x) 將對象x轉換為表達式字元串。

6 eval(str) 評估求值一個字元串並返回一個對象。

7 tuple(s) 將s轉換為元組。

8 list(s) 將s轉換為列表。

9 set(s) 將s轉換為集合。

10 dict(d) 創建一個字典，d必須是(key，value)元組的序列

11 frozenset(s) 將s轉換為凍結集

12 chr(x) 將整數x轉換為字元

13 unichr(x) 將整數x轉換為Unicode字元。

14 ord(x) 將單個字元x轉換為其整數值。

15 hex(x) 將整數x轉換為十六進制字元串。

16 oct(x) 將整數x轉換為八進制字元串。

⑤ python怎麼創建類的對象

定義的類只有進行實例化，也就是使用該類創建對象之後，才能得到利用。總的來說，實例化後的類對象可以執行以下操作：

• 訪問或修改類對象具有的實例變數，甚至可以添加新的實例變數或者刪除已有的實例變數；

• 調用類對象的方法，包括調用現有的方法，以及給類對象動態添加方法。

⑥ python為什麼是面向對象的

Python雖然是解釋型語言，但從設計之初就已經是一門面向對象的語言，對於Python來說一切皆為對象。正因為如此，在Python中創建一個類和對象是很容易的，當然如果習慣面向過程或者函數的寫法也是可以的，Python並不做硬性的限制。
Python的面向對象特徵如下：
封裝
面向對象程序設計中的術語對象(Object)基本上可以看做數據(特性)以及由一系列可以存取、操作這些數據的方法所組成的集合。傳統意義上的「程序=數據結構+演算法」被封裝」掩蓋「並簡化為「程序=對象+消息」。對象是類的實例，類的抽象則需要經過封裝。封裝可以讓調用者不用關心對象是如何構建的而直接進行使用。
繼承
類繼承：
繼承給人的直接感覺是這是一種復用代碼的行為。繼承可以理解為它是以普通的類為基礎建立專門的類對象，子類和它繼承的父類是IS-A的關系。
多重繼承：
不同於C#，Python是支持多重類繼承的(C#可繼承自多個Interface，但最多繼承自一個類)。多重繼承機制有時很好用，但是它容易讓事情變得復雜。
多態
多態意味著可以對不同的對象使用同樣的操作，但它們可能會以多種形態呈現出結果。在Python中，任何不知道對象到底是什麼類型，但又需要對象做點什麼的時候，都會用到多態。方法是多態的，運算符也是多態的。
相關推薦：《Python教程》以上就是小編分享的關於python為什麼是面向對象的的詳細內容希望對大家有所幫助，更多有關python教程請關注環球青藤其它相關文章！