Python源碼理解: '+=' 和 'xx = xx + xx' 的區(qū)別
前菜
在我們使用Python的過(guò)程, 很多時(shí)候會(huì)用到+運(yùn)算, 例如:
- a = 1 + 2
- print a
- # 輸出
- 3
不光在加法中使用, 在字符串的拼接也同樣發(fā)揮這重要的作用, 例如:
- a = 'abc' + 'efg'
- print a
- # 輸出
- abcefg
同樣的, 在列表中也能使用, 例如:
- a = [1, 2, 3] + [4, 5, 6]
- print a
- # 輸出
- [1, 2, 3, 4, 5, 6]
為什么上面不同的對(duì)象執(zhí)行同一個(gè)+會(huì)有不同的效果呢? 這就涉及到+的重載, 然而這不是本文要討論的重點(diǎn), 上面的只是前菜而已~~~
正文
先看一個(gè)例子:
- num = 123
- num = num + 4
- print num
- # 輸出
- 127
這段代碼的用途很明確, 就是一個(gè)簡(jiǎn)單的數(shù)字相加, 但是這樣似乎很繁瑣, 一點(diǎn)都Pythonic, 于是就有了下面的代碼:
- num = 123
- num += 4
- print num
- # 輸出
- 127
哈, 這樣就很Pythonic了! 但是這種用法真的就是這么好么? 不一定. 看例子:
- # coding: utf8
- l = [1, 2]
- l = l + [3, 4]
- print l
- # 輸出
- [1, 2, 3, 4]
- # ------------------------------------------
- l = [1, 2]
- l += [3, 4] # 列表的+被重載了, 左右操作數(shù)必須都是iterable對(duì)象, 否則會(huì)報(bào)錯(cuò)
- print l
- # 輸出
- [1, 2, 3, 4]
看起來(lái)結(jié)果都一樣嘛~, 但是真的一樣嗎? 我們改下代碼再看下:
- # coding: utf8
- l = [1, 2]
- print 'l之前的id: ', id(l)
- l = l + [3, 4]
- print 'l之后的id: ', id(l)
- # 輸出
- l之前的id: 40270024
- l之后的id: 40389000
- # ------------------------------------------
- l = [1, 2]
- print 'l之前的id: ', id(l)
- l += [3, 4] # 列表的+被重載了, 左右操作數(shù)必須都是iterable對(duì)象, 否則會(huì)報(bào)錯(cuò)
- print 'l之后的id: ', id(l)
- # 輸出
- l之前的id: 40270024
- l之后的id: 40270024
看到結(jié)果了嗎? 雖然結(jié)果一樣, 但是通過(guò)id的值表示, 運(yùn)算前后, 第一種方法對(duì)象是不同的了, 而第二種還是同一個(gè)對(duì)象! 為什么會(huì)這樣?
結(jié)果分析
先來(lái)看看字節(jié)碼:
- [root@test1 ~]# cat 2.py
- # coding: utf8
- l = [1, 2]
- l = l + [3, 4]
- print l
- l = [1, 2]
- l += [3, 4]
- print l
- [root@test1 ~]# python -m dis 2.py
- 2 0 LOAD_CONST 0 (1)
- 3 LOAD_CONST 1 (2)
- 6 BUILD_LIST 2
- 9 STORE_NAME 0 (l)
- 3 12 LOAD_NAME 0 (l)
- 15 LOAD_CONST 2 (3)
- 18 LOAD_CONST 3 (4)
- 21 BUILD_LIST 2
- 24 BINARY_ADD
- 25 STORE_NAME 0 (l)
- 4 28 LOAD_NAME 0 (l)
- 31 PRINT_ITEM
- 32 PRINT_NEWLINE
- 7 33 LOAD_CONST 0 (1)
- 36 LOAD_CONST 1 (2)
- 39 BUILD_LIST 2
- 42 STORE_NAME 0 (l)
- 8 45 LOAD_NAME 0 (l)
- 48 LOAD_CONST 2 (3)
- 51 LOAD_CONST 3 (4)
- 54 BUILD_LIST 2
- 57 INPLACE_ADD
- 58 STORE_NAME 0 (l)
- 9 61 LOAD_NAME 0 (l)
- 64 PRINT_ITEM
- 65 PRINT_NEWLINE
- 66 LOAD_CONST 4 (None)
- 69 RETURN_VALUE
在上訴的字節(jié)碼, 我們著重需要看的是兩個(gè): BINARY_ADD 和 INPLACE_ADD!
很明顯:
- l = l + [3, 4, 5] 這種背后就是BINARY_ADD
- l += [3, 4, 5] 這種背后就是INPLACE_ADD
深入理解
雖然兩個(gè)單詞差很遠(yuǎn), 但其實(shí)兩個(gè)的作用是很類(lèi)似的, 最起碼前面一部分是, 為什么這樣說(shuō), 請(qǐng)看源碼:
- # 取自ceva.c
- # BINARY_ADD
- TARGET_NOARG(BINARY_ADD)
- {
- w = POP();
- v = TOP();
- if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { // 檢查左右操作數(shù)是否 int 類(lèi)型
- /* INLINE: int + int */
- register long a, b, i;
- a = PyInt_AS_LONG(v);
- b = PyInt_AS_LONG(w);
- /* cast to avoid undefined behaviour
- on overflow */
- i = (long)((unsigned long)a + b);
- if ((i^a) < 0 && (i^b) < 0)
- goto slow_add;
- x = PyInt_FromLong(i);
- }
- else if (PyString_CheckExact(v) &&
- PyString_CheckExact(w)) { // 檢查左右操作數(shù)是否 string 類(lèi)型
- x = string_concatenate(v, w, f, next_instr);
- /* string_concatenate consumed the ref to v */
- goto skip_decref_vx;
- }
- else {
- slow_add: // 兩者都不是, 請(qǐng)走這里~
- x = PyNumber_Add(v, w);
- }
- ...(省略)
- # INPLACE_ADD
- TARGET_NOARG(INPLACE_ADD)
- {
- w = POP();
- v = TOP();
- if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) { // 檢查左右操作數(shù)是否 int 類(lèi)型
- /* INLINE: int + int */
- register long a, b, i;
- a = PyInt_AS_LONG(v);
- b = PyInt_AS_LONG(w);
- i = a + b;
- if ((i^a) < 0 && (i^b) < 0)
- goto slow_iadd;
- x = PyInt_FromLong(i);
- }
- else if (PyString_CheckExact(v) &&
- PyString_CheckExact(w)) { // 檢查左右操作數(shù)是否 string 類(lèi)型
- x = string_concatenate(v, w, f, next_instr);
- /* string_concatenate consumed the ref to v */
- goto skip_decref_v;
- }
- else {
- slow_iadd:
- x = PyNumber_InPlaceAdd(v, w); // 兩者都不是, 請(qǐng)走這里~
- }
- ... (省略)
從上面可以看出, 不管是BINARY_ADD 還是INPLACE_ADD, 他們都會(huì)有如下相同的操作:
檢查是不是都是`int`類(lèi)型, 如果是, 直接返回兩個(gè)數(shù)值相加的結(jié)果
檢查是不是都是`string`類(lèi)型, 如果是, 直接返回字符串拼接的結(jié)果
因?yàn)閮烧叩男袨檎娴暮茴?lèi)似, 所以在這著重講INPLACE_ADD, 對(duì)BINARY_ADD感興趣的童鞋可以在源碼文件: abstract.c, 搜索: PyNumber_Add.實(shí)際上也就少了對(duì)列表之類(lèi)對(duì)象的操作而已.
那我們接著繼續(xù), 先貼個(gè)源碼:
- PyObject *
- PyNumber_InPlaceAdd(PyObject *v, PyObject *w)
- {
- PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),
- NB_SLOT(nb_add));
- if (result == Py_NotImplemented) {
- PySequenceMethods *m = v->ob_type->tp_as_sequence;
- Py_DECREF(result);
- if (m != NULL) {
- binaryfunc f = NULL;
- if (HASINPLACE(v))
- f = m->sq_inplace_concat;
- if (f == NULL)
- f = m->sq_concat;
- if (f != NULL)
- return (*f)(v, w);
- }
- result = binop_type_error(v, w, "+=");
- }
- return result;
INPLACE_ADD本質(zhì)上是對(duì)應(yīng)著abstract.c文件里面的PyNumber_InPlaceAdd函數(shù), 在這個(gè)函數(shù)中, 首先調(diào)用binary_iop1函數(shù), 然后進(jìn)而又調(diào)用了里面的binary_op1函數(shù), 這兩個(gè)函數(shù)很大一個(gè)篇幅, 都是針對(duì)ob_type->tp_as_number, 而我們目前是list, 所以他們的大部分操作, 都和我們的無(wú)關(guān). 正因?yàn)闊o(wú)關(guān), 所以這兩函數(shù)調(diào)用最后, 直接返回Py_NotImplemented, 而這個(gè)是用來(lái)干嘛, 這個(gè)有大作用, 是列表相加的核心所在!
因?yàn)閎inary_iop1的調(diào)用結(jié)果是Py_NotImplemented, 所以下面的判斷成立, 開(kāi)始尋找對(duì)象(也就是演示代碼中l(wèi)對(duì)象)的ob_type->tp_as_sequence屬性.
因?yàn)槲覀兊膶?duì)象是l(列表), 所以我們需要去PyList_type需找真相:
- # 取自: listobject.c
- PyTypeObject PyList_Type = {
- ... (省略)
- &list_as_sequence, /* tp_as_sequence */
- ... (省略)
- }
可以看出, 其實(shí)也就是直接取list_as_sequence, 而這個(gè)是什么呢? 其實(shí)是一個(gè)結(jié)構(gòu)體, 里面存放了列表的部分功能函數(shù).
- static PySequenceMethods list_as_sequence = {
- (lenfunc)list_length, /* sq_length */
- (binaryfunc)list_concat, /* sq_concat */
- (ssizeargfunc)list_repeat, /* sq_repeat */
- (ssizeargfunc)list_item, /* sq_item */
- (ssizessizeargfunc)list_slice, /* sq_slice */
- (ssizeobjargproc)list_ass_item, /* sq_ass_item */
- (ssizessizeobjargproc)list_ass_slice, /* sq_ass_slice */
- (objobjproc)list_contains, /* sq_contains */
- (binaryfunc)list_inplace_concat, /* sq_inplace_concat */
- (ssizeargfunc)list_inplace_repeat, /* sq_inplace_repeat */
- };
接下來(lái)就是一個(gè)判斷, 判斷咱們這個(gè)l對(duì)象是否有Py_TPFLAGS_HAVE_INPLACEOPS這個(gè)特性, 很明顯是有的, 所以就調(diào)用上步取到的結(jié)構(gòu)體中的sq_inplace_concat函數(shù), 那接下來(lái)呢? 肯定就是看看這個(gè)函數(shù)是干嘛的:
- list_inplace_concat(PyListObject *self, PyObject *other)
- {
- PyObject *result;
- result = listextend(self, other); # 關(guān)鍵所在
- if (result == NULL)
- return result;
- Py_DECREF(result);
- Py_INCREF(self);
- return (PyObject *)self;
- }
終于找到關(guān)鍵了, 原來(lái)最后就是調(diào)用這個(gè)listextend函數(shù), 這個(gè)和我們python層面的列表的extend方法很類(lèi)似, 在這不細(xì)講了!
把PyNumber_InPlaceAdd的執(zhí)行調(diào)用過(guò)程, 簡(jiǎn)單整理下來(lái)就是:
- INPLACE_ADD(字節(jié)碼)
- -> PyNumber_InPlaceAdd
- -> 判斷是否數(shù)字: 如果是, 直接返回兩數(shù)相加
- -> 判斷是否字符串: 如果是, 直接返回`string_concatenate`的結(jié)果
- -> 都不是:
- -> binary_iop1 (判斷是否數(shù)字, 如果是則按照數(shù)字處理, 否則返回Py_NotImplemented)
- -> binary_iop (判斷是否數(shù)字, 如果是則按照數(shù)字處理, 否則返回Py_NotImplemented)
- -> 返回的結(jié)果是否 Py_NotImplemented:
- -> 是:
- -> 對(duì)象是否有Py_TPFLAGS_HAVE_INPLACEOPS:
- -> 是: 調(diào)用對(duì)象的: sq_inplace_concat
- -> 否: 調(diào)用對(duì)象的: sq_concat
- -> 否: 報(bào)錯(cuò)
所以在上面的結(jié)果, 第二種代碼: l += [3,4,5], 我們看到的id值并沒(méi)有改變, 就是因?yàn)?=通過(guò)sq_inplace_concat調(diào)用了列表的listextend函數(shù), 然后導(dǎo)致新列表以追加的方式去處理.
結(jié)論
現(xiàn)在我們大概明白了+=實(shí)際上是干嘛了: 它應(yīng)該能算是一個(gè)加強(qiáng)版的+, 因?yàn)樗?多了一個(gè)寫(xiě)回本身的功能.不過(guò)是否能夠?qū)懟乇旧? 還是得看對(duì)象自身是否支持, 也就是說(shuō)是否具備Py_NotImplemented標(biāo)識(shí), 是否支持sq_inplace_concat, 如果具備, 才能實(shí)現(xiàn), 否則, 也就是和 + 效果一樣而已.
