在Python中，對象就是在堆上申請的結(jié)構(gòu)體，對象不能是被靜態(tài)初始化的，并且也不能是在棧空間上生存的。唯一的例外就是類型對象(type object)，Python中所有的類型對象都是被靜態(tài)初始化的。

AD：2014WOT全球軟件技術(shù)峰會北京站 課程視頻發(fā)布

本篇文章主要是對Python?進(jìn)行詳解，內(nèi)容是介紹Python?源碼之對象機(jī)制，先來看內(nèi)容。

1、對象

在Python的世界中，一切都是對象，一個整數(shù)是一個對象，一個字符串也是一個對象，更為奇妙的是，類型也是一個對象，整數(shù)類型是一個對象，字符串類型也是一個對象。從1980年Guido在那個圣誕節(jié)揭開Python世界的大幕開始，一直到現(xiàn)在，Python經(jīng)歷了一次一次的升級，但是其實現(xiàn)語言一直都是ANSI C。我們知道，C并不是一個面向?qū)ο蟮恼Z言，那么在Python中，它的對象機(jī)制是如何實現(xiàn)的呢？

對于人的思維來說，對象是一個比較形象的概念，而對于計算機(jī)來說，對象實際上是一個抽象的概念。計算機(jī)并不能理解這是一個整數(shù)，那是一個字符串，對于計算機(jī)來說，它所知道的一切都是字節(jié)。通常的說法是，對象是數(shù)據(jù)以及基于這些數(shù)據(jù)的操作的集合。在計算機(jī)上，一個對象實際上就是一片被分配的內(nèi)存空間，這些內(nèi)存可能是連續(xù)的，也有可能是離散的，這都不重要，重要的是這片內(nèi)存在更高的層次上可以作為一個整體來考慮，這個整體就是一個對象。在這片內(nèi)存中，存儲著一系列的數(shù)據(jù)以及可以對這些數(shù)據(jù)進(jìn)行修改或讀取的一系列操作的代碼。

在Python中，對象就是在堆上申請的結(jié)構(gòu)體，對象不能是被靜態(tài)初始化的，并且也不能是在棧空間上生存的。唯一的例外就是類型對象(type object)，Python中所有的類型對象都是被靜態(tài)初始化的。

在Python中，一個對象一旦被創(chuàng)建，它在內(nèi)存中的大小就是不變的了。這就意味著那些需要容納可變長度數(shù)據(jù)的對象只能在對象內(nèi)維護(hù)一個指向一個可變大小的內(nèi)存區(qū)域的指針。為什么要設(shè)定這樣一條特殊的規(guī)則呢，因為遵循這樣的規(guī)則可以使通過指針維護(hù)對象的工作變得非常的簡單。因為一旦允許對象的大小可在運行期改變，我們可以考慮如下的情形。在內(nèi)存中有對象A，并且其后緊跟著對象B。如果運行期某個時刻，A的大小增大了，這意味著必須將整個A移動到內(nèi)存中的其他位置，否則A增大的部分將覆蓋原本屬于B的數(shù)據(jù)。一旦將A移動到內(nèi)存中的其他位置，那么所有指向A的指針必須立即得到更新，光是想一想，就知道這樣的工作是多么的恐怖。

在Python中，所有的東西都是對象，而所有的對象都擁有一些相同的內(nèi)容，這些內(nèi)容在PyObject中定義，PyObject是整個Python對象機(jī)制的核心。

[object.h]? ?

typedef?struct?_object?{? ?

PyObject_HEAD? ?

}?PyObject;??

實際上，PyObject是Python中不包含可變長度數(shù)據(jù)的對象的基石，而對于包含可變長度數(shù)據(jù)的對象，它的基石是PyVarObject：

[object.h]? ?

typedef?struct?{????PyObject_VAR_HEAD}?PyVarObject;?

