国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

Python源碼理解: '+=' 和 'xx = xx + xx�

learning / 849人閱讀

摘要:前菜在我們使用的過程很多時候會用到運算例如輸出不光在加法中使用在字符串的拼接也同樣發揮這重要的作用例如輸出同樣的在列表中也能使用例如輸出為什么上面不同的對象執行同一個會有不同的效果呢這就涉及到的重載然而這不是本文要討論的重點上面的只是前菜而

前菜

在我們使用Python的過程, 很多時候會用到+運算, 例如:

a = 1 + 2
print a 

# 輸出
3

不光在加法中使用, 在字符串的拼接也同樣發揮這重要的作用, 例如:

a = "abc" + "efg"
print a

# 輸出
abcefg

同樣的, 在列表中也能使用, 例如:

a = [1, 2, 3] + [4, 5, 6]
print a

# 輸出
[1, 2, 3, 4, 5, 6]

為什么上面不同的對象執行同一個+會有不同的效果呢? 這就涉及到+的重載, 然而這不是本文要討論的重點, 上面的只是前菜而已~~~

正文

先看一個例子:

num = 123
num = num + 4
print num

# 輸出
127

這段代碼的用途很明確, 就是一個簡單的數字相加, 但是這樣似乎很繁瑣, 一點都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]  # 列表的+被重載了, 左右操作數必須都是iterable對象, 否則會報錯
print l

# 輸出
[1, 2, 3, 4]

看起來結果都一樣嘛~, 但是真的一樣嗎? 我們改下代碼再看下:

# 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]  # 列表的+被重載了, 左右操作數必須都是iterable對象, 否則會報錯
print "l之后的id: ", id(l)

# 輸出
l之前的id:  40270024
l之后的id:  40270024

看到結果了嗎? 雖然結果一樣, 但是通過id的值表示, 運算前后, 第一種方法對象是不同的了, 而第二種還是同一個對象! 為什么會這樣?

結果分析

先來看看字節碼:

