淺談Python中物件是如何被呼叫的

# int可以呼叫
# 那麼它的型別物件、也就是元類(type), 內部一定有__call__方法
print(hasattr(type, "__call__"))  # True

# 而呼叫一個物件，等價於呼叫其型別物件的 __call__ 方法
# 所以 int(3.14)實際就等價於如下
print(type.__call__(int, 3.14))  # 3

class A:
    pass
    
a = A()
# 因為我們自定義的類 A 裡面沒有 __call__
# 所以 a 是不可以被呼叫的
try:
    a()
except Exception as e:
    # 告訴我們 A 的範例物件不可以被呼叫
    print(e)  # 'A' object is not callable    
    
# 如果我們給 A 設定了一個 __call__
type.__setattr__(A, "__call__", lambda self: "這是__call__")
# 發現可以呼叫了
print(a())  # 這是__call__

try:
    type.__setattr__(dict, "__call__", lambda self: "這是__call__")
except Exception as e:
    print(e)  # can't set attributes of built-in/extension type 'dict'

class Girl: 
    pass

g = Girl()
g.name = "古明地覺"
# 範例物件我們也可以手動設定屬性
print(g.name)  # 古明地覺

lst = list()
try:
    lst.name = "古明地覺"
except Exception as e:
    # 但是內建型別的範例物件是不可以的
    print(e)  # 'list' object has no attribute 'name'

import gc

try:
    type.__setattr__(list, "ping", "pong")
except TypeError as e:
    print(e)  # can't set attributes of built-in/extension type 'list'

# 我們看到無法設定，那麼我們就來改變這一點
attrs = gc.get_referents(tuple.__dict__)[0]
attrs["ping"] = "pong"
print(().ping)  # pong

attrs["append"] = lambda self, item: self + (item,)
print(
    ().append(1).append(2).append(3)
)  # (1, 2, 3)

//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 */
    //...                                       /* tp_hash */
    (ternaryfunc)type_call,                     /* tp_call */
    //...
}

(&PyFloat_Type) -> ob_type -> tp_call(&PyFloat_Type, args, kwargs);
// 即：
(&PyType_Type) -> tp_call(&PyFloat_Type, args, kwargs);
// 而在建立 PyType_Type 的時候，給 tp_call 成員傳遞的是 type_call
// 因此最終相當於
type_call(&PyFloat_Type, args, kwargs)

# float(3.14)，等價於
f1 = float.__class__.__call__(float, 3.14)
# 等價於
f2 = type.__call__(float, 3.14)

print(f1, f2)  # 3.14 3.14

# lst = list("abcd")
lst = list.__class__.__call__(list, "abcd")
print(lst)  # ['a', 'b', 'c', 'd']

# dct = dict([("name", "古明地覺"), ("age", 17)])
dct = dict.__class__.__call__(dict, [("name", "古明地覺"), ("age", 17)])
print(dct)  # {'name': '古明地覺', 'age': 17}

static PyObject *
type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
{  
    // 如果我們呼叫的是 float
    // 那麼顯然這裡的 type 就是 &PyFloat_Type
    
    // 這裡是宣告一個PyObject *
    // 顯然它是要返回的範例物件的指標
    PyObject *obj;
  
    // 這裡會檢測 tp_new是否為空，tp_new是什麼估計有人已經猜到了
    // 我們說__call__對應底層的tp_call
    // 顯然__new__對應底層的tp_new，這裡是為範例物件分配空間
    if (type->tp_new == NULL) {
        // tp_new 是一個函數指標，指向具體的建構函式
        // 如果 tp_new 為空，說明它沒有建構函式
        // 因此會報錯，表示無法建立其範例
        PyErr_Format(PyExc_TypeError,
                     "cannot create '%.100s' instances",
                     type->tp_name);
        return NULL;
    }
  
    //通過tp_new分配空間
    //此時範例物件就已經建立完畢了，這裡會返回其指標
    obj = type->tp_new(type, args, kwds);
    //型別檢測，暫時不用管
    obj = _Py_CheckFunctionResult((PyObject*)type, obj, NULL);
    if (obj == NULL)
        return NULL;

    //我們說這裡的引數type是型別物件，但也可以是元類
    //元類也是由PyTypeObject結構體範例化得到的
    //元類在呼叫的時候執行的依舊是type_call
    //所以這裡是檢測type指向的是不是PyType_Type
    //如果是的話，那麼範例化得到的obj就不是範例物件了，而是型別物件
    //要單獨檢測一下
    if (type == &PyType_Type &&
        PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
        (kwds == NULL ||
         (PyDict_Check(kwds) && PyDict_GET_SIZE(kwds) == 0)))
        return obj;

    //tp_new應該返回相應型別物件的範例物件(的指標)
    //但如果不是，就直接將這裡的obj返回
    //此處這麼做可能有點難理解，我們一會細說
    if (!PyType_IsSubtype(Py_TYPE(obj), type))
        return obj;
  
    //拿到obj的型別
    type = Py_TYPE(obj);
    //執行 tp_init
    //顯然這個tp_init就是__init__函數
    //這與Python中類的範例化過程是一致的。
    if (type->tp_init != NULL) {
        //將tp_new返回的物件作為self，執行 tp_init
        int res = type->tp_init(obj, args, kwds);
        if (res < 0) {
            //執行失敗，將引入計數減1，然後將obj設定為NULL
            assert(PyErr_Occurred());
            Py_DECREF(obj);
            obj = NULL;
        }
        else {
            assert(!PyErr_Occurred());
        }
    }
    //返回obj
    return obj;
}

class Girl:

    def __new__(cls, name, age):
        print("__new__方法執行啦")
        # 寫法非常固定
        # 呼叫object.__new__(cls)就會建立Girl的範例物件
        # 因此這裡的cls指的就是這裡的Girl，注意：一定要返回
        # 因為__new__會將自己的返回值交給__init__中的self
        return object.__new__(cls)

    def __init__(self, name, age):
        print("__init__方法執行啦")
        self.name = name
        self.age = age


g = Girl("古明地覺", 16)
print(g.name, g.age)
"""
__new__方法執行啦
__init__方法執行啦
"""

static PyObject *
type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
{  
    //......
    //......
    if (!PyType_IsSubtype(Py_TYPE(obj), type))
        return obj;
  
    //......
    //......
}

class Girl:

    def __new__(cls, *args, **kwargs):
        print("__new__方法執行啦")
        instance = object.__new__(cls)
        # 列印看看instance到底是個什麼東東
        print("instance:", instance)
        print("type(instance):", type(instance))
        
        # 正確做法是將instance返回
        # 但是我們不返回, 而是返回個 123
        return 123

    def __init__(self, name, age):
        print("__init__方法執行啦")


g = Girl()
"""
__new__方法執行啦
instance: <__main__.Girl object at 0x000002C0F16FA1F0>
type(instance): <class '__main__.Girl'>
"""

class Girl:

    def __new__(cls, *args, **kwargs):
        return 123

    def __init__(self, name, age):
        print("__init__方法執行啦")


g = Girl()
print(g, type(g))  # 123 <class 'int'>

static PyObject *
type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
{  
    //呼叫__new__方法， 拿到其返回值
    obj = type->tp_new(type, args, kwds);

    if (type->tp_init != NULL) {
        //將__new__返回的範例obj，和args、kwds組合起來
        //一起傳給 __init__
        //其中 obj 會傳給 self，
        int res = type->tp_init(obj, args, kwds);
        //......
    return obj;
}