這兩個結(jié)構(gòu)體構(gòu)成了Python對象機(jī)制的核心基石，從代碼中我們可以看到，Python的對象的秘密都隱藏在PyObject_HEAD與PyObject_VAR_HEAD中。

[object.h]? ?

?

#ifdef?Py_TRACE_REFS ?

/*?Define?pointers?to?support?a?doubly-linked?list?of?all?live?heap?objects.?*/ ?

#define?_PyObject_HEAD_EXTRA?\???? ?

struct?_object?*_ob_next;???\ ?

????struct?_object?*_ob_prev; ?

#define?_PyObject_EXTRA_INIT?0,?0,#else#define?_PyObject_HEAD_EXTRA#define?_PyObject_EXTRA_INIT#endif ?

/*?PyObject_HEAD?defines?the?initial?segment?of?every?PyObject.?*/ ?

#define?PyObject_HEAD??????????\???? ?

_PyObject_HEAD_EXTRA????????\ ?

????int?ob_refcnt;??\???? ?

struct?_typeobject?*ob_type;#define?PyObject_VAR_HEAD???????\? ?

???PyObject_HEAD???????????\???? ?

int?ob_size; ?

?/*?Number?of?items?in?variable?part?*/?

在PyObject_HEAD中定義了每一個Python對象都必須有的內(nèi)容，這些內(nèi)容將出現(xiàn)在每一個Python對象所占有的內(nèi)存的最開始的字節(jié)中，從PyObject_VAR_HEAD的定義可以看出，即使對于擁有可變大小數(shù)據(jù)的對象，其最開始的字節(jié)也含有相同的內(nèi)容，這就是說，在Python中，每一個對象都擁有相同的對象頭部。這就使得在Python中，對對象的引用變得非常的統(tǒng)一，我們只需要用一個PyObject *就可以引用任意的一個對象，而不論該對象實際是一個什么對象。

在PyObject_HEAD的定義中，我們注意到有一個ob_refcnt的整形變量，這個變量的作用是實現(xiàn)引用計數(shù)機(jī)制。對于某一個對象A，當(dāng)有一個新的PyObject *引用該對象時，A的引用計數(shù)應(yīng)該增加；而當(dāng)這個PyObject *被刪除時，A的引用計數(shù)應(yīng)該減少。當(dāng)A的引用計數(shù)減少到0時，A就可以從堆上被刪除，以釋放出內(nèi)存供別的對象使用。

在PyObject_HEAD中，我們注意到ob_type是一個指向_typeobject結(jié)構(gòu)體的指針，那么這個結(jié)構(gòu)體是一個什么東西呢？實際上這個結(jié)構(gòu)體也是一個對象，它是用來指定一個對象類型的類型對象。這個類型對象我們將在后邊詳細(xì)地考察。現(xiàn)在我們看到了，在Python中實際上對象機(jī)制的核心非常的簡單，一個是引用計數(shù)，一個就是類型。

而對于擁有可變長度數(shù)據(jù)的對象，這樣的對象通常都是容器，我們可以在PyObject_VAR_HEAD中看到ob_size這個變量，這個變量實際上就是指明了該對象中一共包含了多少個元素。注意，ob_size指明的是元素的個數(shù)，而不是字節(jié)的數(shù)目。比如對于Python中最常用的list，它就是一個PyVarObject對象，如果某一時刻，這個list中有5個元素，那么PyVarObject.ob_size的值就是5。

2、類型對象

在上面的描述中，我們看到了Python中所有對象的對象頭的定義。所以，當(dāng)內(nèi)存中存在某一個Python的對象時，該對象的開始的幾個字節(jié)的含義一定會符合我們的預(yù)期。但是，當(dāng)我們把眼光沿著時間軸上溯，就會發(fā)現(xiàn)一個問題。當(dāng)在內(nèi)存中分配空間，創(chuàng)建對象的時候，毫無疑問地，必須要知道申請多大的空間。顯然，這不會是一個定值，因為對于不同的對象，需要不同的空間，一個整數(shù)對象和一個字符串對象所需的空間肯定不同。那么，對象所需的內(nèi)存空間的大小的信息到底在哪里呢？在對象頭中顯然沒有這樣的信息。

