楔子
在上一篇文章中，我们分析了对象是如何创建的，主要有两种方式，一种是通过特定类型 API，另一种是通过调用类型对象。
对于内置类型的实例对象而言，这两种方式都是支持的，比如列表，我们既可以通过 [ ] 创建，也可以通过 list() 创建，前者是列表的特定类型 API，后者是调用类型对象。
但对于自定义类的实例对象而言，我们只能通过调用类型对象的方式来创建。一个对象如果可以被调用，那么这个对象就是 callable，否则就不是 callable。而决定一个对象是不是 callable，则取决于它的类型对象。
- 从 Python 的角度看，如果对象是 callable，那么它的类型对象一定实现了 __call__ 函数；
- 从解释器的角度看，如果对象是 callable，那么它的类型对象的 tp_call 字段一定不为空。
从 Python 的角度看对象的调用
调用 int 可以创建一个整数，调用 str 可以创建一个字符串，调用 tuple 可以创建一个元组，调用自定义的类也可以创建出相应的实例对象，这就说明类型对象是可调用的，也就是 callable。
既然类型对象可调用，那么类型对象的类型对象（type）内部一定实现了 __call__ 函数。
# int 可以调用，那么它的类型对象、也就是元类（type）
# 内部一定实现了 __call__ 函数
print(hasattr(type, "__call__")) # True
# 而调用一个对象，等价于调用其类型对象的 __call__ 函数
# 所以 int(2.71) 实际就等价于如下
print(type.__call__(int, 2.71)) # 2我们说 int、str、float 这些都是类型对象（简单来说就是类），而 123、"你好"、2.71 是其对应的实例对象，这些都没问题。但相对 type 而言，int、str、float 是不是又成了实例对象呢？因为它们的类型是 type。
所以 class 具有二象性：
- 如果站在实例对象（如：123、"satori"、2.71）的角度上，它是类型对象；
- 如果站在 type 的角度上，它是实例对象；
同理，由于 type 的类型还是 type，那么 type 既是 type 的类型对象，type 也是 type 的实例对象。虽然这里描述的有一些绕，但应该不难理解，而为了避免后续的描述出现歧义，这里我们做一个申明：
- 整数、浮点数、字符串、列表等等，我们称之为实例对象
- int、float、str、dict，以及自定义的类，我们称之为类型对象
- type 虽然也是类型对象，但我们称它为元类
由于 type 的内部定义了 __call__ 函数，那么说明类型对象都是可调用的，因为调用类型对象就是调用元类 type 的 __call__ 函数。而实例对象能否调用就不一定了，这取决于它的类型对象是否定义了 __call__ 函数，因为调用一个对象，本质上是调用其类型对象内部的 __call__ 函数。
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__这就是动态语言的特性，即便在类创建完毕之后，依旧可以通过 type 进行动态设置，而这在静态语言中是不支持的。所以 type 是所有类的元类，它控制了自定义类的生成过程，因此 type 这个古老而又强大的类可以让我们玩出很多新花样。
但对于内置的类，type 是不可以对其动态增加、删除或者修改属性的，因为内置的类在底层是静态定义好的。从源码中我们看到，这些内置的类、包括元类，它们都是 PyTypeObject 对象，在底层已经被声明为全局变量了，或者说它们已经作为静态类存在了。所以 type 虽然是所有类型对象的类型，但只有在面对我们自定义的类，type 才具有对属性进行增删改的能力。
而且在上一篇文章中我们也解释过，Python 的动态性是解释器将字节码翻译成 C 代码的时候动态赋予的，因此给类对象动态设置属性只适用于动态类，也就是在 py 文件中使用 class 关键字定义的类。
而对于静态类，它们在编译之后已经是指向 C 一级的数据结构了，不需要再被解释器解释了，因此解释器自然也就无法在它们身上动手脚，毕竟彪悍的人生不需要解释。
try:
type.__setattr__(dict, "ping", "pong")
except Exception as e:
print(e)
"""
cannot set 'ping' attribute of immutable type 'dict'
"""
try:
type.__setattr__(list, "ping", "pong")
except Exception as e:
print(e)
"""
cannot set 'ping' attribute of immutable type 'list'
"""同理其实例对象亦是如此，静态类的实例对象也不可以动态设置属性：
lst = list()
try:
lst.name = "古明地觉"
except Exception as e:
print(e) # 'list' object has no attribute 'name'在介绍 PyTypeObject 结构体的时候我们说过，静态类的实例对象可以绑定哪些属性，已经写死在 tp_members 字段里面了。
从解释器的角度看对象的调用
以内置类型 list 为例，我们说创建一个列表，可以通过 [ ] 或者 list() 的方式。前者使用列表的特定类型 API 创建，[ ] 会被直接解析成 C 一级的数据结构，也就是 PyListObject 实例；后者使用类型对象创建，对 list 进行调用，最终也得到指向 C 一级的数据结构 PyListObject 实例。
第一种方式我们已经很熟悉了，就是根据值来推断在底层应该对应哪一种数据结构，然后直接创建即可，因为解释器对内置的数据结构了如指掌。我们重点来看第二种方式，也就是通过调用类型对象去创建实例对象。
如果一个对象可以被调用，那么它的类型对象中一定要有 tp_call，更准确的说是 tp_call 字段的值是一个具体的函数指针，而不是 0。由于 PyList_Type 是可以调用的，这就说明 PyType_Type 内部的 tp_call 是一个函数指针，这在 Python 的层面我们已经验证过了，下面再来通过源码看一下。
图片
在创建 PyType_Type 的时候，PyTypeObject 内部的 tp_call 字段被设置成了 type_call。所以当我们调用 PyList_Type 的时候，会执行 type_call 函数。
因此 list() 在 C 的层面上等价于：
(&PyList_Type)->ob_type->tp_call(&PyList_Type, args, kwargs);
// 即：
(&PyType_Type)->tp_call(&PyList_Type, args, kwargs);
// 而在创建 PyType_Type 的时候，给 tp_call 字段传递的是 type_call
// 因此最终相当于
type_call(&PyList_Type, args, kwargs)如果用 Python 来演示这一过程的话：
# 以 list("abcd") 为例，它等价于
lst1 = list.__class__.__call__(list, "abcd")
# 等价于
lst2 = type.__call__(list, "abcd")
print(lst1) # ['a', 'b', 'c', 'd']
print(lst2) # ['a', 'b', 'c', 'd']这就是 list() 的秘密，相信其它类型在实例化的时候是怎么做的，你已经知道了，做法是相同的。
# dct = dict([("name", "古明地觉"), ("age", 17)])
dct = dict.__class__.__call__(
dict, [("name", "古明地觉"), ("age", 17)]
)
print(dct) # {'name': '古明地觉', 'age': 17}
# buf = bytes("hello world", encoding="utf-8")
buf = bytes.__class__.__call__(
bytes, "hello world", encoding="utf-8"
)
print(buf) # b'hello world'当然，目前还没有结束，我们还需要看一下 type_call 的源码实现。
type_call 源码解析
调用类型对象，本质上会调用 type.__call__，在底层对应 type_call 函数，因为 PyType_Type 的 tp_call 字段被设置成了 type_call。当然调用 type 也是如此，因为 type 的类型还是 type。
那么这个 type_call 都做了哪些事情呢？
static PyObject *
type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
// 参数 type 表示类型对象或者元类，假设调用的是 list，那么它就是 &PyList_Type
// 参数 args 和 kwds 表示位置参数和关键字参数，args 是元组，kwds 是字典
// 创建的实例对象，当然也可能是类型对象，取决于参数 type
PyObject *obj;
// 线程状态对象，后续介绍线程的时候会细说
// 此处的线程状态对象是用来设置异常的
PyThreadState *tstate = _PyThreadState_GET();
// 如果参数 type 是 &PyType_Type，也就是 Python 中的元类
if (type == &PyType_Type) {
// 那么它只能接收一个位置参数（查看对象类型）或三个位置参数（动态创建类）
Py_ssize_t nargs = PyTuple_GET_SIZE(args); // 获取位置参数的个数
// 如果位置参数个数为 1，并且没有传递关键字参数，那么直接返回对象的类型
if (nargs == 1 && (kwds == NULL || !PyDict_GET_SIZE(kwds))) {
// Py_TYPE 负责获取对象类型，因此相当于 type(args[0])
obj = (PyObject *) Py_TYPE(PyTuple_GET_ITEM(args, 0));
// 增加引用计数，返回 obj
return Py_NewRef(obj);
}
// 如果位置参数的个数不等于 1，那么一定等于 3
if (nargs != 3) {
PyErr_SetString(PyExc_TypeError,
"type() takes 1 or 3 arguments");
return NULL;
}
}
// 接下来执行类型对象（也可能是元类）的 tp_new，也就是 __new__
// 如果不存在，那么会报错，而在 Python 中见到的报错信息就是这里指定的
if (type->tp_new == NULL) {
_PyErr_Format(tstate, PyExc_TypeError,
"cannot create '%s' instances", type->tp_name);
return NULL;
}
// 执行类型对象的 __new__
obj = type->tp_new(type, args, kwds);
// 检测调用是否正常，如果调用正常，那么 obj 一定指向一个合法的 PyObject
// 而如果 obj 为 NULL，则表示执行出错，此时解释器会抛出异常
obj = _Py_CheckFunctionResult(tstate, (PyObject*)type, obj, NULL);
if (obj == NULL)
return NULL;
// __new__ 执行完之后该执行啥了，显然是 __init__，但需要先做一个检测
// 如果 __new__ 返回的实例对象的类型不是当前类型，那么直接返回，不再执行 __init__
// 比如自定义 class A，那么在 __new__ 里面应该返回 A 的实例对象，但假设返回个 123
// 由于返回值的类型不是当前类型，那么不再执行初始化函数 __init__
if (!PyObject_TypeCheck(obj, type))
return obj;
// 走到这里说明类型一致，那么执行 __init__，将 obj、args、kwds 一起传过去
type = Py_TYPE(obj);
if (type->tp_init != NULL) {
int res = type->tp_init(obj, args, kwds);
if (res < 0) {
assert(_PyErr_Occurred(tstate));
Py_SETREF(obj, NULL);
}
else {
assert(!_PyErr_Occurred(tstate));
}
}
// 返回创建的对象 obj
return obj;
}所以整个过程就三步：
- 如果传递的是元类，并且只有一个参数，那么直接返回对象的类型；
- 否则先调用 tp_new 为实例对象申请内存；
- 再调用 tp_init（如果有）进行初始化，设置对象属性；
所以这对应了 Python 中的 __new__ 和 __init__，其中 __new__ 负责为实例对象开辟一份内存，然后返回指向对象的指针，并且该指针会自动传递给 __init__ 中的 self。
class Girl:
def __new__(cls, name, age):
print("__new__ 方法执行啦")
# 调用 object.__new__(cls) 创建 Girl 的实例对象
# 然后该对象的指针会自动传递给 __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
"""__new__ 里面的参数要和 __init__ 里面的参数保持一致，因为会先执行 __new__，然后解释器再将 __new__ 的返回值和传递的参数组合起来一起传给 __init__。因此从这个角度讲，设置属性完全可以在 __new__ 里面完成。
class Girl:
def __new__(cls, name, age):
self = object.__new__(cls)
self.name = name
self.age = age
return self
g = Girl("古明地觉", 16)
print(g.name, g.age)
"""
古明地觉 16
"""这样也是没问题的，不过 __new__ 一般只负责创建实例，设置属性应该交给 __init__ 来做，毕竟一个是构造函数、一个是初始化函数，各司其职。另外由于 __new__ 里面不负责初始化，那么它的参数除了 cls 之外，一般都会写成 *args 和 **kwargs。
然后再回过头来看一下 type_call 中的这两行代码：
图片
tp_new 应该返回该类型对象的实例对象，而且一般情况下我们是不重写 __new__ 的，会默认执行 object 的 __new__。但如果我们重写了，那么必须要手动返回 object.__new__(cls)。可如果我们不返回，或者返回其它的话，会怎么样呢？
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 0x0000019A2B7270A0>
type(instance): <class '__main__.Girl'>
"""这里面有很多可以说的点，首先就是 __init__ 里面需要两个参数，但是我们没有传，却还不报错。原因就在于这个 __init__ 压根就没有执行，因为 __new__ 返回的不是 Girl 的实例对象。
通过打印 instance，我们知道了 object.__new__(cls) 返回的就是 cls 的实例对象，而这里的 cls 就是 Girl 这个类本身。所以我们必须要返回 instance，才会自动执行相应的 __init__。
我们在外部来打印一下创建的实例对象吧，看看结果：
class Girl:
def __new__(cls, *args, **kwargs):
return 123
def __init__(self, name, age):
print("__init__ 方法执行啦")
g = Girl()
print(g)
"""
123
"""我们看到打印的结果是 123，所以再次总结一下 tp_new 和 tp_init 之间的区别，当然也对应 __new__ 和 __init__ 的区别：
- tp_new：为实例对象申请内存，底层会调用 tp_alloc，至于对象的大小则记录在 tp_basicsize 字段中，而在 Python 里面则是调用 object.__new__(cls)，然后返回；
- tp_init：tp_new 的返回值会自动传递给 self，然后为 self 绑定相应的属性，也就是进行实例对象的初始化；
但如果 tp_new 返回的对象的类型不对，比如 type_call 的第一个参数接收的是 &PyList_Type，但 tp_new 返回的却是 PyTupleObject *，那么此时就不会执行 tp_init。
对应上面的 Python 代码就是，Girl 的 __new__ 应该返回 Girl 的实例对象（指针）才对，但却返回了整数，因此类型不一致，不会执行 __init__。
所以都说类在实例化的时候会先调用 __new__，再调用 __init__，相信你应该知道原因了，因为在源码中先调用 tp_new，再调用 tp_init。所以源码层面表现出来的，和我们在 Python 层面看到的是一样的。
小结
到此，我们就从 Python 和解释器两个层面解释了对象是如何调用的，更准确的说我们是从解释器的角度对 Python 层面的知识进行了验证，通过 tp_new 和 tp_init 的关系，来了解 __new__ 和 __init__ 的关系。
当然对象调用还不止目前说的这么简单，更多的细节隐藏在了幕后。后续我们会循序渐进，一点点地揭开它的面纱，并且在这个过程中还会不断地学习到新的东西。比如说，实例对象在调用方法的时候会自动将实例本身作为参数传递给 self，那么它为什么会传递呢？解释器在背后又做了什么工作呢？这些在之后的文章中都会详细说明。
