Python源码理解: '+=' 和 'xx = xx + xx' 的区别

开发 后端
+=实际上是干嘛了: 它应该能算是一个加强版的+, 因为它比+多了一个写回本身的功能.不过是否能够写回本身, 还是得看对象自身是否支持, 也就是说是否具备Py_NotImplemented标识, 是否支持sq_inplace_concat, 如果具备, 才能实现, 否则, 也就是和 + 效果一样而已。

[[200486]]

前菜

在我们使用Python的过程, 很多时候会用到+运算, 例如:

  1. a = 1 + 2 
  2.  
  3. print a 
  4.  
  5. # 输出 
  6.  

 

不光在加法中使用, 在字符串的拼接也同样发挥这重要的作用, 例如:

  1. a = 'abc' + 'efg' 
  2.  
  3. print a 
  4.  
  5. # 输出 
  6.  
  7. abcefg 

 

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

  1. a = [1, 2, 3] + [4, 5, 6] 
  2.  
  3. print a 
  4.  
  5. # 输出 
  6.  
  7. [1, 2, 3, 4, 5, 6] 

 

为什么上面不同的对象执行同一个+会有不同的效果呢? 这就涉及到+的重载, 然而这不是本文要讨论的重点, 上面的只是前菜而已~~~

正文

先看一个例子:

  1. num = 123 
  2.  
  3. num = num + 4 
  4.  
  5. print num 
  6.  
  7. # 输出 
  8.  
  9. 127 

 

这段代码的用途很明确, 就是一个简单的数字相加, 但是这样似乎很繁琐, 一点都Pythonic, 于是就有了下面的代码:

  1. num = 123 
  2.  
  3. num += 4 
  4.  
  5. print num 
  6.  
  7. # 输出 
  8.  
  9. 127 

 

哈, 这样就很Pythonic了! 但是这种用法真的就是这么好么? 不一定. 看例子:

  1. # coding: utf8 
  2.  
  3. l = [1, 2] 
  4.  
  5. l = l + [3, 4] 
  6.  
  7. print l 
  8.  
  9. # 输出 
  10.  
  11. [1, 2, 3, 4] 
  12.  
  13. ------------------------------------------ 
  14.  
  15. l = [1, 2] 
  16.  
  17. l += [3, 4] # 列表的+被重载了, 左右操作数必须都是iterable对象, 否则会报错 
  18.  
  19. print l 
  20.  
  21. # 输出 
  22.  
  23. [1, 2, 3, 4] 

 

看起来结果都一样嘛~, 但是真的一样吗? 我们改下代码再看下:

  1. # coding: utf8 
  2.  
  3. l = [1, 2] 
  4.  
  5. print 'l之前的id: ', id(l) 
  6.  
  7. l = l + [3, 4] 
  8.  
  9. print 'l之后的id: ', id(l) 
  10.  
  11.   
  12.  
  13. # 输出 
  14.  
  15. l之前的id:  40270024 
  16.  
  17. l之后的id:  40389000 
  18.  
  19.   
  20.  
  21. ------------------------------------------ 
  22.  
  23.   
  24.  
  25. l = [1, 2] 
  26.  
  27. print 'l之前的id: ', id(l) 
  28.  
  29. l += [3, 4]  # 列表的+被重载了, 左右操作数必须都是iterable对象, 否则会报错 
  30.  
  31. print 'l之后的id: ', id(l) 
  32.  
  33.   
  34.  
  35. # 输出 
  36.  
  37. l之前的id:  40270024 
  38.  
  39. l之后的id:  40270024 

 

看到结果了吗? 虽然结果一样, 但是通过id的值表示, 运算前后, 第一种方法对象是不同的了, 而第二种还是同一个对象! 为什么会这样?

结果分析

