Python: 变量 += 和变量 = 变量 +

左手的ㄟ右手 2023-07-24 08:18 47阅读 0赞

# \+= 和 = + 的内部实现： #

为了方便起见：a += 1 和 a = a + 1 这两种形式在本文中被缩写为 += 和 =+。

\+= 在内部的方法是： \_\_iadd\_\_  
=+ 在内部的方法是： \_\_add\_\_

如果一个类，没有实现 \_\_iadd\_\_ 方法的话，python 就会退一步调用 \_\_add\_\_ 方法  
总体来说，可变类型都有 \_\_iadd\_\_ 方法，而不可变类型没有 \_\_iadd\_\_ 方法

# 不可变类型： #

a = 1
    print(id(a))
    a += 1
    print(id(a))
    a = a + 1
    print(id(a))
    print('*'*15)
    
    b = 1.5
    print(id(b))
    b += 1.1
    print(id(b))
    b = b + 1.1
    print(id(b))
    print('*'*15)
    
    c = 'abc'
    print(id(c))
    c += 'd'
    print(id(c))
    c = c + 'e'
    print(id(c))
    print('*'*15)
    
    d = (1, 2, 3)
    print(id(d))
    d += (4,)
    print(id(d))
    d = d + (5,)
    print(id(d))
    print('*'*15)
    
    print(dir(a))
    print(dir(b))
    print(dir(c))
    print(dir(d))

结果如下：  
![在这里插入图片描述][20200410091200571.png]  
![在这里插入图片描述][20200410091208171.png]  
![在这里插入图片描述][20200410091215307.png]  
![在这里插入图片描述][20200410091223306.png]  
![在这里插入图片描述][202004100912336.png]  
我们发现除了字符串型 str 有意外之外，别的都符合不可变对象的性质。一个对象如果是不可变对象，那么创建之后就无法修改，我们看着的 += 和 =+ 都是创建了一个新的对象，然后赋值给相应的值，最后变量名重新指向。  
这里的特例就是 str 的 =+ ，我们发现 str 的 =+ 方法是在原有的基础上面修改的，一开始我以为是 str 类实现了 \_\_iadd\_\_ 方法，但是我用 dir() 方法查看 c 包含的属性和方法之后发现并没有实现。具体的原因我还没有找到，如果有大佬知道原因的请指教。

# 可变类型 #

考虑到集合 set 和字典 dict 没有 + 操作，我们在 list 上面测试：

a = [1, 2, 3]
    print(id(a))
    a += [4]
    print(id(a))
    a = a + [5]
    print(id(a))
    print('*'*15)

结果如下：  
![在这里插入图片描述][20200410092230502.png]  
我们发现 list 对象的 += 是在自身操作的，=+ 和可变对象一样，是新建一个对象，然后把 + 之前列表元素和要加的元素依次放进去的。这里还有一个就是时间的效率问题。

import time
    
    
    def test1():
        a_list = []
        start_time = time.time()
        for i in range(100000):
            a_list += [i]
        end_time = time.time()
        print('Time1: ', end_time - start_time)
        return a_list
    
    
    def test2():
        b_list = []
        start_time = time.time()
        for i in range(100000):
            b_list = b_list + [i]
        end_time = time.time()
        print('Time2: ', end_time - start_time)
        return b_list
    
    
    def test3():
        c_list = []
        start_time = time.time()
        for i in range(100000):
            b_list = c_list.extend([i])
        end_time = time.time()
        print('Time3: ', end_time - start_time)
        return c_list
    
    
    test1()
    print('*'*30)
    test2()
    print('*'*30)
    test3()

结果如下：  
![在这里插入图片描述][20200410093231706.png]  
我们额外加了一个 extend() 方法，我们发现 += 和 extend() 方法比 =+ 快很多，因为不用新建对象和删除对象，以及最耗时的将原有列表的值复制过来的过程。最后用 dir() 方法发现 list 对象中有 \_\_iadd\_\_ 方法。顺便提一句 extend 方法中参数代表的列表不会有变化，即 a.extend(b) 操作之后，b 没有任何变化。

# 总结 #

1.  首先排除例外 str 对象的 =+ 方法
2.  不可变对象的 += 和 =+ 和期望的一样，都需要新建对象来操作，除了例外：str 的 =+ 方法是在原来对象上操作的。不可变对象没有实现 \_\_iadd\_\_ 方法。
3.  可变对象的 += 是在原有对象上修改扩展，速度快；而 =+ 则需要新建一个对象，然后复制和添加操作，速度慢；可变对象实现了 \_\_iadd\_\_ 方法

[20200410091200571.png]: /images/20230528/bdc392f4d4594036b2da48a96faa6c40.png
[20200410091208171.png]: /images/20230528/457751b688014dc2b906ee64faccf547.png
[20200410091215307.png]: /images/20230528/1839794e054145a7957b2486b123ae4c.png
[20200410091223306.png]: /images/20230528/ff79b047adf548d4bac3a24d76787039.png
[202004100912336.png]: /images/20230528/6c88c95c242d41efb83f0015107b2d91.png
[20200410092230502.png]: /images/20230528/8f25c13a8d584aa8ad00ffe7db6f6d41.png
[20200410093231706.png]: /images/20230528/9b7661b1e61642f3ad6acbb1166f8bbd.png