最近嘗試了解Django中ORM實(shí)現(xiàn)的原理，發(fā)現(xiàn)其用到了metaclass(元類)這一技術(shù)，進(jìn)一步又涉及到Python class中有兩個特殊內(nèi)置方法__init__與__new__，決定先嘗試探究一番兩者的具體作用與區(qū)別。
PS: 本文中涉及的類均為Python3中默認(rèn)的新式類，對應(yīng)Python2中則為顯式繼承了object的class，因?yàn)槲蠢^承object基類的舊式類并沒有這些內(nèi)置方法。
為懷化等地區(qū)用戶提供了全套網(wǎng)頁設(shè)計制作服務(wù)，及懷化網(wǎng)站建設(shè)行業(yè)解決方案。主營業(yè)務(wù)為成都網(wǎng)站制作、成都網(wǎng)站設(shè)計、懷化網(wǎng)站設(shè)計，以傳統(tǒng)方式定制建設(shè)網(wǎng)站，并提供域名空間備案等一條龍服務(wù)，秉承以專業(yè)、用心的態(tài)度為用戶提供真誠的服務(wù)。我們深信只要達(dá)到每一位用戶的要求，就會得到認(rèn)可，從而選擇與我們長期合作。這樣，我們也可以走得更遠(yuǎn)！
凡是使用Python自定義過class就必然要和__init__方法打交道，因?yàn)閏lass實(shí)例的初始化工作即由該函數(shù)負(fù)責(zé)，實(shí)例各屬性的初始化代碼一般都寫在這里。事實(shí)上之前如果沒有認(rèn)真了解過class實(shí)例化的詳細(xì)過程，會很容易誤認(rèn)為__init__函數(shù)就是class的構(gòu)造函數(shù)，負(fù)責(zé)實(shí)例創(chuàng)建(內(nèi)存分配)、屬性初始化工作，但實(shí)際上__init__只是負(fù)責(zé)第二步的屬性初始化工作，第一步的內(nèi)存分配工作另有他人負(fù)責(zé)--也就是__new__函數(shù)。
__new__是一個內(nèi)置staticmethod，其首個參數(shù)必須是type類型--要實(shí)例化的class本身，其負(fù)責(zé)為傳入的class type分配內(nèi)存、創(chuàng)建一個新實(shí)例并返回該實(shí)例，該返回值其實(shí)就是后續(xù)執(zhí)行__init__函數(shù)的入?yún)elf，大體執(zhí)行邏輯其實(shí)可以從Python的源碼typeobject.c中定義的type_call函數(shù)看出來：
重慶分公司
重慶分公司
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); # 這里先執(zhí)行tp_new分配內(nèi)存、創(chuàng)建對象返回obj
975 obj = _Py_CheckFunctionResult((PyObject*)type, obj, NULL);
...
992 type = Py_TYPE(obj); # 這里獲取obj的class類型，并判定有tp_init則執(zhí)行該初始化函數(shù)
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 }
執(zhí)行代碼class(*args, **kwargs) 時，其會先調(diào)用type_new函數(shù)分配內(nèi)存創(chuàng)建實(shí)例并返回為obj，而后通過Py_TYPE(obj)獲取其具體type，再進(jìn)一步檢查type->tp_init不為空則執(zhí)行該初始化函數(shù)。
上面已經(jīng)明確__new__負(fù)責(zé)內(nèi)存分配創(chuàng)建好實(shí)例，__init__負(fù)責(zé)實(shí)例屬性的相關(guān)初始化工作，乍看上去對于實(shí)例屬性的初始化代碼完全可以也放在__new__之中，即__new__同時負(fù)責(zé)對象創(chuàng)建、屬性初始化，省去多定義一個__init__函數(shù)的工作，那為什么要把這兩個功能拆分開來呢？
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__方法自定義要求保證實(shí)例創(chuàng)建、并且必須記得返回實(shí)例對象的一系列固定邏輯正確，而__init__方法相當(dāng)簡單只需要設(shè)置想要設(shè)置的屬性即可，出錯的可能性就很小了，絕大部分場景用戶完全只需要更改__init__方法，用戶無需感知__new__的相關(guān)邏輯。
另外對于一個實(shí)例理論上是可以通過多次調(diào)用__init__函數(shù)進(jìn)行初始化的，但是任何實(shí)例都只可能被創(chuàng)建一次，因?yàn)槊看握{(diào)用__new__函數(shù)理論上都是創(chuàng)建一個新實(shí)例返回(特殊情況如單例模式則只返回首次創(chuàng)建的實(shí)例)，而不會存在重新構(gòu)造已有實(shí)例的情況。
針對__init__可被多次調(diào)用的情況，mutable和immutable對象會有不同的行為，因?yàn)閕mmutable對象從語義上來說首次創(chuàng)建、初始化完成后就不可以修改了，所以后續(xù)再調(diào)用其__init__方法應(yīng)該無任何效果才對，如下以list和tuple為例可以看出：
In [1]: a = [1, 2, 3]; print(id(a), a)
[1, 2, 3]
# 對list實(shí)例重新初始化改變其取值為[4, 5]
In [2]: a.__init__([4, 5]); print(id(a), a)
[4, 5]
In [3]: b = (1, 2, 3); print(id(b), b)
(1, 2, 3)
# 對tuple實(shí)例嘗試重新初始化并無任何效果，符合對immutable類型的行為預(yù)期
In [4]: b.__init__((4, 5)); print(id(b), b)
(1, 2, 3)
這里可以看出將實(shí)例創(chuàng)建、初始化工作獨(dú)立拆分后的一個好處是：要自定義immutable class時，就應(yīng)該自定義該類的__new__方法，而非__init__方法，對于immutable class的定義更方便了。
上面已經(jīng)說過對于絕大部分場景自定義__init__函數(shù)初始化實(shí)例已經(jīng)能cover住需求，完全不需要再自定義__new__函數(shù)，但是終歸是有一些“高端”場景需要自定義__new__的，經(jīng)過閱讀多篇資料，這里大概總結(jié)出了兩個主要場景舉例如下。
之前已經(jīng)說過__int__與__new__的拆分使immutable class的定義更加方便了，因?yàn)橹恍枰远x僅在創(chuàng)建時會調(diào)用一次的__new__方法即可保證后面任意調(diào)用其__init__方法也不會有副作用。
而如果是繼承immutable class，要自定義對應(yīng)immutable 實(shí)例的實(shí)例化過程，也只能通過自定義__new__來實(shí)現(xiàn)，更改__init__是沒有用的，如下嘗試定義一個PositiveTuple，其繼承于tuple，但是會將輸入數(shù)字全部轉(zhuǎn)化為正數(shù)。
首先嘗試自定義__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: (-3, -2, 5)
get in init two, self: (3, 2, 5)
In [97]: print(id(t), t)
(-3, -2, 5)
可以看到雖然在__init__中重新對self進(jìn)行了賦值，其實(shí)只是相當(dāng)于新生成了一個tuple對象，t指向的依然是最開始生成好的實(shí)例。
如下為使用自定義__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: (-3, -2, 5)
get in init two, self: (3, 2, 5)
In [130]: print(id(t), t)
(3, 2, 5)
可以看到一開始調(diào)用super.__new__時其實(shí)已經(jīng)創(chuàng)建了一個實(shí)例，而后通過新生成一個全部轉(zhuǎn)化為正數(shù)的tuple 賦值后返回，最終返回的實(shí)例t也就最終需要的全正數(shù)tuple。
另一個使用__new__函數(shù)的場景是metaclass，這是一個號稱99%的程序員都可以不用了解的“真高端”技術(shù)，也是Django中ORM實(shí)現(xiàn)的核心技術(shù)，目前本人也還在摸索、初學(xué)之中，這里推薦廖老師的一篇文章科普：https://www.liaoxuefeng.com/wiki// ，以后有機(jī)會再單獨(dú)寫一篇blog探究。
轉(zhuǎn)載請注明出處，原文地址： https://www.cnblogs.com/AcAc-t/p/python_builtint_new_init_meaning.html
https://stackoverflow.com/a//
https://www.liaoxuefeng.com/wiki//
https://xxhs-blog.readthedocs.io/zh_CN/latest/how_to_be_a_rich_man.html
https://blog.csdn.net/luoweifu/article/details/
https://www.cnblogs.com/wdliu/p/.html