先来看看字节码:

  1. [root@test1 ~]# cat 2.py 
  2.  
  3. # coding: utf8 
  4.  
  5. l = [1, 2] 
  6.  
  7. l = l + [3, 4] 
  8.  
  9. print l 
  10.  
  11.   
  12.  
  13.   
  14.  
  15. l = [1, 2] 
  16.  
  17. l += [3, 4]   
  18.  
  19. print l 
  20.  
  21. [root@test1 ~]# python -m dis 2.py 
  22.  
  23.   2           0 LOAD_CONST               0 (1) 
  24.  
  25.               3 LOAD_CONST               1 (2) 
  26.  
  27.               6 BUILD_LIST               2 
  28.  
  29.               9 STORE_NAME               0 (l) 
  30.  
  31.   
  32.  
  33.   3          12 LOAD_NAME                0 (l) 
  34.  
  35.              15 LOAD_CONST               2 (3) 
  36.  
  37.              18 LOAD_CONST               3 (4) 
  38.  
  39.              21 BUILD_LIST               2 
  40.  
  41.              24 BINARY_ADD           
  42.  
  43.              25 STORE_NAME               0 (l) 
  44.  
  45.   
  46.  
  47.   4          28 LOAD_NAME                0 (l) 
  48.  
  49.              31 PRINT_ITEM           
  50.  
  51.              32 PRINT_NEWLINE       
  52.  
  53.   
  54.  
  55.   7          33 LOAD_CONST               0 (1) 
  56.  
  57.              36 LOAD_CONST               1 (2) 
  58.  
  59.              39 BUILD_LIST               2 
  60.  
  61.              42 STORE_NAME               0 (l) 
  62.  
  63.   
  64.  
  65.   8          45 LOAD_NAME                0 (l) 
  66.  
  67.              48 LOAD_CONST               2 (3) 
  68.  
  69.              51 LOAD_CONST               3 (4) 
  70.  
  71.              54 BUILD_LIST               2 
  72.  
  73.              57 INPLACE_ADD         
  74.  
  75.              58 STORE_NAME               0 (l) 
  76.  
  77.   
  78.  
  79.   9          61 LOAD_NAME                0 (l) 
  80.  
  81.              64 PRINT_ITEM           
  82.  
  83.              65 PRINT_NEWLINE       
  84.  
  85.              66 LOAD_CONST               4 (None) 
  86.  
  87.              69 RETURN_VALUE 

 

在上诉的字节码, 我们着重需要看的是两个: BINARY_ADD 和 INPLACE_ADD!

很明显:

  • l = l + [3, 4, 5]    这种背后就是BINARY_ADD
  • l += [3, 4, 5]     这种背后就是INPLACE_ADD

深入理解

