技術文章 » Python中class內建方法__init__與__new__作用與區別探究

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

2022-09-26 06:01:59

背景

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