[[194303]]

前菜

在我們使用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)?binary_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), 否則, 也就是和 + 效果一樣而已.