虽然两个单词差很远, 但其实两个的作用是很类似的, 最起码前面一部分是, 为什么这样说, 请看源码:

  1. # 取自ceva.c 
  2.  
  3. # BINARY_ADD 
  4.  
  5. TARGET_NOARG(BINARY_ADD) 
  6.  
  7.         { 
  8.  
  9.             w = POP(); 
  10.  
  11.             v = TOP(); 
  12.  
  13.             if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {    // 检查左右操作数是否 int 类型 
  14.  
  15.                 /* INLINE: int + int */ 
  16.  
  17.                 register long a, b, i; 
  18.  
  19.                 a = PyInt_AS_LONG(v); 
  20.  
  21.                 b = PyInt_AS_LONG(w); 
  22.  
  23.                 /* cast to avoid undefined behaviour 
  24.  
  25.                    on overflow */ 
  26.  
  27.                 i = (long)((unsigned long)a + b); 
  28.  
  29.                 if ((i^a) < 0 && (i^b) < 0) 
  30.  
  31.                     goto slow_add; 
  32.  
  33.                 x = PyInt_FromLong(i); 
  34.  
  35.             } 
  36.  
  37.             else if (PyString_CheckExact(v) && 
  38.  
  39.                      PyString_CheckExact(w)) {                   // 检查左右操作数是否 string 类型 
  40.  
  41.                 x = string_concatenate(v, w, f, next_instr); 
  42.  
  43.                 /* string_concatenate consumed the ref to v */ 
  44.  
  45.                 goto skip_decref_vx; 
  46.  
  47.             } 
  48.  
  49.             else { 
  50.  
  51.               slow_add:                                          // 两者都不是, 请走这里~ 
  52.  
  53.                 x = PyNumber_Add(v, w); 
  54.  
  55.             } 
  56.  
  57.            ...(省略) 
  58.  
  59.   
  60.  
  61.   
  62.  
  63. # INPLACE_ADD 
  64.  
  65. TARGET_NOARG(INPLACE_ADD) 
  66.  
  67.         { 
  68.  
  69.             w = POP(); 
  70.  
  71.             v = TOP(); 
  72.  
  73.             if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {   // 检查左右操作数是否 int 类型 
  74.  
  75.                 /* INLINE: int + int */ 
  76.  
  77.                 register long a, b, i; 
  78.  
  79.                 a = PyInt_AS_LONG(v); 
  80.  
  81.                 b = PyInt_AS_LONG(w); 
  82.  
  83.                 i = a + b; 
  84.  
  85.                 if ((i^a) < 0 && (i^b) < 0) 
  86.  
  87.                     goto slow_iadd; 
  88.  
  89.                 x = PyInt_FromLong(i); 
  90.  
  91.             } 
  92.  
  93.             else if (PyString_CheckExact(v) && 
  94.  
  95.                      PyString_CheckExact(w)) {                 // 检查左右操作数是否 string 类型 
  96.  
  97.                 x = string_concatenate(v, w, f, next_instr); 
  98.  
  99.                 /* string_concatenate consumed the ref to v */ 
  100.  
  101.                 goto skip_decref_v; 
  102.  
  103.             } 
  104.  
  105.             else { 
  106.  
  107.               slow_iadd:                           
  108.  
  109.                 x = PyNumber_InPlaceAdd(v, w);                 // 两者都不是, 请走这里~ 
  110.  
  111.             } 
  112.  
  113.            ... (省略) 

 

从上面可以看出, 不管是BINARY_ADD 还是INPLACE_ADD, 他们都会有如下相同的操作:

检查是不是都是`int`类型, 如果是, 直接返回两个数值相加的结果

检查是不是都是`string`类型, 如果是, 直接返回字符串拼接的结果

因为两者的行为真的很类似, 所以在这着重讲INPLACE_ADD, 对BINARY_ADD感兴趣的童鞋可以在源码文件: abstract.c, 搜索: PyNumber_Add.实际上也就少了对列表之类对象的操作而已.

那我们接着继续, 先贴个源码:

  1. PyObject * 
  2.  
  3. PyNumber_InPlaceAdd(PyObject *v, PyObject *w) 
  4.  
  5.  
  6.     PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),     
  7.  
  8.                                    NB_SLOT(nb_add)); 
  9.  
  10.     if (result == Py_NotImplemented) { 
  11.  
  12.         PySequenceMethods *m = v->ob_type->tp_as_sequence; 
  13.  
  14.         Py_DECREF(result); 
  15.  
  16.         if (m != NULL) { 
  17.  
  18.             binaryfunc f = NULL
  19.  
  20.             if (HASINPLACE(v)) 
  21.  
  22.                 f = m->sq_inplace_concat; 
  23.  
  24.             if (f == NULL
  25.  
  26.                 f = m->sq_concat; 
  27.  
  28.             if (f != NULL
  29.  
  30.                 return (*f)(v, w); 
  31.  
  32.         } 
  33.  
  34.         result = binop_type_error(v, w, "+="); 
  35.  
  36.     } 
  37.  
  38.     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需找真相:

  1. # 取自: listobject.c 
  2.  
  3. PyTypeObject PyList_Type = { 
  4.  
  5.     ... (省略) 
  6.  
  7.     &list_as_sequence,                          /* tp_as_sequence */ 
  8.  
  9.     ... (省略) 
  10.  

 

可以看出, 其实也就是直接取list_as_sequence, 而这个是什么呢? 其实是一个结构体, 里面存放了列表的部分功能函数.

  1. static PySequenceMethods list_as_sequence = { 
  2.  
  3.     (lenfunc)list_length,                       /* sq_length */ 
  4.  
  5.     (binaryfunc)list_concat,                    /* sq_concat */ 
  6.  
  7.     (ssizeargfunc)list_repeat,                  /* sq_repeat */ 
  8.  
  9.     (ssizeargfunc)list_item,                    /* sq_item */ 
  10.  
  11.     (ssizessizeargfunc)list_slice,              /* sq_slice */ 
  12.  
  13.     (ssizeobjargproc)list_ass_item,             /* sq_ass_item */ 
  14.  
  15.     (ssizessizeobjargproc)list_ass_slice,       /* sq_ass_slice */ 
  16.  
  17.     (objobjproc)list_contains,                  /* sq_contains */ 
  18.  
  19.     (binaryfunc)list_inplace_concat,            /* sq_inplace_concat */ 
  20.  
  21.     (ssizeargfunc)list_inplace_repeat,          /* sq_inplace_repeat */ 
  22.  
  23. }; 

 

接下来就是一个判断, 判断咱们这个l对象是否有Py_TPFLAGS_HAVE_INPLACEOPS这个特性, 很明显是有的, 所以就调用上步取到的结构体中的sq_inplace_concat函数, 那接下来呢? 肯定就是看看这个函数是干嘛的:

  1. list_inplace_concat(PyListObject *self, PyObject *other) 
  2.  
  3.  
  4.     PyObject *result; 
  5.  
  6.   
  7.  
  8.     result = listextend(self, other);    # 关键所在 
  9.  
  10.     if (result == NULL
  11.  
  12.         return result; 
  13.  
  14.     Py_DECREF(result); 
  15.  
  16.     Py_INCREF(self); 
  17.  
  18.     return (PyObject *)self; 
  19.  

 

终于找到关键了, 原来最后就是调用这个listextend函数, 这个和我们python层面的列表的extend方法很类似, 在这不细讲了!

把PyNumber_InPlaceAdd的执行调用过程, 简单整理下来就是:

  1. INPLACE_ADD(字节码) 
  2.  
  3.     -> PyNumber_InPlaceAdd 
  4.  
  5.         -> 判断是否数字: 如果是, 直接返回两数相加 
  6.  
  7.         -> 判断是否字符串: 如果是, 直接返回`string_concatenate`的结果 
  8.  
  9.         -> 都不是: 
  10.  
  11.             -> binary_iop1 (判断是否数字, 如果是则按照数字处理, 否则返回Py_NotImplemented) 
  12.  
  13.                 -> binary_iop (判断是否数字, 如果是则按照数字处理, 否则返回Py_NotImplemented) 
  14.  
  15.             -> 返回的结果是否 Py_NotImplemented: 
  16.  
  17.                 -> 是: 
  18.  
  19.                     -> 对象是否有Py_TPFLAGS_HAVE_INPLACEOPS: 
  20.  
  21.                         -> 是: 调用对象的: sq_inplace_concat 
  22.  
  23.                         -> 否: 调用对象的: sq_concat 
  24.  
  25.                 -> 否: 报错 

 

所以在上面的结果, 第二种代码: l += [3,4,5], 我们看到的id值并没有改变, 就是因为+=通过sq_inplace_concat调用了列表的listextend函数, 然后导致新列表以追加的方式去处理.

结论

现在我们大概明白了+=实际上是干嘛了: 它应该能算是一个加强版的+, 因为它比+多了一个写回本身的功能.不过是否能够写回本身, 还是得看对象自身是否支持, 也就是说是否具备Py_NotImplemented标识, 是否支持sq_inplace_concat, 如果具备, 才能实现, 否则, 也就是和 + 效果一样而已. 

责任编辑:庞桂玉 来源: Python开发者
相关推荐

2017-06-16 20:30:54

Python源码理解

2014-12-25 10:31:33

微信朋友圈挑战

2019-08-28 12:31:31

戴尔

2013-01-16 10:07:30

加密解密破解Android软件

2015-04-01 09:09:12

2021-09-07 06:40:26

状态机识别地址

2011-04-13 12:46:38

IDF2011凌动小尺寸

2024-10-15 09:34:57

2020-09-02 07:03:04

虚拟机HotSpotJava

2020-06-17 15:25:34

Linux 系统 数据

2024-08-30 08:50:00

2022-06-01 12:00:54

HTTP状态码服务端

2017-02-09 15:14:38

物联网工信部网号

2012-06-27 11:13:04

x

2009-12-23 16:15:24

ADO.NET Ent

2018-09-20 16:10:48

CookiesSession前端

2016-06-07 10:28:07

大数据机器学习LSTM

2019-09-03 15:43:21

CIOIT经理信息化建设

2009-03-17 18:09:57

虚拟化Vmwareesx

2021-08-29 22:04:10

Windows 11操作系统微软
点赞
收藏

51CTO技术栈公众号