源码探秘：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__方法执行啦

古明地觉 16

"""

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>

class Girl:

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

 return 123

 def __init__(self, name, age):

 print("__init__方法执行啦")

g = Girl()

print(g, type(g))# 123

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;

}