Python中class內置方法__init__與__new__作用與區別探究

背景

最近嘗試了解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

參考

https://stackoverflow.com/a/4859181/11153091
https://www.liaoxuefeng.com/wiki/1016959663602400/1017592449371072
https://xxhs-blog.readthedocs.io/zh_CN/latest/how_to_be_a_rich_man.html
https://blog.csdn.net/luoweifu/article/details/82732313
https://www.cnblogs.com/wdliu/p/6757511.html

標籤：其他

上一篇：上傳檔案-給檔案起隨機名

下一篇：密碼學奇妙之旅、01 CFB密文反饋模式、AES標準、Golang代碼