详解python中的列表切片以及它与浅拷贝的关系(下）

lsekfe

从上文的列表切片中，我们已经能大致看出浅拷贝的全貌了。不管是使用切片的方式获取列表的部分内容还是全部内容，python都帮我们把列表的索引以及每个列表元素的引用都拷贝了一份，相当于生成了一个新列表。下面我们来详细介绍一下浅拷贝与深拷贝。

浅谈列表的深/浅拷贝

浅拷贝与深拷贝是各大语言中的一个比较热门的话题，具体到每种语言，体现出的含义又略有不同。在python中，由于它一切皆对象的特性，使得我们经常在浅拷贝与深拷贝这个问题上弄得晕头转向。

·      浅拷贝

在python中，无论是数值、字符、字符串，还是列表、元组、集合、字典，都看作是一种对象。列表、元组、集合、字典属于复合对象，它们可以包含数值、字符、字符串，也可以互相嵌套。在不考虑复合对象之间互相嵌套的情形下，浅拷贝解决了复合对象拷贝以后与源对象的数据隔离问题。

我们看如下代码：

1. originList = ["钢铁侠", "美国队长", "雷神", "冬兵", "浩克", "星爵", "格鲁特", "蚁人", "猩红女巫", "女武神"]
   
2. heroList02 = ["幻视", "鹰眼", "蜘蛛侠"]
   
3. element = "灭霸"
   
4. herolist01 = originList[:]
   
5. print("heroList01 的内容是：{}".format(herolist01))
   
6. print("heroList01 的地址是：{}".format(hex(id(herolist01))))
   
7. print("heroList01 第一个元素的地址是：{}".format(hex(id(herolist01[0]))))
   
8. print("originList 的内容是：{}".format(originList))
   
9. print("originList 的地址是：{}".format(hex(id(originList))))
   
10. print("originList 第一个元素的地址是：{}".format(hex(id(originList[0]))))
    
11. print("----------------接下来我们修改heroList第一个元素-----------------")
    
12. print("element 的内容是{}，地址是{}".format(element, hex(id(element))))
    
13. herolist01[0] = element
    
14. print("heroList01 的内容是：{}".format(herolist01))
    
15. print("heroList01 的地址是：{}".format(hex(id(herolist01))))
    
16. print("heroList01 第一个元素的地址是：{}".format(hex(id(herolist01[0]))))
    
17. print("originList 的内容是：{}".format(originList))
    
18. print("originList 的地址是：{}".format(hex(id(originList))))
    
19. print("originList 第一个元素的地址是：{}".format(hex(id(originList[0]))))
    

复制代码

在pycharm中运行上述代码，得到如下输出：

1. heroList01 的内容是：['钢铁侠', '美国队长', '雷神', '冬兵', '浩克', '星爵', '格鲁特', '蚁人', '猩红女巫', '女武神']
   
2. heroList01 的地址是：0x15011868688
   
3. heroList01 第一个元素的地址是：0x150105c5390
   
4. originList 的内容是：['钢铁侠', '美国队长', '雷神', '冬兵', '浩克', '星爵', '格鲁特', '蚁人', '猩红女巫', '女武神']
   
5. originList 的地址是：0x15010485188
   
6. originList 第一个元素的地址是：0x150105c5390
   
7. ----------------接下来我们修改heroList第一个元素-----------------
   
8. element 的内容是灭霸，地址是0x150118e9090
   
9. heroList01 的内容是：['灭霸', '美国队长', '雷神', '冬兵', '浩克', '星爵', '格鲁特', '蚁人', '猩红女巫', '女武神']
   
10. heroList01 的地址是：0x15011868688
    
11. heroList01 第一个元素的地址是：0x150118e9090
    
12. originList 的内容是：['钢铁侠', '美国队长', '雷神', '冬兵', '浩克', '星爵', '格鲁特', '蚁人', '猩红女巫', '女武神']
    
13. originList 的地址是：0x15010485188
    
14. originList 第一个元素的地址是：0x150105c5390
    

复制代码

可以看到，使用浅拷贝以后，heroList01与originList之间实现了数据隔离，对heroList01中的元素进行修改不影响originList。浅拷贝的数据隔离非常类似于linux内核中的写时复制机制，即浅拷贝发生以后，拷贝的列表与原始列表仍然共享一份数据副本，后续对拷贝的列表或者原始列表进行写入操作时，才会重新申请空间写入新数据。

列表切片属于浅拷贝的一种，对于列表来说，浅拷贝还有其它3种实现方式，分别是工厂方法list()、列表中自带的copy()方法，以及copy库中的copy方法，感兴趣的同学可以去尝试一下，这里不再一一赘述。

·      深拷贝

浅拷贝只解决了复合对象中包含简单对象的数据隔离，当待拷贝的对象中嵌套了其他复合对象的时候，浅拷贝就出问题了。我们看如下代码：

1. list01 = [1, 2, 3, [4, 5]]
   
2. list02 = list01[::]
   
3. print(hex(id(list01[0])))
   
4. print(hex(id(list02[0])))
   
5. list02[0] = 10
   
6. list02[3][0] = 8
   
7. print(hex(id(list01[0])))
   
8. print(hex(id(list02[0])))
   
9. print(list01)
   
10. print(list02)
    

复制代码

代码输出如下：

1. 0x7ffeea02a190
   
2. 0x7ffeea02a190
   
3. 0x7ffeea02a190
   
4. 0x7ffeea02a2b0
   
5. [1, 2, 3, [8, 5]]
   
6. [10, 2, 3, [8, 5]]
   

复制代码

可以看到，对于外层元素，两个列表之间实现了数据隔离，而对于嵌套的复合对象，两个列表之间仍然是共享的。我们将上述代码转化成内存示意图，就能更直观地看出在拷贝以及修改过程中究竟发生了什么

可以看到，浅拷贝在拷贝复杂对象时仍然采取了共享策略，于是，对嵌套列表的修改导致list01、list02的数据都发生了变化。当我们要对列表中嵌套的列表保持数据隔离时，深拷贝就派上用场了。在python中，实现深拷贝的方法是调用copy中的deepcopy方法，请看如下代码：

1. import copy
   
2. 
   
3. list01 = [1, 2, 3, [4, 5]]
   
4. print("----------------使用深拷贝的方法复制一个list02----------------")
   
5. list02 = copy.deepcopy(list01)
   
6. print("list01 第一个元素的地址是：{}".format(hex(id(list01[0]))))
   
7. print("list01 中嵌套的列表地址是：{}".format(hex(id(list01[3]))))
   
8. print("list01 中嵌套的列表的第一个元素地址是：{}".format(hex(id(list01[3][0]))))
   
9. print("list02 第一个元素的地址是：{}".format(hex(id(list02[0]))))
   
10. print("list02 中嵌套的列表地址是：{}".format(hex(id(list02[3]))))
    
11. print("list02 中嵌套的列表的第一个元素地址是：{}".format(hex(id(list02[3][0]))))
    
12. print("-----------------下面对list02中的元素进行修改-----------------")
    
13. list02[0] = 10
    
14. list02[3][0] = 8
    
15. print("list01 第一个元素的地址是：{}".format(hex(id(list01[0]))))
    
16. print("list01 中嵌套的列表地址是：{}".format(hex(id(list01[3]))))
    
17. print("list01 中嵌套的列表的第一个元素地址是：{}".format(hex(id(list01[3][0]))))
    
18. print("list02 第一个元素的地址是：{}".format(hex(id(list02[0]))))
    
19. print("list02 中嵌套的列表地址是：{}".format(hex(id(list02[3]))))
    
20. print("list02 中嵌套的列表的第一个元素地址是：{}".format(hex(id(list02[3][0]))))
    
21. print("list01的内容是：{}".format(list01))
    
22. print("list02的内容是：{}".format(list02))
    

复制代码

上述代码的输出如下:

1. ----------------使用深拷贝的方法复制一个list02----------------
   
2. list01 第一个元素的地址是：0x7ffee9d9a190
   
3. list01 中嵌套的列表地址是：0x148f6d95188
   
4. list01 中嵌套的列表的第一个元素地址是：0x7ffee9d9a1f0
   
5. list02 第一个元素的地址是：0x7ffee9d9a190
   
6. list02 中嵌套的列表地址是：0x148f6ecbf08
   
7. list02 中嵌套的列表的第一个元素地址是：0x7ffee9d9a1f0
   
8. -----------------下面对list02中的元素进行修改-----------------
   
9. list01 第一个元素的地址是：0x7ffee9d9a190
   
10. list01 中嵌套的列表地址是：0x148f6d95188
    
11. list01 中嵌套的列表的第一个元素地址是：0x7ffee9d9a1f0
    
12. list02 第一个元素的地址是：0x7ffee9d9a2b0
    
13. list02 中嵌套的列表地址是：0x148f6ecbf08
    
14. list02 中嵌套的列表的第一个元素地址是：0x7ffee9d9a270
    
15. list01的内容是：[1, 2, 3, [4, 5]]
    
16. list02的内容是：[10, 2, 3, [8, 5]]
    

复制代码

在上述代码的输出中，我们至少可以看出两点：1、对于列表中包含的数值类型，在深拷贝时依然采取了写时复制的策略，也就是说只有当这些元素被修改时才会重新申请空间写入新数据；2、对于列表中包含的列表，在深拷贝时会逐层拷贝，但嵌套列表中包含的数值类型仍然采取共享策略。我们用内存图来表达上述深拷贝过程，会更直观更清晰。

列表与函数参数传递

在开发过程中经常遇到的一个问题是：列表在函数参数传递时使用的是浅拷贝还是深拷贝？如果你的回答是浅拷贝，那么恭喜你，答错了！列表在函数参数传递过程中使用的既不是浅拷贝也不是深拷贝，而是简单的引用传递。请看下面的程序：

1. list01 = ["幻视", "鹰眼", "蜘蛛侠"]
   
2. 
   
3. def listPrint(strList):
   
4.     print(hex(id(strList)))
   
5.     for item in strList:
   
6.         print(item, end='\t')
   
7.     print()
   
8.     strList[0] = "灭霸"
   
9.     print("--------------在listPrint函数里面----------------")
   
10.     print(strList)
    
11. 
    
12. print(hex(id(list01)))
    
13. listPrint(list01)
    
14. print("--------------调用完listPrint以后----------------")
    
15. print(list01)
    

复制代码

程序的输出如下：

1. 0x234a59b5188
   
2. 0x234a59b5188
   
3. 幻视        鹰眼        蜘蛛侠       
   
4. --------------在listPrint函数里面----------------
   
5. ['灭霸', '鹰眼', '蜘蛛侠']
   
6. --------------调用完listPrint以后----------------
   
7. ['灭霸', '鹰眼', '蜘蛛侠']
   

复制代码

在进行listPrint函数调用时，解释器仅仅是简单地将list01的引用放在了函数listPrint的栈帧上，在函数listPrint中对列表的修改都将影响到list01。

我们在调用listPrint函数时对list01做一次简单的浅拷贝，观察程序输出：

1. list01 = ["幻视", "鹰眼", "蜘蛛侠"]
   
2. 
   
3. def listPrint(strList):
   
4.     print(hex(id(strList)))
   
5.     for item in strList:
   
6.         print(item, end='\t')
   
7.     print()
   
8.     strList[0] = "灭霸"
   
9.     print("--------------在listPrint函数里面----------------")
   
10.     print(strList)
    
11. 
    
12. print(hex(id(list01)))
    
13. listPrint(list01.copy())
    
14. print("--------------调用完listPrint以后----------------")
    
15. print(list01)
    

复制代码

上述代码的输出如下：

1. 0x250328b5188
   
2. 0x250328b5388
   
3. 幻视        鹰眼        蜘蛛侠       
   
4. --------------在listPrint函数里面----------------
   
5. ['灭霸', '鹰眼', '蜘蛛侠']
   
6. --------------调用完listPrint以后----------------
   
7. ['幻视', '鹰眼', '蜘蛛侠']
   

复制代码

我们发现，此时listPrint对实参的修改已经不能影响到list01了，因为函数listPrint接收到的参数是list01的一份浅拷贝，而不是list01本身，从而实现了一次简单的数据隔离。

深/浅拷贝的拓展

上文介绍了列表的深/浅拷贝，在python中，深/浅拷贝主要发生在可变对象互相嵌套的场景中，包括python内置的可变对象列表、集合、字典，以及元组中嵌套的列表、集合、字典。除此之外，用户自定义的对象，只要对象属性中包含了可变对象，在对对象进行拷贝的时候就需要考虑使用浅拷贝还是深拷贝，从而实现拷贝对象与源对象的数据隔离。