對象
對象, 在C語言是如何實現(xiàn)的?
Python中對象分為兩類: 定長(int等), 非定長(list/dict等)
所有對象都有一些相同的東西, 源碼中定義為PyObject和PyVarObject, 兩個定義都有一個共同的頭部定義PyObject_HEAD(其實PyVarObject有自己的頭部定義PyObject_VAR_HEAD, 但其實際上用的也是PyObject_HEAD).
源碼位置: Include/object.h
PyObject_HEAD
Python 內(nèi)部, 每個對象擁有相同的頭部.
定義
|
1
2
3
4
5
|
/* PyObject_HEAD defines the initial segment of every PyObject. */#define PyObject_HEAD \ _PyObject_HEAD_EXTRA \ Py_ssize_t ob_refcnt; \ struct _typeobject *ob_type; |
說明
1. _PyObject_HEAD_EXTRA
先忽略, 雙向鏈表結(jié)構(gòu), 后面垃圾回收再說
2. Py_ssize_t ob_refcnt
Py_ssize_t在編譯時確定, 整型
ob_refcnt, 引用計數(shù), 跟Python的內(nèi)存管理機制相關(基于引用計數(shù)的垃圾回收)
3. struct _typeobject *ob_type
*ob_type 指向類型對象的指針(指向_typeobject結(jié)構(gòu)體)
決定了這個對象的類型!
PyObject
定義
|
1
2
3
|
typedef struct _object { PyObject_HEAD} PyObject; |
說明
1. 依賴關系
PyObject -> PyObject_HEAD
結(jié)構(gòu)
PyVarObject
定義
|
1
2
3
4
5
6
7
|
typedef struct { PyObject_VAR_HEAD} PyVarObject;#define PyObject_VAR_HEAD \ PyObject_HEAD \ Py_ssize_t ob_size; /* Number of items in variable part */ |
說明
1. 依賴關系
PyVarObject -> PyObject_VAR_HEAD -> PyObject_HEAD
2.Py_ssize_t ob_size
ob_size, 變長對象容納的元素個數(shù)
結(jié)構(gòu)
代碼關系
幾個方法
跟對象相關的方法
#define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)
讀取引用計數(shù)
#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
獲取對象類型
#define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size)
讀取元素個數(shù)(len)
跟引用計數(shù)相關的方法
Py_INCREF(op) 增加對象引用計數(shù)
Py_DECREF(op) 減少對象引用計數(shù), 如果計數(shù)位0, 調(diào)用_Py_Dealloc
_Py_Dealloc(op) 調(diào)用對應類型的 tp_dealloc 方法(每種類型回收行為不一樣的, 各種緩存池機制, 后面看)
其他
幾個參數(shù)涉及
ob_refcnt 引用計數(shù), 與內(nèi)存管理/垃圾回收相關
ob_type 類型, 涉及Python的類型系統(tǒng)
類型
一個例子
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
>>> a = 1>>> a1>>> type(a)<type 'int'>#等價的兩個>>> type(type(a))<type 'type'>>>> type(int)<type 'type'>#還是等價的兩個>>> type(type(type(a)))<type 'type'>>>> type(type(int))<type 'type'> |
我們反向推導一個int對象是怎么生成的.
1. 首先, 定義一種類型叫PyTypeObject
代碼位置 Include/object.h
定義
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
typedef struct _typeobject { /* MARK: base, 注意, 是個變長對象*/ PyObject_VAR_HEAD const char *tp_name; /* For printing, in format "<module>.<name>" */ //類型名 Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */ // 創(chuàng)建該類型對象時分配的內(nèi)存空間大小 // 一堆方法定義, 函數(shù)和指針 /* Methods to implement standard operations */ printfunc tp_print; hashfunc tp_hash; /* Method suites for standard classes */ PyNumberMethods *tp_as_number; // 數(shù)值對象操作 PySequenceMethods *tp_as_sequence; // 序列對象操作 PyMappingMethods *tp_as_mapping; // 字典對象操作 // 一堆屬性定義 ....} PyTypeObject; |
說明
1. PyObject_VAR_HEAD
變長對象
2. const char *tp_name
tp_name, 類型名字符串數(shù)組
所有Type都是PyTypeObject的"實例": PyType_Type/PyInt_Type
2. 然后, 用PyTypeObject初始化得到一個對象PyType_Type
代碼位置 Objects/typeobject.c
定義
|
1
2
3
4
5
6
7
8
9
10
11
|
PyTypeObject PyType_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "type", /* tp_name */ sizeof(PyHeapTypeObject), /* tp_basicsize */ sizeof(PyMemberDef), /* tp_itemsize */ (destructor)type_dealloc, /* tp_dealloc */ // type對象的方法和屬性初始化值 .....}; |
說明
1. tp_name
類型名, 這里是"type"
2. PyVarObject_HEAD_INIT(&PyType_Type, 0)
PyVarObject_HEAD_INIT, 這個方法在 Include/object.h中,
等價于
ob_refcnt = 1
*ob_type = &PyType_Type
ob_size = 0
即, PyType_Type的類型是其本身!
結(jié)構(gòu)
第一張圖, 箭頭表示實例化(google doc用不是很熟找不到對應類型的箭頭)
第二張圖, 箭頭表示指向
使用
|
1
2
3
4
5
6
7
|
# 1. int 的 類型 是`type`>>> type(int)<type 'type'># 2. type 的類型 還是`type`, 對應上面說明第二點>>> type(type(int))<type 'type'> |
注意: 無論任何時候, ob_type指向的是 PyTypeObject的實例: PyType_Type/PyInt_Type...
3. 再然后, 定義具體的類型, 這里以PyInt_Type為例子
代碼位置 Objects/intobject.c
定義
|
1
2
3
4
5
6
7
8
9
10
11
12
|
PyTypeObject PyInt_Type = { PyVarObject_HEAD_INIT(&PyType_Type, 0) "int", sizeof(PyIntObject), 0, // int類型的相關方法和屬性值 .... (hashfunc)int_hash, /* tp_hash */}; |
說明
1. "int"
PyInt_Type的類型名是int
2.PyVarObject_HEAD_INIT(&PyType_Type, 0)
PyInt_Type的
|
1
|
*ob_type = &PyType_Type |
結(jié)構(gòu)
使用
|
1
2
3
4
5
|
>>> type(1)<type 'int'>>>> type(type(1))<type 'type'> |
4. 最后, 生成一個整數(shù)對象int
代碼位置 Include/intobject.h
定義
|
1
2
3
4
|
typedef struct { PyObject_HEAD long ob_ival;} PyIntObject; |
結(jié)構(gòu)
