前菜
在我们使用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_ADD 和 INPLACE_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/1190000009764209
