Python中class内置方法init与new作用与区别探究

技术分享 2年前 (2022-09-26) 0 999+

背景

最近尝试了解Django中ORM实现的原理，发现其用到了metaclass(元类)这一技术，进一步又涉及到Python class中有两个特殊内置方法__init__与__new__，决定先尝试探究一番两者的具体作用与区别。
PS: 本文中涉及的类均为Python3中默认的新式类，对应Python2中则为显式继承了object的class，因为未继承object基类的旧式类并没有这些内置方法。

init方法作用

凡是使用Python自定义过class就必然要和__init__方法打交道，因为class实例的初始化工作即由该函数负责，实例各属性的初始化代码一般都写在这里。事实上之前如果没有认真了解过class实例化的详细过程，会很容易误认为__init__函数就是class的构造函数，负责实例创建(内存分配)、属性初始化工作，但实际上__init__只是负责第二步的属性初始化工作，第一步的内存分配工作另有他人负责--也就是__new__函数。

new方法作用

__new__是一个内置staticmethod，其首个参数必须是type类型--要实例化的class本身，其负责为传入的class type分配内存、创建一个新实例并返回该实例，该返回值其实就是后续执行__init__函数的入参self，大体执行逻辑其实可以从Python的源码typeobject.c中定义的type_call函数看出来：

 955 static PyObject *  956 type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)  957 {  958     PyObject *obj;  959  960     if (type->tp_new == NULL) {  961         PyErr_Format(PyExc_TypeError,  962                      "cannot create '%.100s' instances",  963                      type->tp_name);  964         return NULL;  965     }  ...  974     obj = type->tp_new(type, args, kwds); # 这里先执行tp_new分配内存、创建对象返回obj  975     obj = _Py_CheckFunctionResult((PyObject*)type, obj, NULL);  ...  992     type = Py_TYPE(obj); # 这里获取obj的class类型，并判定有tp_init则执行该初始化函数  993     if (type->tp_init != NULL) {  994         int res = type->tp_init(obj, args, kwds);  995         if (res < 0) {  996             assert(PyErr_Occurred());  997             Py_DECREF(obj);  998             obj = NULL;  999         } 1000         else { 1001             assert(!PyErr_Occurred()); 1002         } 1003     } 1004     return obj; 1005 }

执行代码class(*args, **kwargs) 时，其会先调用type_new函数分配内存创建实例并返回为obj，而后通过Py_TYPE(obj)获取其具体type，再进一步检查type->tp_init不为空则执行该初始化函数。

init && new联系

上面已经明确__new__负责内存分配创建好实例，__init__负责实例属性的相关初始化工作，乍看上去对于实例属性的初始化代码完全可以也放在__new__之中，即__new__同时负责对象创建、属性初始化，省去多定义一个__init__函数的工作，那为什么要把这两个功能拆分开来呢？
stackoverflow上有一个回答感觉比较合理:

As to why they're separate (aside from simple historical reasons): __new__ methods require a bunch of boilerplate to get right (the initial object creation, and then remembering to return the object at the end). __init__ methods, by contrast, are dead simple, since you just set whatever attributes you need to set.

大意是__new__方法自定义要求保证实例创建、并且必须记得返回实例对象的一系列固定逻辑正确，而__init__方法相当简单只需要设置想要设置的属性即可，出错的可能性就很小了，绝大部分场景用户完全只需要更改__init__方法，用户无需感知__new__的相关逻辑。
另外对于一个实例理论上是可以通过多次调用__init__函数进行初始化的，但是任何实例都只可能被创建一次，因为每次调用__new__函数理论上都是创建一个新实例返回(特殊情况如单例模式则只返回首次创建的实例)，而不会存在重新构造已有实例的情况。
针对__init__可被多次调用的情况，mutable和immutable对象会有不同的行为，因为immutable对象从语义上来说首次创建、初始化完成后就不可以修改了，所以后续再调用其__init__方法应该无任何效果才对，如下以list和tuple为例可以看出：

In [1]: a = [1, 2, 3]; print(id(a), a) 4590340288 [1, 2, 3] # 对list实例重新初始化改变其取值为[4, 5] In [2]: a.__init__([4, 5]); print(id(a), a) 4590340288 [4, 5]  In [3]: b = (1, 2, 3); print(id(b), b) 4590557296 (1, 2, 3) # 对tuple实例尝试重新初始化并无任何效果，符合对immutable类型的行为预期 In [4]: b.__init__((4, 5)); print(id(b), b) 4590557296 (1, 2, 3)

这里可以看出将实例创建、初始化工作独立拆分后的一个好处是：要自定义immutable class时，就应该自定义该类的__new__方法，而非__init__方法，对于immutable class的定义更方便了。

使用new的场景

上面已经说过对于绝大部分场景自定义__init__函数初始化实例已经能cover住需求，完全不需要再自定义__new__函数，但是终归是有一些“高端”场景需要自定义__new__的，经过阅读多篇资料，这里大概总结出了两个主要场景举例如下。

定义、继承immutable class

之前已经说过__int__与__new__的拆分使immutable class的定义更加方便了，因为只需要自定义仅在创建时会调用一次的__new__方法即可保证后面任意调用其__init__方法也不会有副作用。
而如果是继承immutable class，要自定义对应immutable 实例的实例化过程，也只能通过自定义__new__来实现，更改__init__是没有用的，如下尝试定义一个PositiveTuple，其继承于tuple，但是会将输入数字全部转化为正数。
首先尝试自定义__init__的方法：

In [95]: class PositiveTuple(tuple):     ...:     def __init__(self, *args, **kwargs):     ...:         print('get in init one, self:', id(self), self)     ...:         # 直接通过索引赋值的方式会报: PositiveTuple' object does not support item assignment     ...:         # for i, x in enumerate(self):     ...:         #     self[i] = abs(x)     ...:         # 只能尝试对self整体赋值     ...:         self = tuple(abs(x) for x in self)     ...:         print('get in init two, self:', id(self), self)     ...:  In [96]: t = PositiveTuple([-3, -2, 5]) get in init one, self: 4590714416 (-3, -2, 5) get in init two, self: 4610402176 (3, 2, 5)  In [97]: print(id(t), t) 4590714416 (-3, -2, 5)

可以看到虽然在__init__中重新对self进行了赋值，其实只是相当于新生成了一个tuple对象4610402176，t指向的依然是最开始生成好的实例4590714416。
如下为使用自定义__new__的方法：

In [128]: class PositiveTuple(tuple):      ...:     def __new__(cls, *args, **kwargs):      ...:         self = super().__new__(cls, *args, **kwargs)      ...:         print('get in init one, self:', id(self), self)      ...:         # 直接通过索引赋值的方式会报: PositiveTuple' object does not support item assignment      ...:         # for i, x in enumerate(self):      ...:         #     self[i] = abs(x)      ...:         # 只能尝试对self整体赋值      ...:         self = tuple(abs(x) for x in self)      ...:         print('get in init two, self:', id(self), self)      ...:         return self      ...:      ...: In [129]: t = PositiveTuple([-3, -2, 5]) get in init one, self: 4621148432 (-3, -2, 5) get in init two, self: 4611736752 (3, 2, 5)  In [130]: print(id(t), t) 4611736752 (3, 2, 5)

可以看到一开始调用super.__new__时其实已经创建了一个实例4621148432，而后通过新生成一个全部转化为正数的tuple 4611736752赋值后返回，最终返回的实例t也就最终需要的全正数tuple。

使用metaclass

另一个使用__new__函数的场景是metaclass，这是一个号称99%的程序员都可以不用了解的“真高端”技术，也是Django中ORM实现的核心技术，目前本人也还在摸索、初学之中，这里推荐廖老师的一篇文章科普：https://www.liaoxuefeng.com/wiki/1016959663602400/1017592449371072 ，以后有机会再单独写一篇blog探究。
转载请注明出处，原文地址： https://www.cnblogs.com/AcAc-t/p/python_builtint_new_init_meaning.html