【Python原始碼剖析】物件模型概述

• 一切皆物件
• 型別、物件體系
• 變數只是名字
• 可變物件 與 不可變物件
• 定長物件 與 變長物件
• 更多章節
• 附錄

Python 是一門 面向物件 語言，實作了一個完整的面向物件體系，簡潔而優雅，

與其他面向物件編程語言相比， Python 有自己獨特的一面， 這讓很多開發人員在學習 Python 時，多少有些無所適從， 那么，Python 物件模型都有哪些特色呢？

一切皆物件

首先，在 Python 世界， 基本型別也是物件 ，與通常意義的“物件”形成一個有機統一， 換句話講， Python 不再區別對待基本型別和物件，所有基本型別內部均由物件實作， 一個整數是一個物件，一個字串也是一個物件：

>>> a = 1
>>> b = 'abc'

其次， Python 中的 型別也是一種物件 ，稱為 型別物件 ， 整數型別是一個物件，字串型別是一個物件，程式中通過 class 關鍵字定義的類也是一個物件，

舉個例子，整數型別在 Python 內部是一個物件，稱為 型別物件 ：

>>> int
<class 'int'>

通過整數型別 實體化 可以得到一個整數物件，稱為 實體物件 ：

>>> int('1024')
1024

面向物件理論中的“ 類 ”和“ 物件 ”這兩個基本概念，在 Python 內部都是通過物件實作的，這是 Python 最大的特點，

型別、物件體系

a 是一個整數物件( 實體物件 )，其型別是整數型別( 型別物件 )：

>>> a = 1
>>> type(a)
<class 'int'>
>>> isinstance(a, int)
True

那么整數型別的型別又是什么呢？

>>> type(int)
<class 'type'>

可以看到，整數型別的型別還是一種型別，即 型別的型別 ， 只是這個型別比較特殊，它的實體物件還是型別物件，

Python 中還有一個特殊型別 object ，所有其他型別均繼承于 object ，換句話講 object 是所有型別的基類：

>>> issubclass(int, object)
True

綜合以上關系，得到以下關系圖：

內置型別已經搞清楚了，自定義型別及物件關系又如何呢？定義一個簡單的類來實驗：

class Dog(object):

    def yelp(self):
        print('woof')

創建一個 Dog 實體，毫無疑問，其型別是 Dog ：

>>> dog = Dog()
>>> dog.yelp()
woof
>>> type(dog)
<class '__main__.Dog'>

Dog 類的型別自然也是 type ，其基類是 object (就算不顯式繼承也是如此)：

>>> type(Dog)
<class 'type'>
>>> issubclass(Dog, object)
True

自定義子類及實體物件在圖中又處于什么位置？定義一個獵犬類進行實驗：

class Sleuth(Dog):

    def hunt(self):
        pass

可以看到， 獵犬物件( sleuth )是獵犬類( Sleuth )的實體， Sleuth 的型別同樣是 type ：

>>> sleuth = Sleuth()
>>> sleuth.hunt()
>>> type(sleuth)
<class '__main__.Sleuth'>
>>> type(Sleuth)
<class 'type'>

同時， Sleuth 類繼承自 Dog 類，是 Dog 的子類，當然也是 object 的子類：

>>> issubclass(Sleuth, Dog)
True
>>> issubclass(Sleuth, object)
True

現在不可避免需要討論 type 以及 object 這兩個特殊的型別，

理論上， object 是所有型別的 基類 ，本質上是一種型別，因此其型別必然是 type ， 而 type 是所有型別的型別，本質上也是一種型別，因此其型別必須是它自己！

>>> type(object)
<class 'type'>
>>> type(object) is type
True

>>> type(type)
<class 'type'>
>>> type(type) is type
True

另外，由于 object 是所有型別的 基類 ，理論上也是 type 的基類( __base__ 屬性)：

>>> issubclass(type, object)
True
>>> type.__base__
<class 'object'>

但是 object 自身便不能有基類了，為什么呢？ 對于存在繼承關系的類，成員屬性和成員方法查找需要回溯繼承鏈，不斷查找基類， 因此，繼承鏈必須有一個終點，不然就死回圈了，

這就完整了！

可以看到，所有型別的基類收斂于 object ，所有型別的型別都是 type ，包括它自己！ 這就是 Python 型別、物件體系全圖，設計簡潔、優雅、嚴謹，

該圖將成為后續閱讀原始碼、探索 Python 物件模型的有力工具，像地圖一樣指明方向， 圖中所有物體在 Python 內部均以物件形式存在，至于物件到底長啥樣，相互關系如何描述，這些問題先按下不表，后續一起到原始碼中探尋答案，

變數只是名字

先看一個例子，定義一個變數 a ，并通過 id 內建函式取出其“地址”：

>>> a = 1
>>> id(a)
4302704784

定義另一個變數 b ，以 a 賦值，并取出 b 的“地址”：

>>> b = a
>>> id(b)
4302704784

驚奇地看到， a 和 b 這兩個變數的地址居然是相同的！這不合常理呀！

