我們知道所有類型對象在底層都由結構體 PyTypeObject 實例化得到，但內部字段接收的值不同，得到的類型對象就不同。類型對象不同，那么實例對象的表現就不同，這也正是一種對象區別于另一種對象的關鍵所在。

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

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

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

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 等字段會直接對應 Python 里的魔法函數，它們以雙下劃線開頭、以雙下劃線結尾。但除了魔法函數之外，每種類型還可以有很多自定義的成員函數。

# 自定義 foo 和 bar
class A:

    def foo(self):
        pass

    def bar(self):
        pass

# 當然內置類型也是如此
# 像 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)

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

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

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

圖片

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

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

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

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

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

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

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

所以，只要類型對象提供相關操作，實例對象便具備對應的行為，因為實例對象所調用的方法都是由類型對象提供的。

class Girl:

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

def say(self):
    pass

def cry(self):
    pass

實例對象的屬性字典，只包含了一些在 init 里面設置的屬性而已，而實例能夠調用的 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 在實例化之后自然是一個數值對象，但看上去 a[""] 是一個類似于字典才具有的行為，那為什么可以實現呢？

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

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

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

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

圖片

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

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

圖片

里面的 long_add、long_sub、long_mul 等等顯然都是已經定義好的函數指針，在創建 PyNumberMethods 結構體實例 long_as_number 的時候，分別賦值給了字段 nb_add、nb_substract、nb_multiply 等等。

創建完整數相關操作的 PyNumberMethods 結構體實例 long_as_number 之后，再將其指針交給 PyLong_Type 的 tp_as_number 字段。

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

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

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

所以對象的行為是由其類型對象定義的操作所決定的，比如一個對象可以計算長度，那么它的類型對象要實現 len；一個對象可以轉成整數，那么它的類型對象要實現 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) 在底層會轉成 A.__len__(a)
# int(a) 在底層會轉成 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 總之核心就是一句話：類型對象定義了哪些操作，決定了實例對象具有哪些行為。