<h2>前菜</h2>    <p>在我们使用Python的过程, 很多时候会用到 + 运算, 例如:</p>    <pre>  <code class="language-python">a = 1 + 2  print a     # 输出  3</code></pre>    <p>不光在加法中使用, 在字符串的拼接也同样发挥这重要的作用, 例如:</p>    <pre>  <code class="language-python">a = 'abc' + 'efg'  print a    # 输出  abcefg</code></pre>    <p>同样的, 在列表中也能使用, 例如:</p>    <pre>  <code class="language-python">a = [1, 2, 3] + [4, 5, 6]  print a    # 输出  [1, 2, 3, 4, 5, 6]</code></pre>    <p>为什么上面不同的对象执行同一个 + 会有不同的效果呢? 这就涉及到 + 的重载, 然而这不是本文要讨论的重点, 上面的只是前菜而已~~~</p>    <h2>正文</h2>    <p>先看一个例子:</p>    <pre>  <code class="language-python">num = 123  num = num + 4  print num    # 输出  127</code></pre>    <p>这段代码的用途很明确, 就是一个简单的数字相加, 但是这样似乎很繁琐, 一点都Pythonic, 于是就有了下面的代码:</p>    <pre>  <code class="language-python">num = 123  num += 4  print num    # 输出  127</code></pre>    <p>哈, 这样就很Pythonic了! 但是这种用法真的就是这么好么? 不一定. 看例子:</p>    <pre>  <code class="language-python"># 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]</code></pre>    <p>看起来结果都一样嘛~, 但是真的一样吗? 我们改下代码再看下:</p>    <pre>  <code class="language-python"># 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</code></pre>    <p>看到结果了吗? 虽然结果一样, 但是通过 id 的值表示, 运算前后, 第一种方法对象是不同的了, 而第二种还是同一个对象! 为什么会这样?</p>    <h2>结果分析</h2>    <p>先来看看字节码:</p>    <pre>  <code class="language-python">[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</code></pre>    <p>在上诉的字节码, 我们着重需要看的是两个: BINARY_ADD 和 INPLACE_ADD ! 很明显:</p>    <p>l = l + [3, 4, 5] 这种背后就是 BINARY_ADD</p>    <p>l += [3, 4, 5] 这种背后就是 INPLACE_ADD</p>    <h2>深入理解</h2>    <p>虽然两个单词差很远, 但其实两个的作用是很类似的, 最起码前面一部分是, 为什么这样说, 请看源码:</p>    <pre>  <code class="language-python"># 取自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);                 // 两者都不是, 请走这里~              }             ... (省略)</code></pre>    <p>从上面可以看出, 不管是 BINARY_ADD 还是 INPLACE_ADD , 他们都会有如下相同的操作:</p>    <pre>  <code class="language-python">检查是不是都是`int`类型, 如果是, 直接返回两个数值相加的结果  检查是不是都是`string`类型, 如果是, 直接返回字符串拼接的结果</code></pre>    <p>因为两者的行为真的很类似, 所以在这着重讲 INPLACE_ADD , 对 BINARY_ADD 感兴趣的童鞋可以在源码文件: abstract.c , 搜索: PyNumber_Add .实际上也就少了对列表之类对象的操作而已.</p>    <p>那我们接着继续, 先贴个源码:</p>    <pre>  <code class="language-python">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;</code></pre>    <p>INPLACE_ADD 本质上是对应着 abstract.c 文件里面的 PyNumber_InPlaceAdd 函数, 在这个函数中, 首先调用 binary_iop1 函数, 然后进而又调用了里面的 binary_op1 函数, 这两个函数很大一个篇幅, 都是针对 ob_type->tp_as_number , 而我们目前是 list , 所以他们的大部分操作, 都和我们的无关. 正因为无关, 所以这两函数调用最后, 直接返回 Py_NotImplemented , 而这个是用来干嘛, 这个有大作用, 是列表相加的核心所在!</p>    <p>因为 binary_iop1 的调用结果是 Py_NotImplemented , 所以下面的判断成立, 开始寻找对象( 也就是演示代码中l对象 )的 ob_type->tp_as_sequence 属性.</p>    <p>因为我们的对象是l(列表), 所以我们需要去 PyList_type 需找真相:</p>    <pre>  <code class="language-python"># 取自: listobject.c  PyTypeObject PyList_Type = {      ... (省略)      &list_as_sequence,                          /* tp_as_sequence */      ... (省略)  }</code></pre>    <p>可以看出, 其实也就是直接取 list_as_sequence , 而这个是什么呢? 其实是一个结构体, 里面存放了列表的部分功能函数.</p>    <pre>  <code class="language-python">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 */  };</code></pre>    <p>接下来就是一个判断, 判断咱们这个 l 对象是否有 Py_TPFLAGS_HAVE_INPLACEOPS 这个特性, 很明显是有的, 所以就调用上步取到的结构体中的 sq_inplace_concat 函数, 那接下来呢? 肯定就是看看这个函数是干嘛的:</p>    <pre>  <code class="language-python">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;  }</code></pre>    <p>终于找到关键了, 原来最后就是调用这个 listextend 函数, 这个和我们 python 层面的列表的 extend方法 很类似, 在这不细讲了!</p>    <p>把 PyNumber_InPlaceAdd 的执行调用过程, 简单整理下来就是:</p>    <pre>  <code class="language-python">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                  -> 否: 报错</code></pre>    <p>所以在上面的结果, 第二种代码: l += [3,4,5] , 我们看到的 id 值并没有改变, 就是因为 += 通过 sq_inplace_concat 调用了列表的 listextend 函数, 然后导致新列表以追加的方式去处理.</p>    <h2>结论</h2>    <p>现在我们大概明白了 += 实际上是干嘛了: 它应该能算是一个加强版的 + , 因为它比 + 多了一个写回本身的功能.不过是否能够写回本身, 还是得看对象自身是否支持, 也就是说是否具备 Py_NotImplemented 标识, 是否支持 sq_inplace_concat , 如果具备, 才能实现, 否则, 也就是和 + 效果一样而已.</p>    <p> </p>    <p>来自：https://segmentfault.com/a/1190000009764209</p>    <p> </p>