Python浅拷贝、深拷贝

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

可变与不可变对象

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

int  float  str  bool  tuple

   
   

   
   
1

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

list  set  dict

   
   

   
   
1

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

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

   
   

   
   
1
2
3
4
5
6

输出：

1
140715945029376
2
140715945029408

   
   

   
   
1
2
3
4

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

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

a[0] = 100
print(a)
print(id(a))

• 1
• 2
• 3
• 4
• 5
• 6
• 7

输出：

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

 
 

 
 
1
2
3
4

可以看到，尽管我们修改了值，但是两个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))

 
 

 
 
1
2
3
4
5
6
7
8
9
10

输出：

5
140715945029504
10
140715945029664
5
140715945029504

 
 

 
 
1
2
3
4
5
6

可以看到，这与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))

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12

输出：

5
140715945029504
140715945029504
10
140715945029664
10
140715945029664

 
 

 
 
1
2
3
4
5
6
7

可以看到，在使用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
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

输出：

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

 
 

 
 
1
2
3
4
5
6

这个好理解，直接传递引用，相当于直接修改全局对象，所以内存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
3
4
5
6
7
8
9
10
11

这段代码输出：

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

 
 

 
 
1
2
3
4
5
6
7

稍微改动一下：

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
3
4
5
6
7
8
9
10
11

输出：

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

 
 

 
 
1
2
3
4
5
6
7

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

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

 
 

 
 
1
2
3
4
5

输出：

2303528464264
[1, 2, 3, 4]
2303528481544

• 1
• 2
• 3
• 4
• 5

第二种方式：

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

 
 

 
 
1
2
3
4

输出：

2303527935432
2303527935432

 
 

 
 
1
2

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

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

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

 
 

 
 
1
2
3
4

输出：

140715945029376
140715945029408

 
 

 
 
1
2

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

 
 

 
 
1
2
3
4

输出：

print(id(a))
140715945029376
140715945029408

 
 

 
 
1
2
3

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

简单来说，
对于不可变对象， 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))

 
 

 
 
1
2
3
4

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

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

 
 

 
 
1
2
3
4
5

输出：

2303527809800
2303528408008

 
 

 
 
1
2

更简单的方式是使用切片：

a = [1,2,3]
b = a[:]

print(id(a))
print(id(b))

• 1
• 2
• 3
• 4
• 5

输出：

2303528464840
2303528482568

 
 

 
 
1
2

这样完成的也是深拷贝。

转载于：http://t.csdn.cn/EEyDi