我們知道所有類型對象在底層都由結(jié)構(gòu)體 PyTypeObject 實例化得到，但內(nèi)部字段接收的值不同，得到的類型對象就不同。類型對象不同，那么實例對象的表現(xiàn)就不同，這也正是一種對象區(qū)別于另一種對象的關(guān)鍵所在。

比如 PyLong_Type 的 tp_iter 是空，那么整數(shù)就不是可迭代對象，而 PyList_Type 的 tp_iter 不是空，那么列表就是可迭代對象。再比如 PyLong_Type 和 PyFloat_Type，雖然內(nèi)部都實現(xiàn)了 tp_hash，但它們是不同的類型，所以整數(shù)和浮點數(shù)的哈希值計算方式也不一樣。

因此類型對象決定了實例對象的行為，比如能否調(diào)用、能否計算哈希值、能否迭代等等，這些都由類型對象決定。

PyTypeObject 里面定義了很多函數(shù)指針，比如 tp_call、tp_hash 等等，它們可能指向某個具體的函數(shù)，也可能為空。這些函數(shù)指針可以看做是類型對象所定義的操作，這些操作決定了其實例對象在運行時的行為。

class A:
# tp_new
def __new__(cls, *args, **kwargs):
    pass

# tp_init
def __init__(self):
    pass

# tp_call
def __call__(self):
    pass

# tp_getattr
def __getattr__(self, attr):
    pass

# tp_setattr
def __setattr__(self, key, value):
    pass

...
...

像 tp_call、tp_hash、tp_new 等字段會直接對應(yīng) Python 里的魔法函數(shù)，它們以雙下劃線開頭、以雙下劃線結(jié)尾。但除了魔法函數(shù)之外，每種類型還可以有很多自定義的成員函數(shù)。

# 自定義 foo 和 bar
class A:

    def foo(self):
        pass

    def bar(self):
        pass

# 當然內(nèi)置類型也是如此
# 像 str 定義了 join、split、upper
print(str.join)
print(str.split)
print(str.upper)
# 像 list 定義了 append、extend，insert
print(list.append)
print(list.extend)
print(list.insert)

這些自定義的函數(shù)會一起保存在類型對象的 tp_methods 里面，負責讓實例對象更具有表現(xiàn)力。需要補充的是，類型對象里面定義的是函數(shù)，也叫成員函數(shù)，實例對象在獲取之后會自動包裝成方法。

所以實例對象能調(diào)用的方法都定義在類型對象里面，并且通過實例調(diào)用本質(zhì)上就是一個語法糖，但用起來更加優(yōu)雅。假設(shè)有一個類 A，實例對象為 a，那么 a.some() 底層會轉(zhuǎn)成 A.some(a)，至于這背后的細節(jié)后續(xù)再聊。

但除了以上這些，PyTypeObject 還提供了三個字段。

圖片

每個字段各自指向一個結(jié)構(gòu)體實例，結(jié)構(gòu)體實例中有大量的字段，這些字段也是函數(shù)指針，指向了具體的函數(shù)。所以它們也被稱為方法簇，分別應(yīng)用于如下操作。

• tp_as_number：負責數(shù)值型操作，比如整數(shù)、浮點數(shù)的加減乘除；
• tp_as_sequence：負責序列型操作，比如字符串、列表、元組等通過索引取值的行為；
• tp_as_mapping：負責映射型操作，比如字典通過 key 映射出 value；

我們以 tp_as_number 為例，它指向 PyNumberMethods 類型的結(jié)構(gòu)體實例，那么這個結(jié)構(gòu)體長什么樣子呢？

// Include/cpython/object.h
typedef struct {
// add，對應(yīng) + 操作符，如 a + b
binaryfunc nb_add;
// sub，對應(yīng) - 操作符，如 a - b
binaryfunc nb_subtract;
// mul，對應(yīng) * 操作符，如 a * b
binaryfunc nb_multiply;
// mod，對應(yīng) % 操作符，如 a % b
binaryfunc nb_remainder;
// divmod，對應(yīng) divmode 函數(shù)，如 divmod(a, b)
binaryfunc nb_divmod;
// power，對應(yīng) ** 操作符，如 a ** b
ternaryfunc nb_power;
// neg，對應(yīng) - 操作符，如 -a
unaryfunc nb_negative;
// pos，對應(yīng) + 操作符，如 +a
unaryfunc nb_positive;
// abs，對應(yīng) abs 函數(shù)，如 abs(a)
unaryfunc nb_absolute;
// bool，如 bool(a)
inquiry nb_bool;
// invert，對應(yīng) ~ 操作符，如 ~a
unaryfunc nb_invert;
// lshift，對應(yīng) << 操作符，如 a << b
binaryfunc nb_lshift;
// rshift，對應(yīng) >> 操作符，如 a >> b
binaryfunc nb_rshift;
// and，對應(yīng) & 操作符，如 a & b
binaryfunc nb_and;
// xor，對應(yīng) ^ 操作符，如 a ^ b
binaryfunc nb_xor;
// or，對應(yīng) | 操作符，如 a | b
binaryfunc nb_or;
// int，如 int(a)
unaryfunc nb_int;
// ...
} PyNumberMethods;

