Python a = a + b 与 a+= b 问题

落日映苍穹つ 2024-04-18 23:56 78阅读 0赞

今天又遇到了这个问题，关于变量在函数内外定义以及修改的问题，在这里简要总结一下：

#### 可变与不可变对象 ####

首先这个问题归根结底是Python变量机制中的可变与不可变对象，Python中万物皆对象，简单来说，不可变对象有这几种：

int  float  str  bool  tuple

而可变对象有（一般自定义的类也是可变对象）：

list  set  dict

所谓可变与不可变，也就是创建对象之后，会分配唯一一个id值，如果是可变对象，那么这个对象的数值就是可变化的，如果是不可变对象，那么它的数值就是不可变的，这里要注意判断是否为同一个对象并不能以对象名为依据，例如：

a = 1
    print(a)
    print(id(a))
    a = a+1
    print(a)
    print(id(a))

输出：

1
    140715945029376
    2
    140715945029408

两个对象的变量名称都是 `a` ，但是使用id函数可以看出，这两个对象不指向同一块内存，是不同的对象。对于可变对象，则是：

a = [1,2,3]
    print(a)
    print(id(a))
    
    a[0] = 100
    print(a)
    print(id(a))

输出：

[1, 2, 3]
    2303528409352
    [100, 2, 3]
    2303528409352

可以看到，尽管我们修改了值，但是两个list都指向同一块内存，是一个对象。  
要说不可变对象完全不可变，也太过于绝对，最经典就是定义一个tuple，让它的元素是list，那么实际上tuple的值是可以改变的，本质上是间接改变的list的值，这有点感觉像是“钻空子”，也不是那么重要。

#### 函数调用问题 ####

对于函数调用函数外定义的对象，如果是**不可变对象**：

a = 5
    def fun(a):
        a += 5
        print(a)
        print(id(a))
    print(a)  
    print(id(a))
    fun(a)
    print(a)
    print(id(a))

输出：

5
    140715945029504
    10
    140715945029664
    5
    140715945029504

可以看到，这与C++等的函数一致，也就是不可变对象是传值方式，如果在函数内部对这个对象进行改变，相当于临时创建了一个局部变量（可以看到如果改变值，内存id就会改变），函数结束后不影响原来的对象。  
如果需要在函数内改变全局对象，那么就需要在函数内部将对象声明成全局，使用 `global` 即可：

a = 5
    def fun():
        global a
        print(id(a))
        a += 5
        print(a)
        print(id(a))
    print(a)  
    print(id(a))
    fun()
    print(a)
    print(id(a))

输出：

5
    140715945029504
    140715945029504
    10
    140715945029664
    10
    140715945029664

可以看到，在使用global定义函数内部的 a 是全局之后，在对它进行改变之后，函数外的内存id也改变了。

如果是**可变对象**：

a = [1,2,3]
    def fun(a):
        a[0] = 10
        print(a)
        print(id(a))
        
    print(a)
    print(id(a))
    fun(a)
    print(a)
    print(id(a))

输出：

[1, 2, 3]
    2303528417224
    [10, 2, 3]
    2303528417224
    [10, 2, 3]
    2303528417224

这个好理解，直接传递引用，相当于直接修改全局对象，所以内存id都是一样的。

#### 关于 a += 1 和 a = a + 1 的问题 ####

这是我今天刚遇到的问题，一开始是在写函数的时候遇到的，例如：

a = np.array([1,2])
    def fun(a):
        print(id(a))
        a = a-1
        print(a)
        print(id(a))
    print(a)
    print(id(a))
    fun(a)
    print(a)
    print(id(a))

这段代码输出：

[1 2]
    2303528368688
    2303528368688
    [0 1]
    2303528368528
    [1 2]
    2303528368688

稍微改动一下：

a = np.array([1,2])
    def fun(a):
        print(id(a))
        a -= 1
        print(a)
        print(id(a))
    print(a)
    print(id(a))
    fun(a)
    print(a)
    print(id(a))

输出：

[1 2]
    2303528368528
    2303528368528
    [0 1]
    2303528368528
    [0 1]
    2303528368528

两段代码仅仅改变了 `a -= 1` 与 `a = a - 1`，可以看到，对于前者，所有的对象 `a` 的内存id都是一样的，但是对于后者则是在这条语句之后改变了内存id，也就是对象改变了，如果不在函数中：

a = [1,2,3]
    print(id(a))
    a = a + [4]
    print(a)
    print(id(a))

输出：

2303528464264
    [1, 2, 3, 4]
    2303528481544

第二种方式：

a = [1,2,3]
    print(id(a))
    a += [4]
    print(id(a))

输出：

2303527935432
    2303527935432

可以看到，同样，都是 a += 1这种方式不会改变对象，但是 a = a+1这种方式会改变对象，查了一些资料，总结一下，就是两者看似相同，但是内部实现的方式并不同，首先是 `+=`，这种方式会先调用 `__iadd__`方法，这个方法会在元对象上进行改变，而`= +`则是 使用`__add__`方法，这个方法会返回一个对象，所以对象会改变，

更具体可见：[Python 中 a+=b 和 a=a+b 的区别有哪些？][Python _ a_b _ a_a_b]  
这里要注意，上面的变化只是可变对象才会发生，对于int等不可变对象，这两种写法是一样的， 都会改变对象（因为对于不可变对象，只有`__add__`方法，都会返回一个新对象），例如：

a = 1
    print(id(a))
    a += 1
    print(id(a))

输出：

140715945029376
    140715945029408

a = 1
    print(id(a))
    a = a + 1
    print(id(a))

输出：

print(id(a))
    140715945029376
    140715945029408

可以看到，都改变了对象。

简单来说，  
**对于不可变对象**， `a -= b`与`a = a - b`两种写法一样，都会改变对象。  
**对于可变对象**， `a -= b` 就相当于在原址上改变， `a = a - b`则是先进行 `a - b`运算，然后让 `a`再指向这个新值，所以改变了对象。

附注：我们知道：

a = [1,2,3]
    b = a 
    print(id(a))
    print(id(b))

这时候是传递的引用，也就是 b 也是指向 a 所在的内存块的，所以修改一个就会修改另一个，但是如果我们希望深拷贝，完全复制一个，可以使用这个方法：

import copy
    a = [1,2,3]
    b = copy.deepcopy(a)
    print(id(a))
    print(id(b))