Python面试必考点：浅拷贝与深拷贝

在搞清楚浅拷贝与深拷贝之前，需要知道以下基础知识，这是极为重要的。

1. 在Python中，一切皆对象。它的这种面向对象相对于其他语言是更彻底的。平时所使用的的int，str，tuple，list，dict, set这些可都是对象！！！所以别再傻傻地以为int()是在调用一个方法，这实际上是在实例化一个对象。当然了还有函数名、模块等，就连True，False全都是对象。所以类似数字1、字符长"hello"这些都是实例化后的实例对象。

2. Python的变量名仅仅是“标签” ，它的作用就是指向实际的内存地址。
   如 s = 'hello' 是先在内存中开辟了一个空间，存放着'hello'，然后s指向了这个内存地址，学过Java的应该知道，这一点与Java很像。

在Python中，内置的标准数据类型又分为可变对象与不可变对象。
其中int，str，tuple是不可变对象：其中的元素是不可被修改的。
好，话不多说，用代码来说明一切：

>>> a = 1
>>> b = 1
>>> a is b  # is 用于判断内存地址是否相等
True

等等！这结果与预料的不对吧？按照上述所说的整数也是个对象，a 和 b 这两个标签应该指向的应该是不同的实例对象啊，怎么内存地址反倒是相等的？？（说明是同一个对象）

那是因为Python有一个intern机制：它会将之前实例化过的小整数对象存放在intern池中，如果后面再需要同样的小整数，Python也就不会再实例化了，而是直接指向原先生成好的数字。
Python这么做也是为了节约内存空间。因为在我们平时写代码的过程中，索引、遍历什么的都要用到小整数，总不能每次都实例出个整数对象吧？
而大整数Python就会生成两个不同的对象了，在此就不再演示。

同理：string也是一样：

>>> a = "hello"
>>> b = "hello"
>>> a is b
True
>>>

Python会将已将实例化过的string缓存起来，值相等的话便不再生成新的对象。
那float和tuple呢??

>>> a = 1.2
>>> b = 1.2
>>> a is b
False
>>> a = (1, 2)
>>> b = (1, 2)
>>> a is b
False

发现这时真正的实例出了对象。这又是为什么？
对于float对象。这种带有小数点的可有太多了，Python可不会帮你缓存
而对于tuple，Python要判断两个tuple相等时是要O(n)的复杂度，与其这样，不如不加缓存。

那对于可变对象set、list、dict呢？

>>> a = []
>>> b = []
>>> a is b
False
>>> a = {}
>>> b = {}
>>> a is b
False
>>>

显而易见，这些不可变对象都是不同的实例对象。

以上都清楚明白之后，再来说浅拷贝与深拷贝：无论是浅拷贝还是深拷贝，对于不可变类型是不会生成实例的！！指向的还是同一个对象，看如下代码：

>>> from copy import copy, deepcopy
>>> a = "test"
>>> b = copy(a)
>>> c = deepcopy(a)
>>> a is b
True
>>> a is c
True
>>> a = (1, 2, 3)
>>> b = copy(a)
>>> c = deepcopy(a)
>>> a is b
True
>>> a is c
True

这里要特别注意元组的拷贝：虽然元组没有intern机制，但对于浅拷贝来讲一样不会产生新实例。
而对于可变对象，无论是浅拷贝还是深拷贝，都会生成不同的实例对象。

>>> a = []
>>> b = copy(a)
>>> c = deepcopy(a)
>>> a is b
False
>>> a is c
False
>>> a = {}
>>> b = copy(a)
>>> c = deepcopy(a)
>>> a is b
False
>>> a is c
False

那既然都一样，浅拷贝和深拷贝还有啥区别？？
它们的区别在于：浅拷贝仅仅拷贝最外的一层，而深拷贝则会递归地拷贝对象。最明显的就是可变对象中嵌套可变对象：如列表嵌套列表。

>>> l1 = [1, 2]
>>> l2 = [3, 4]
>>> a = [l1, l2]
>>> b = copy(a)
>>> c = deepcopy(a)
>>> l1 is b[0]
True
>>> l1 is c[0]
False

所以可以知道：当l1或l2中的元素发生变化时，列表a和b会随之改变，因为它们中存放的元素就是l1和l2。而深拷贝不会随之改变，因为列表c中的元素是一个全新的实例对象，与l1和l2无关。
来接着看代码：

>>> l1[0] = 2   
>>> a           
[[2, 2], [3, 4]]
>>> b           
[[2, 2], [3, 4]]
>>> c           
[[1, 2], [3, 4]]

那对于可变对象中存放着不可变对象呢？浅拷贝也会跟着改变吗？

>>> a = ["hello", (1, 2, 3), 123]
>>> b = copy(a)
>>> a[0] = "haha"
>>> a[1] = (1, 2)
>>> a
['haha', (1, 2), 123]
>>> b
['hello', (1, 2, 3), 123]

修改不可变类型时实际上是生成新对象，与之前的对象毫无关系了，所以是不会随之改变的。
所以得出结论： 只有在可变对象中嵌套可变对象时，浅拷贝与深拷贝才会有区别。
而平时用到的列表切片、自带的copy()方法等也都是浅拷贝。

>>> a = [[1, 2], [3, 4]]
>>> b = a[:]
>>> a[0][0] = 2
>>> a
[[2, 2], [3, 4]]
>>> b
[[2, 2], [3, 4]]

再来看字典的copy()方法：

>>> d = dict(a=[1, 2], b=[3, 4])
>>> e = d.copy()
>>>> d['a'][0] = 2
>>> d
{'a': [2, 2], 'b': [3, 4]}
>>> e
{'a': [2, 2], 'b': [3, 4]}

接下来就看看平时写代码过程中经常会犯的错误：

def f():
    item = {}
    for i in range(10):
        item['a'] = i
        res.append(item)  

if __name__ == '__main__':  
    res = []
    f()
    print(res)

运行结果：

[{'a': 9}, {'a': 9}, {'a': 9}, {'a': 9}, {'a': 9}, {'a': 9}, {'a': 9}, {'a': 9}, {'a': 9}, {'a': 9}]

这样的结果大多数人应该都遇到过：就是列表中的元素都是相同的！！
现在看来就非常好理解，问题是出现在了res.append(item)，因为自始至终程序修改的都是同一个对象，而这个对象又反复地往列表中添加，自然就会得到最后一次修改后的结果。
那该如何解决呢？那就添加一个全新的对象呗，修改为res.append(item.copy())

这样就能如愿地得到了想要的结果：

[{'a': 0}, {'a': 1}, {'a': 2}, {'a': 3}, {'a': 4}, {'a': 5}, {'a': 6}, {'a': 7}, {'a': 8}, {'a': 9}]

本文到此告一段落了，希望看完后的你有所收获。
over！！！