你看到了什么？是不是想到了 Python 里面的魔法方法，所以它們也被稱為方法簇。

在 PyNumberMethods 這個方法簇里面定義了作為一個數(shù)值應(yīng)該支持的操作，如果一個對象能被視為數(shù)值，比如整數(shù)，那么在其對應(yīng)的類型對象 PyLong_Type 中，tp_as_number->nb_add 就指定了該對象進行加法操作時的具體行為。

同樣，PySequenceMethods 和 PyMappingMethods 中分別定義了作為一個序列對象和映射對象應(yīng)該支持的行為，這兩種對象的典型例子就是 list 和 dict。

所以，只要類型對象提供相關(guān)操作，實例對象便具備對應(yīng)的行為，因為實例對象所調(diào)用的方法都是由類型對象提供的。

class Girl:

class Girl:
def __init__(self, name, age):
    self.name = name
    self.age = age

def say(self):
    pass

def cry(self):
    pass

實例對象的屬性字典，只包含了一些在 init 里面設(shè)置的屬性而已，而實例能夠調(diào)用的 say、cry 都是定義在類型對象中的。

因此一定要記住：類型對象定義的操作，決定了實例對象的行為。

class Int(int):

    def __getitem__(self, item):
        return item


a = Int(1)
b = Int(2)

print(a + b)  # 3
print(a["你好"])  # 你好

繼承自 int 的 Int 在實例化之后自然是一個數(shù)值對象，但看上去 a[""] 是一個類似于字典才具有的行為，那為什么可以實現(xiàn)呢？

原因就是我們重寫了 getitem 這個魔法函數(shù)，該方法在底層對應(yīng) PyMappingMethods 中的 mp_subscript 操作，因此最終 Int 實例對象表現(xiàn)的像一個字典一樣。

歸根結(jié)底就在于這幾個方法簇都只是 PyTypeObject 的一個字段罷了，默認使用 PyTypeObject 結(jié)構(gòu)體創(chuàng)建的 PyLong_Type 所生成的實例對象是不具備列表和字典的屬性特征的。但我們通過繼承 PyLong_Type，同時指定 getitem，使得構(gòu)建出來的類型對象所生成的實例對象，同時具備多種屬性特征，就是因為解釋器支持這種做法。

自定義的類在底層也是 PyTypeObject 結(jié)構(gòu)體實例，而在繼承 int 的時候，將其內(nèi)部定義的 PyNumberMethods 方法簇也繼承了下來，而我們又單獨實現(xiàn)了 PyMappingMethods 中的 mp_subscript。所以自定義類 Int 的實例對象具備了整數(shù)的全部行為，以及字典的部分行為（因為我們只實現(xiàn)了 getitem）。

我們再通過 PyLong_Type 實際考察一下：

圖片

整數(shù)對象顯然不支持序列和映射操作，所以在創(chuàng)建 PyLong_Type 時，字段 tp_as_sequence 和 tp_as_mapping 就是 0，相當于空。但整數(shù)明顯支持數(shù)值型操作，所以實現(xiàn)了 tp_as_number。

而 tp_as_number 字段被賦值為 long_as_number，看一下它長什么樣。

圖片

里面的 long_add、long_sub、long_mul 等等顯然都是已經(jīng)定義好的函數(shù)指針，在創(chuàng)建 PyNumberMethods 結(jié)構(gòu)體實例 long_as_number 的時候，分別賦值給了字段 nb_add、nb_substract、nb_multiply 等等。

創(chuàng)建完整數(shù)相關(guān)操作的 PyNumberMethods 結(jié)構(gòu)體實例 long_as_number 之后，再將其指針交給 PyLong_Type 的 tp_as_number 字段。

然后整數(shù)在操作的時候，比如相加，會先通過 變量->ob_type->tp_as_number->nb_add 獲取該操作對應(yīng)的函數(shù)指針，其中 int 類型對象的 tp_as_number 字段的值是 &long_as_number，因此獲取其字段 nb_add 的時候，拿到的就是 long_add 函數(shù)指針，然后調(diào)用。

同理 float 類型里的 tp_as_number 則被賦值成了 &float_as_number，獲取 nb_add 字段的時候，拿到的就是 float_add 函數(shù)指針。不同類型的對象的行為不同，它們都有屬于自己的一組方法簇。

最后再畫一張圖總結(jié)一下，假設(shè)有兩個變量，分別是 e = 2.71 和 num = 666。

所以對象的行為是由其類型對象定義的操作所決定的，比如一個對象可以計算長度，那么它的類型對象要實現(xiàn) len；一個對象可以轉(zhuǎn)成整數(shù)，那么它的類型對象要實現(xiàn) int 或 index。

class A:

    def __len__(self):
        return 123

    def __int__(self):
        return 456

a = A()
print(len(a))  # 123
print(int(a))  # 456
# len(a) 在底層會轉(zhuǎn)成 A.__len__(a)
# int(a) 在底層會轉(zhuǎn)成 A.__int__(a)
print(A.__len__(a))  # 123
print(A.__int__(a))  # 456

a = A() print(len(a)) # 123 print(int(a)) # 456

print(A.len(a)) # 123 print(A.int(a)) # 456 總之核心就是一句話：類型對象定義了哪些操作，決定了實例對象具有哪些行為。