[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    

在上訴的字節碼, 我們著重需要看的是兩個: BINARY_ADDINPLACE_ADD! 很明顯:
l = l + [3, 4, 5]    這種背后就是BINARY_ADD
l += [3, 4, 5]     這種背后就是INPLACE_ADD

深入理解

雖然兩個單詞差很遠, 但其實兩個的作用是很類似的, 最起碼前面一部分是, 為什么這樣說, 請看源碼:

# 取自ceva.c
# BINARY_ADD
TARGET_NOARG(BINARY_ADD)
        {
            w = POP();
            v = TOP();
            if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {    // 檢查左右操作數是否 int 類型
                /* 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)) {                   // 檢查左右操作數是否 string 類型
                x = string_concatenate(v, w, f, next_instr);
                /* string_concatenate consumed the ref to v */
                goto skip_decref_vx;
            }
            else {
              slow_add:                                          // 兩者都不是, 請走這里~
                x = PyNumber_Add(v, w);
            }
           ...(省略)


# INPLACE_ADD
TARGET_NOARG(INPLACE_ADD)
        {
            w = POP();
            v = TOP();
            if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {   // 檢查左右操作數是否 int 類型
                /* 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)) {                 // 檢查左右操作數是否 string 類型
                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);                 // 兩者都不是, 請走這里~
            }
           ... (省略)

從上面可以看出, 不管是BINARY_ADD 還是 INPLACE_ADD, 他們都會有如下相同的操作:

檢查是不是都是`int`類型, 如果是, 直接返回兩個數值相加的結果
檢查是不是都是`string`類型, 如果是, 直接返回字符串拼接的結果

因為兩者的行為真的很類似, 所以在這著重講INPLACE_ADD, 對BINARY_ADD感興趣的童鞋可以在源碼文件: abstract.c, 搜索: PyNumber_Add.實際上也就少了對列表之類對象的操作而已.

那我們接著繼續, 先貼個源碼:

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本質上是對應著abstract.c文件里面的PyNumber_InPlaceAdd函數, 在這個函數中, 首先調用binary_iop1函數, 然后進而又調用了里面的binary_op1函數, 這兩個函數很大一個篇幅, 都是針對ob_type->tp_as_number, 而我們目前是list, 所以他們的大部分操作, 都和我們的無關. 正因為無關, 所以這兩函數調用最后, 直接返回Py_NotImplemented, 而這個是用來干嘛, 這個有大作用, 是列表相加的核心所在!

因為binary_iop1的調用結果是Py_NotImplemented, 所以下面的判斷成立, 開始尋找對象(也就是演示代碼中l對象)的ob_type->tp_as_sequence屬性.

因為我們的對象是l(列表), 所以我們需要去PyList_type需找真相:

# 取自: listobject.c
PyTypeObject PyList_Type = {
    ... (省略)
    &list_as_sequence,                          /* tp_as_sequence */
    ... (省略)
}

可以看出, 其實也就是直接取list_as_sequence, 而這個是什么呢? 其實是一個結構體, 里面存放了列表的部分功能函數.

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對象是否有Py_TPFLAGS_HAVE_INPLACEOPS這個特性, 很明顯是有的, 所以就調用上步取到的結構體中的sq_inplace_concat函數, 那接下來呢? 肯定就是看看這個函數是干嘛的:

list_inplace_concat(PyListObject *self, PyObject *other)
{
    PyObject *result;

    result = listextend(self, other);    # 關鍵所在
    if (result == NULL)
        return result;
    Py_DECREF(result);
    Py_INCREF(self);
    return (PyObject *)self;
}

終于找到關鍵了, 原來最后就是調用這個listextend函數, 這個和我們python層面的列表的extend方法很類似, 在這不細講了!

PyNumber_InPlaceAdd的執行調用過程, 簡單整理下來就是:

INPLACE_ADD(字節碼)
    -> PyNumber_InPlaceAdd
        -> 判斷是否數字: 如果是, 直接返回兩數相加
        -> 判斷是否字符串: 如果是, 直接返回`string_concatenate`的結果
        -> 都不是:
            -> binary_iop1 (判斷是否數字, 如果是則按照數字處理, 否則返回Py_NotImplemented)
                -> binary_iop (判斷是否數字, 如果是則按照數字處理, 否則返回Py_NotImplemented)
            -> 返回的結果是否 Py_NotImplemented:
                -> 是: 
                    -> 對象是否有Py_TPFLAGS_HAVE_INPLACEOPS:
                        -> 是: 調用對象的: sq_inplace_concat
                        -> 否: 調用對象的: sq_concat
                -> 否: 報錯

所以在上面的結果, 第二種代碼: l += [3,4,5], 我們看到的id值并沒有改變, 就是因為+=通過sq_inplace_concat調用了列表的listextend函數, 然后導致新列表以追加的方式去處理.

結論

現在我們大概明白了+=實際上是干嘛了: 它應該能算是一個加強版的+, 因為它比+多了一個寫回本身的功能.不過是否能夠寫回本身, 還是得看對象自身是否支持, 也就是說是否具備Py_NotImplemented標識, 是否支持sq_inplace_concat, 如果具備, 才能實現, 否則, 也就是和 + 效果一樣而已.

歡迎各位大神指點交流,轉載請注明來源: https://segmentfault.com/a/11...

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/44440.html

相關文章

  • Socket Error 104 bug

    摘要:概述技術棧錯誤詳情報警機器人經常有如下警告過程確定報錯位置有日志就很好辦首先看日志在哪里打的從三個地方入手我們自己的代碼沒有的代碼從上下來沒有的代碼在容器中執行 bug概述 技術棧 nginx uwsgi bottle 錯誤詳情 報警機器人經常有如下警告: 1 2018-xx-xxT06:59:03.038Z 660ece0ebaad admin/admin 14 - - Sock...

    keithyau 評論0 收藏0
  • 避免取值時出現Cannot read property &#039;xx&#039; of unde

    摘要:由于是以空函數為代理對象,我們可以將執行它,觸發。中會遍歷數組依次取值,如果發現無法繼續取值則,跳出循環。 本文來自我的博客,歡迎大家去GitHub上star我的博客 我們在取值特別是鏈式取值的時候,常常會遇到Cannot read property xx of undefined的錯誤,如何避免這種情況的發生呢?這里有幾種方法以供參考 使用成熟的庫方法 這是最簡單的一種手段:只用引入...

    fantix 評論0 收藏0
  • module &#039;scipy.misc&#039; has no attribute &#0

    摘要:寫在前面參見了訓練營,收獲頗豐,在此處記錄下我踩過的坑與的沖突從網上翻了資料,都會報錯大部分解釋都說直接安裝我記得我明明有呀是的,我重新裝了一次,依然報錯卸載卸載重裝,依然無果后來猜到可能是各庫版本問題,一搜,還真是這是我在的版本一年前的環 寫在前面 參見了XX訓練營,收獲頗豐,在此處記錄下我踩過的坑 scipy與 Pillow的沖突 >>> from scipy.misc impor...

    CODING 評論0 收藏0
  • 寫了2年python,知道 if __name__ == &#039;__main__&#039;

    摘要:原因很簡單,因為中的代表的就是當前執行的模塊名。缺點就是主程序會受待執行程序的影響,會出現待執行程序中拋異常或主動退出會導致主程序也退出的尷尬問題。總結來說就是,一個是在子進程中執行代碼,一個是在當前進程中執行代碼。 showImg(https://segmentfault.com/img/remote/1460000018607395?w=502&h=318); 相信剛接觸Pytho...

    wangbinke 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<