對于大多數語言( C 語言為例)，定義變數 a 即為其分配記憶體并存盤變數值：

變數 b 記憶體空間與 a 獨立，賦值時進行拷貝：

在 Python 中，一切皆物件，整數也是如此， 變數只是一個與物件關聯的名字 ：

而變數賦值，只是將當前物件與另一個名字進行關聯，背后的物件是同一個：

因此，在 Python 內部，變數只是一個名字，保存指向實際物件的指標，進而與其系結， 變數賦值只拷貝指標，并不拷貝指標背后的物件，

可變物件 與 不可變物件

定義一個整數變數：

>>> a = 1
>>> id(a)
4302704784

然后，對其自增 1 ：

>>> a += 1
>>> a
2
>>> id(a)
4302704816

數值符合預期，但是物件變了！初學者一臉懵逼，這是什么鬼？

一切要從 可變物件 和 不可變物件 說起， 可變物件 在物件創建后，其值可以進行修改； 而 不可變物件 在物件創建后的整個生命周期，其值都不可修改，

在 Python 中，整數型別是不可變型別， 整數物件是不可變物件， 修改整數物件時， Python 將以新數值創建一個新物件，變數名與新物件進行系結； 舊物件如無其他參考，將被釋放，

每次修改整數物件都要創建新物件、回收舊物件，效率不是很低嗎？ 確實是， 后續章節將從原始碼角度來解答： Python 如何通過 小整數池 等手段進行優化，

可變物件是指創建后可以修改的物件，典型的例子是 串列 ( list )：

>>> l = [1, 2]
>>> l
[1, 2]
>>> id(l)
4385900424

往串列里頭追加資料，發現串列物件還是原來那個，只不過多了一個元素了：

>>> l.append(3)
>>> l
[1, 2, 3]
>>> id(l)
4385900424

實際上，串列物件內部維護了一個 動態陣列 ，存盤元素物件的指標：

串列物件增減元素，需要修改該陣列，例如，追加元素 3 ：

定長物件 與 變長物件

Python 一個物件多大呢？相同型別物件大小是否相同呢？ 想回答類似的問題，需要考察影響物件大小的因素，

標準庫 sys 模塊提供了一個查看物件大小的函式 getsizeof ：

>>> import sys
>>> sys.getsizeof(1)
28

先觀察整數物件：

>>> sys.getsizeof(1)
28
>>> sys.getsizeof(100000000000000000)
32
>>> sys.getsizeof(100000000000000000000000000000000000000000000)
44

可見整數物件的大小跟其數值有關，像這樣 大小不固定 的物件稱為 變長物件 ，

我們知道，位數固定的整數能夠表示的數值范圍是有限的，可能導致 溢位 ， Python 為解決這個問題，采用類似 C++ 中 大整數類 的思路實作整數物件 —— 串聯多個普通 32 位整數，以便支持更大的數值范圍， 至于需要多少個 32 位整數，則視具體數值而定，數值不大的一個足矣，避免浪費，

這樣一來，整數物件需要在頭部額外存盤一些資訊，記錄物件用了多少個 32 位整數， 這就是變長物件典型的結構，先有個大概印象即可，后續講解整數物件原始碼時再展開，

接著觀察字串物件：

>>> sys.getsizeof('a')
50
>>> sys.getsizeof('abc')
52

字串物件也是變長物件，這個行為非常好理解，畢竟字串長度不盡相同嘛， 此外，注意到字串物件大小比字串本身大，因為物件同樣需要維護一些額外的資訊， 至于具體需要維護哪些資訊，同樣留到原始碼剖析環節中詳細介紹，

那么，有啥物件是定長的呢？—— 浮點數物件 float ：

>>> sys.getsizeof(1.)
24
>>> sys.getsizeof(1000000000000000000000000000000000.)
24

浮點數背后是由一個 double 實作，就算表示很大的數，浮點數物件的大小也不變，

為啥 64 位的 double 可以表示這么大的范圍呢？答案是：犧牲了精度，

>>> int(1000000000000000000000000000000000.)
999999999999999945575230987042816

由于浮點數存盤位數是固定的，它能表示的數值范圍也是有限的，超出便會拋錨：

>>> 10. ** 1000
Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
OverflowError: (34, 'Result too large')

更多章節

洞悉 Python 虛擬機運行機制，探索高效程式設計之道！

到底如何才能提升我的 Python 開發水平，向更高一級的崗位邁進？ 如果你有這些問題或者疑惑，請訂閱我們的專欄，閱讀更多章節：

• 內建物件
• 虛擬機
• 函式機制
• 類機制
• 生成器與協程
• 記憶體管理機制

附錄

更多 Python 技術文章請訪問：小菜學Python，轉至 原文 可獲得最佳閱讀體驗，

訂閱更新，獲取更多學習資料，請關注 小菜學編程 ：

標籤：Python

上一篇：Python：串列和串列的增刪改查

下一篇：DWTT自動評定系統演算法研究、界面及其邏輯設計