# 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__")
# 發(fā)現(xiàn)可以調用了
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);
// 而在創(chuàng)建 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 是一個函數(shù)指針，指向具體的構造函數(shù)
        // 如果 tp_new 為空，說明它沒有構造函數(shù)
        // 因此會報錯，表示無法創(chuàng)建其實例
        PyErr_Format(PyExc_TypeError,
                     "cannot create '%.100s' instances",
                     type->tp_name);
        return NULL;
    }
  
    //通過tp_new分配空間
    //此時實例對象就已經創(chuàng)建完畢了，這里會返回其指針
    obj = type->tp_new(type, args, kwds);
    //類型檢測，暫時不用管
    obj = _Py_CheckFunctionResult((PyObject*)type, obj, NULL);
    if (obj == NULL)
        return NULL;

    //我們說這里的參數(shù)type是類型對象，但也可以是元類
    //元類也是由PyTypeObject結構體實例化得到的
    //元類在調用的時候執(zhí)行的依舊是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);
    //執(zhí)行 tp_init
    //顯然這個tp_init就是__init__函數(shù)
    //這與Python中類的實例化過程是一致的。
    if (type->tp_init != NULL) {
        //將tp_new返回的對象作為self，執(zhí)行 tp_init
        int res = type->tp_init(obj, args, kwds);
        if (res < 0) {
            //執(zhí)行失敗，將引入計數(shù)減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__方法執(zhí)行啦")
        # 寫法非常固定
        # 調用object.__new__(cls)就會創(chuàng)建Girl的實例對象
        # 因此這里的cls指的就是這里的Girl，注意：一定要返回
        # 因為__new__會將自己的返回值交給__init__中的self
        return object.__new__(cls)

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


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

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__方法執(zhí)行啦")
        instance = object.__new__(cls)
        # 打印看看instance到底是個什么東東
        print("instance:", instance)
        print("type(instance):", type(instance))
        
        # 正確做法是將instance返回
        # 但是我們不返回, 而是返回個 123
        return 123

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


g = Girl()
"""
__new__方法執(zhí)行啦
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__方法執(zhí)行啦")


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