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

时间 2019-11-06

原文原文链接

前菜

在咱们使用Python的过程, 不少时候会用到+运算, 例如:python

a = 1 + 2
print a 

# 输出
3

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

a = 'abc' + 'efg'
print a

# 输出
abcefg

一样的, 在列表中也能使用, 例如:函数

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

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

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

正文

先看一个例子:对象

num = 123
num = num + 4
print num

# 输出
127

这段代码的用途很明确, 就是一个简单的数字相加, 可是这样彷佛很繁琐, 一点都Pythonic, 因而就有了下面的代码:ip

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]

看起来结果都同样嘛~, 可是真的同样吗? 咱们改下代码再看下:get

# 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的值表示, 运算先后, 第一种方法对象是不一样的了, 而第二种仍是同一个对象! 为何会这样?源码

结果分析

先来看看字节码:string

[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/11...