實際上，內(nèi)存空間大小這樣的對象的元信息是與對象所屬類型密切相關(guān)的，因此它一定會出現(xiàn)在與對象所對應(yīng)的類型對象中。現(xiàn)在我們可以來詳細(xì)考察一下類型對象_typeobject：?

[object.h]? ?

?

typedef?struct?_typeobject?{ ?

????PyObject_VAR_HEAD????char?*tp_name; ?

?/*?For?printing,?in?format?"<module>.<name>"?*/? ?

???int?tp_basicsize,?tp_itemsize; ?

?/*?For?allocation?*/ ?

????/*?Methods?to?implement?standard?operations?*/ ?

????destructor?tp_dealloc;printfunc?tp_print; ?

…… ?

????/*?More?standard?operations?(here?for?binary?compatibility)?*/ ?

????hashfunc?tp_hash;? ?

???ternaryfunc?tp_call; ?

????…… ?

}? ?

PyTypeObject;?

在_typeobject的定義中包含了許多的信息，主要可以分為四類：

1、類型名，tp_name，主要是Python內(nèi)部以及調(diào)試的時候使用；

2、創(chuàng)建該類型對象是分配內(nèi)存空間的大小的信息，即tp_basicsize和tp_itemsize；

3、與該類型對象相關(guān)聯(lián)的操作信息，比如hashfunc，tp_hash就指明對于該類型的對象，如何生成其hash值。在Object.h中可以看到，hashfunc實際上是一個函數(shù)指針：typedef long (*hashfunc)(PyObject *); 在_typeobject中，包含了大量的函數(shù)指針，這些函數(shù)指針將用來指定某個類型的操作信息。這些操作主要分為標(biāo)準(zhǔn)操作(dealloc, print, compare)，標(biāo)準(zhǔn)操作族(numbers, sequences, mappings)，以及其他操作（hash, buffer, call…）。

4、我們在下邊將要描述的類型的類型信息。

有趣的是我們在_typeobject的頭部發(fā)現(xiàn)了PyObject_VAR_HEAD，這意味著類型實際上也是一個對象。我們知道在Python中，每一個對象都是對應(yīng)一種類型的，那么一個有趣的問題就出現(xiàn)了，類型對象的類型是什么呢？這個問題聽上去很繞口，實際上確非常重要，對于其他的對象，可以通過與其關(guān)聯(lián)的類型對象確定其類型，那么通過什么來確定一個對象是類型對象呢？答案就是PyType_Type：

[typeobject.c]? ?

?

PyTypeObject?PyType_Type?=?{ ?

????PyObject_HEAD_INIT(&PyType_Type)????0, ?

??????????????????/*?ob_size?*/????"type", ?

?????????????????/*?tp_name?*/????sizeof(PyHeapTypeObject), ?

???????/*?tp_basicsize?*/????sizeof(PyMemberDef), ?

????????????/*?tp_itemsize?*/????……????PyObject_GC_Del, ?

????????????????/*?tp_free?*/????(inquiry)type_is_gc, ?

????????????/*?tp_is_gc?*/};?

前面提到，在Python中，每一個對象它的開始部分都是一樣的。每一個對象都將自己的引用計數(shù)，類型信息保存在開始的部分中。為了方便對這部分內(nèi)存的初始化，Python中提供了幾個有用的宏：

[object.h]#ifdef?Py_TRACE_REFS#define?_PyObject_EXTRA_INIT?0,?0,#else#define?_PyObject_EXTRA_INIT#endif#define?PyObject_HEAD_INIT(type)????\

???_PyObject_EXTRA_INIT????????\? ?

???1,?type,?

再回顧一下PyObject和PyVarObject的定義，初始化的動作就一目了然了。實際上，這些宏在類型對象的初始化中被大量地使用著。

