對象
對象, 在C語言是如何實現(xiàn)的?

Python中對象分為兩類: 定長(int等), 非定長(list/dict等)

所有對象都有一些相同的東西, 源碼中定義為PyObject和PyVarObject, 兩個定義都有一個共同的頭部定義PyObject_HEAD(其實PyVarObject有自己的頭部定義PyObject_VAR_HEAD, 但其實際上用的也是PyObject_HEAD).

源碼位置: Include/object.h

PyObject_HEAD
Python 內部, 每個對象擁有相同的頭部.

定義

/* 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
先忽略, 雙向鏈表結構, 后面垃圾回收再說

2. Py_ssize_t ob_refcnt
Py_ssize_t在編譯時確定, 整型
ob_refcnt, 引用計數(shù), 跟Python的內存管理機制相關(基于引用計數(shù)的垃圾回收)

3. struct _typeobject *ob_type
*ob_type 指向類型對象的指針(指向_typeobject結構體)
決定了這個對象的類型!
PyObject
定義

 typedef struct _object {
   PyObject_HEAD
 } PyObject;

說明

 1. 依賴關系
 PyObject -> PyObject_HEAD
結構

PyVarObject
定義

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ù)
結構

代碼關系

幾個方法
跟對象相關的方法

#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, 調用_Py_Dealloc

_Py_Dealloc(op) 調用對應類型的 tp_dealloc 方法(每種類型回收行為不一樣的, 各種緩存池機制, 后面看)
其他
幾個參數(shù)涉及

ob_refcnt 引用計數(shù), 與內存管理/垃圾回收相關
ob_type   類型, 涉及Python的類型系統(tǒng)

類型
一個例子

>>> a = 1
>>> a
1

>>> 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

定義

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)建該類型對象時分配的內存空間大小


 // 一堆方法定義, 函數(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

定義

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的類型是其本身!
結構

第一張圖, 箭頭表示實例化(google doc用不是很熟找不到對應類型的箭頭)

第二張圖, 箭頭表示指向

使用

# 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

定義

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的

  *ob_type = &PyType_Type

結構

使用

>>> type(1)
<type 'int'>

>>> type(type(1))
<type 'type'>

4. 最后, 生成一個整數(shù)對象int
代碼位置 Include/intobject.h

定義

typedef struct {
  PyObject_HEAD
  long ob_ival;
} PyIntObject;

結構

最新評論