浅谈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",                                     
    sizeof(PyHeapTypeObject),                   
    sizeof(PyMemberDef),                        
    (destructor)type_dealloc,                   
    //...                                       
    (ternaryfunc)type_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;
}