如果以一個整數(shù)對象為例，可以更清晰地看到一半的類型對象和這個特立獨行的PyType_Type對象之間的關(guān)系：

[intobject.c]? ?

PyTypeObject?PyInt_Type?=?{ ?

????PyObject_HEAD_INIT(&PyType_Type)????0, ?

????"int", ?

????sizeof(PyIntObject), ?

????…… ?

};?

現(xiàn)在我們可以放飛想象，看到一個整數(shù)對象在運行時的抽象的表示了，下圖中的箭頭表示ob_type：

?

3、對象間的繼承和多態(tài)

通過PyObject和類型對象，Python利用C語言完成了C++所提供的繼承和多態(tài)的特性。前面提到，在Python中所有的內(nèi)建對象（PyIntObject等）和內(nèi)部使用對象（PyCodeObject等）的最開始的內(nèi)存區(qū)域都擁有一個PyObject。實際上，這一點可以視為PyIntObject，PyCodeObject等對象都是從PyObject繼承而來。

在Python創(chuàng)建一個對象，比如PyIntObject對象時，會分配內(nèi)存，進(jìn)行初始化。然后這個對象會由一個PyObject*變量來維護(hù)，而不是通過一個PyIntObject*指針來維護(hù)。其它對象也與此類似，所以在Python內(nèi)部各個函數(shù)之間傳遞的都是一種范型指針PyObject*。這個指針?biāo)傅膶ο缶烤故鞘裁搭愋偷?#xff0c;不知道，只能從指針?biāo)笇ο蟮膐b_type域判斷，而正是通過這個域，Python實現(xiàn)了多態(tài)機(jī)制。

考慮下面的代碼：

void?Print(PyObject*?object)? ?

{? ?

object->ob_type->tp_print(object);? ?

}??

如果傳給Print的指針實際是一個PyIntObject*，那么就會調(diào)用PyIntObject對象對應(yīng)的類型對象中定義的輸出操作，如果傳給Print的指針實際是一個PyStringObject*，那么就會調(diào)用PyStringObject對象對應(yīng)的類型對象中定義的輸出操作。可以看到，這里同一個函數(shù)在不同情況下表現(xiàn)出了不同的行為，這正是多態(tài)的核心所在。

在object.c中，Python實現(xiàn)了一些對于類型對象中的各種操作的簡單包裝，從而為Python運行時提供了一個統(tǒng)一的多態(tài)接口層：

[object.c]? ?

long?PyObject_Hash(PyObject?*v)? ?

{? ?

PyTypeObject?*tp?=?v->ob_type;? ?

if?(tp->tp_hash?!=?NULL)? ?

return?(*tp->tp_hash)(v);? ?

????……? ?

}??

4、引用計數(shù)

在C或C++中，程序員被賦予了極大的自由，可以任意地申請內(nèi)存。但是權(quán)利的另一面則對應(yīng)著責(zé)任，程序員必須自己負(fù)責(zé)將申請的內(nèi)存釋放，并釋放無效指針。可以說，這一點正是萬惡之源，大量的內(nèi)存泄露和懸空指針的bug由此而生，如黃河泛濫一發(fā)不可收拾 ：）

現(xiàn)代的開發(fā)語言中一般都選擇由語言本身負(fù)責(zé)內(nèi)存的管理和維護(hù)，即采用了垃圾收集機(jī)制，比如Java和C#。垃圾收集機(jī)制使開發(fā)人員從維護(hù)內(nèi)存分配和清理的繁重工作中解放出來，但同時也剝奪了程序員與內(nèi)存親密接觸的機(jī)會，并付出了一定的運行時效率作為代價。現(xiàn)在看來，隨著垃圾收集機(jī)制的完善，對時間要求不是非常高的程序完全可以通過使用垃圾收集機(jī)制的語言來完成，這部分程序占了這個星球上大多數(shù)的程序。這樣做的好處是提高了開發(fā)效率，并降低了bug發(fā)生的機(jī)率。Python同樣也內(nèi)建了垃圾收集機(jī)制，代替程序員進(jìn)行繁重的內(nèi)存管理工作，而引用計數(shù)正式Python垃圾收集機(jī)制的一部分。

Python通過對一個對象的引用計數(shù)的管理來維護(hù)對象在內(nèi)存中的生存。我們知道在Python中每一個東西都是一個對象，都有一個ob_refcnt變量，正是這個變量維護(hù)著該對象的引用計數(shù)，從而也最終決定著該對象的生生滅滅。

在Python中，主要是通過Py_INCREF(op)和Py_DECREF(op)兩個宏來增加和減少一個對象的引用計數(shù)。當(dāng)一個對象的引用計數(shù)減少到0之后，Py_DECREF將調(diào)用該對象的析構(gòu)函數(shù)（deallocator function）來釋放該對象所占有的內(nèi)存和系統(tǒng)資源。注意這里的析構(gòu)函數(shù)借用了C++的詞匯，實際上這個析構(gòu)動作是通過在對象對應(yīng)的類型對象中定義的一個函數(shù)指針來刻畫的，還記得嗎？就是那個tp_dealloc。

如果熟悉設(shè)計模式中Observer模式，可以看到，這里隱隱約約透著Observer模式的影子。在ob_refcnt減為0之后，將觸發(fā)對象銷毀的事件；從Python的對象體系來看，各個對象又提供了不同的事件處理函數(shù)，而事件的注冊動作正是在各個對象對應(yīng)的類型對象中靜態(tài)完成的。

對于這兩個宏的參數(shù)op來說，不允許op是一個指向空對象的指針(NIL)，如果op是一個NIL，那么必須使用Py_XINCREF/Py_XDECREF這一對宏。

在PyObject中我們看到ob_refcnt是一個32位的整形變量，這實際是一個Python所做的假設(shè)，即對一個對象的引用不會超過一個整形變量的最大值。一般情況下，如果不是惡意代碼，這個假設(shè)顯然是不會被突破的。

需要注意的是，在Python的各種對象中，類型對象是超越引用計數(shù)規(guī)則的。類型對象“跳出三界外，不再五行中”，永遠(yuǎn)不會被析構(gòu)。每一個對象中指向類型對象的指針不被視為對類型對象的引用。

在每一個對象創(chuàng)建的時候，Python提供了一個_Py_NewReference(op)宏來將對象的引用計數(shù)初始化為1。

在Python的源代碼中可以看到，在不同的編譯選項下(Py_REF_DEBUG, Py_TRACE_REFS)，引用計數(shù)的宏還要做許多額外的工作。下面展示的代碼是Python在最終發(fā)行時這些宏所對應(yīng)的實際的代碼：

[object.h]? ?

/*?Without?Py_TRACE_REFS,?there's?little?enough?to?do?that?we?expand?code? ?

?*?inline.? ?

?*/? ?

#define?_Py_NewReference(op)?((op)->ob_refcnt?=?1)? ?

#define?_Py_Dealloc(op)?((*(op)->ob_type->tp_dealloc)((PyObject?*)(op)))? ?

#define?Py_INCREF(op)?((op)->ob_refcnt++)? ?

#define?Py_DECREF(op)???????????????????\? ?

if?(--(op)->ob_refcnt?!=?0)?????????\? ?

????????;????????????\? ?

else????????????????????????\? ?

_Py_Dealloc((PyObject?*)(op))? ?

/*?Macros?to?use?in?case?the?object?pointer?may?be?NULL:?*/? ?

#define?Py_XINCREF(op)?if?((op)?==?NULL)?;?else?Py_INCREF(op)? ?

#define?Py_XDECREF(op)?if?((op)?==?NULL)?;?else?Py_DECREF(op)??

在一個對象的引用計數(shù)減為0時，與該對象對應(yīng)的析構(gòu)函數(shù)就會被調(diào)用，但是要特別注意的是，調(diào)用析構(gòu)函數(shù)并不意味著最終一定會調(diào)用free釋放內(nèi)存空間，如果真是這樣的話，那頻繁地申請、釋放內(nèi)存空間會使Python的執(zhí)行效率大打折扣（更何況Python已經(jīng)多年背負(fù)了人們對其執(zhí)行效率的指責(zé)：）。一般來說，Python中大量采用了內(nèi)存對象池的技術(shù)，使用這種技術(shù)避免頻繁地申請和釋放內(nèi)存空間。因此在析構(gòu)時，通常都是將對象占用的空間歸還到內(nèi)存池中。這一點在接下來對Python內(nèi)建對象的實現(xiàn)中可以看得一清二楚。

5、Python對象的分類

我們將Python的對象從概念上大致分為四類，需要指出的是，這種分類并不一定完全正確，不過是提供一種看待Python中對象的視角而已：

Math ：數(shù)值對象

Container ：容納其他對象的集合對象

Composition ：表示程序結(jié)構(gòu)的對象

Internal ：Python解釋器在運行時內(nèi)部使用的對象

圖2列出了我們的對象分類體系，并給出了每一個類別中的一些實例：

6、通向Python之路

對Python源碼的剖析將分為四部分。

1．靜態(tài)對象剖析：首先我們會分析靜態(tài)的對象，Math對象和Container對象，深刻理解這些對象對我們理解Python解釋器的運行會有很大的幫助，同時，對我們編寫Python代碼也將大有裨益，在編寫Python代碼時，你會清晰地意識到系統(tǒng)內(nèi)部這些對象將如何運作，變化。當(dāng)然，我們并不會分析所有的Python對象，而是選取使用最頻繁的四種對象：PyIntObject, PyStringObject, PyListObject, PyDictObject進(jìn)行剖析。

2．運行時剖析：在分析完靜態(tài)的對象之后，我們將進(jìn)入Python解釋器，在這里我們會詳細(xì)地考察Python的字節(jié)碼(byte code)以及解釋器對字節(jié)碼的解釋和執(zhí)行過程。這部分將完整地展現(xiàn)Python中所有的語法結(jié)構(gòu)，如一般表達(dá)式，控制流，異常流，函數(shù)，類等等的字節(jié)碼層面的實現(xiàn)細(xì)節(jié)。同時，在這部分，我們會考察大部分的Python內(nèi)部對象。

3．編譯期剖析：這部分沒什么好打廣告的了，目標(biāo)明確，對象清晰，但是難度呢，絕不簡單 ：

4．運行環(huán)境剖析：這部分將考察從激活Python到Python準(zhǔn)備就緒，可以接受用戶輸入或者執(zhí)行腳本文件，這段時間內(nèi)，Python如何建立自己的運行環(huán)境，并建立了怎樣的運行環(huán)境，呵呵透露一下，想想Python那個龐大的builtin函數(shù)集合，這些就是這部分考察的重點。

閱讀完這些內(nèi)容之后，對于Python，你應(yīng)該是了如指掌了，在以后編寫Python代碼時，你的腦子里甚至可以出現(xiàn)Python解釋器將如何一步步解釋你的代碼的情形。當(dāng)然，這只是我寫作本書的副產(chǎn)品。這本書誕生的真正原因只有一個，興趣，我對Python的實現(xiàn)有濃厚的興趣。這本書也只是第一步，希望以后還能繼續(xù)對Python系列，如IronPython、Jython，PyPy的探索，當(dāng)然，對于其他動態(tài)語言，比如Ruby的探索，我希望也會有時間去做。

小結(jié)：詳解?Python?源碼之對象機(jī)制的內(nèi)容介紹完了，希望本文對你有幫助，更多關(guān)于Python?的內(nèi)容請參考編輯推薦。

總結(jié)

以上是生活随笔為你收集整理的详解 Python 源码之对象机制的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。