Python list 二三事 python

Python中的 list是一种有序的集合，它对其中的元素的类型没什么要求，几乎万物皆可放list。这里讨论list的四个常用操作：

如何从list中删除元素；
list的索引和切片是深拷贝还是浅拷贝；
两个list的交、并、差、对称差集；
list的排序方法。

1. 删除list中的某个元素
删除list中的某个元素，可以使用del和remove，del是按照下标删除元素，remove是按照值删除元素，只能删除匹配某值的第一个元素。

list1 = ['a','b','hello','world','hello'] # 按照下标删除元素 del list1[2] print(list1) ['a', 'b', 'world', 'hello']list1 = ['a','b','hello','world','hello'] list1.remove('hello') # 按照值删除元素，只能删除匹配某值的第一个元素 print(list1) ['a', 'b', 'world', 'hello']

如果想要删除list中所有的“hello”，不能像下面示意的方法使用for循环，否则如果list中有连续的“hello”会删除不掉。

list1 = ['a','b','hello','world','c','hello','hello','d'] for i in list1: if i == 'hello': list1.remove(i) print(list1)['a', 'b', 'world', 'c', 'hello', 'd']

从结果上看，在for循环时，当remove删除一个匹配的元素后，i已经指向了下一个元素（这和C语言里vector的迭代器一样），所以如果遇到连续两个“hello”，i就跳过了第二个“hello”。验证如下，after remove后i的值发生了变化：

list1 = ['a','b','hello','world','c','hello','hello','d'] for i in list1: print('current item : '+i) if i == 'hello': list1.remove(i) print('after remove : '+i) print(list1)current item : a current item : b current item : hello after remove : hello current item : c current item : hello after remove : hello current item : d ['a', 'b', 'world', 'c', 'hello', 'd']

如果需要删除list中所有匹配的元素，可以做一个list的深拷贝用于遍历，而原list用于删除元素，示例如下：

from copy import deepcopy list1 = ['a','b','hello','world','c','hello','hello','d'] list2 = deepcopy(list1) for i in list2: print('current item : '+i) if i == 'hello': list1.remove(i) print('after remove : '+i) print(list1)current item : a current item : b current item : hello after remove : hello current item : world current item : c current item : hello after remove : hello current item : hello after remove : hello current item : d ['a', 'b', 'world', 'c', 'd']

2. list的切片和索引是深拷贝还是浅拷贝？
上例提到了list的深拷贝，那么list的切片和索引是深拷贝还是浅拷贝？
首先看一下list的索引和切片的基本使用方法：Python中list的索引可以是负数，负数是逆序，逆序从-1开始。

# 下标索引和切片 list1 = ['a','b','c','d'] print(list1[0]) print(list1[1:3]) print(list1[-4:-3])a ['b', 'c'] ['a']

list的索引或者切片是深拷贝还是浅拷贝?这里需要用到一个id方法，它能够给出对象的内存地址。
Python中对list的复制，其实是复制了list的引用，原对象和新对象会指向同一块内存地址。改变其中一个list对象中的元素的值，另一个也会被改变。如下所示，list1和list2实际指向了同一个内存地址，所以一旦改变list2中的元素的值，list1也被改变了。

list1 = ['a','b','c'] list2 = list1 print(id(list1)) print(id(list2)) list2[1] = 'd' print(list1)140356459153200 140356459153200 ['a', 'd', 'c']

想要list1和list2互不相干，一种解决方法是使用切片的方法复制原对象，这样得到的list2的内存地址确实不一样了，改变list2中元素的值，list1不会改变。

# 使用切片的方法复制 list1 = ['a','b','c'] list2 = list1[:] print(id(list1)) print(id(list2)) list2[1] = 'd' print(list1)140356987974432 140356459153040 ['a', 'b', 'c']

可是这样就万事无忧了吗？如果list中的对象是个复杂的结构，比如也是个list，使用切片复制的方式有没有问题呢？

list1 = [['a','b'],['c','d']] list2 = list1[:] print(id(list1)) print(id(list2)) list2[1][1] = 'x' print(list1)140356987975872 140356458496720 [['a', 'b'], ['c', 'x']]

如果遇到嵌套列表（二维数组）, 即使使用切片的方法复制了list2，修改list2中的元素，list1还是会被改掉。因为list中的元素如list1[0]，是个list，是个对象，也是引用，如果查看它俩的内存地址，会发现其实是一样的。

list1 = [['a','b'],['c','d']] list2 = list1[:] print(id(list1[0])) print(id(list2[0]))140356717561408 140356717561408

所以，当list中是对象时，切片后修改元素会改变原来的list中的值，保险的办法是用深拷贝。

from copy import deepcopy list1 = [['a','b'],['c','d']] list2 = deepcopy(list1) print('list 的内存地址：') print(id(list1)) print(id(list2)) print('list[0] 的内存地址：') print(id(list1[0])) print(id(list2[0])) list2[1][1] = 'x' print(list1)list 的内存地址： 140356987985824 140356987984384 list[0] 的内存地址： 140356459155120 140356451242944 [['a', 'b'], ['c', 'd']]

3. list的交、并、差、对称差集
这也是一个较为常见的问题，给出两个list，要求它们的交集、并集、差集、对称差集。这里给出几种方法，并比较性能。两个list如下：

list1 = ['hello','world','day','night','world'] list2 = ['day','hello','spring']

首先是求交集，即找出既在list1中出现，也在list2中出现的元素。这里给出三种写法，前两种借助set来实现（推荐），后一种是list遍历方法。借助set方法的话，如果原list中有多个相同的元素，将不会保留多份，list中元素的顺序也不再保留。

# 交集 list3 = list(set(list1) & set(list2)) print(list3)list4 = list(set(list1).intersection(set(list2))) print(list4)list5 = [x for x in list1 if x in list2] print(list5)['hello', 'day'] ['hello', 'day'] ['hello', 'day']

求list并集，即在list1中或者在list2中出现的元素。

# 并集 list3 = list(set(list1) | set(list2)) print(list3)list4 = list(set(list1).union(set(list2))) print(list4)list5 = list(set(list1 + list2)) print(list5)['night', 'day', 'spring', 'hello', 'world'] ['night', 'day', 'spring', 'hello', 'world'] ['day', 'spring', 'night', 'hello', 'world']

求list的差集，即在list1中出现，但不在list2中的元素

# 差集 list3 = list(set(list1).difference(set(list2))) print(list3)list4 = list(set(list1)-(set(list2))) print(list4)# 不求唯一保持顺序 list5 = [x for x in list1 if x not in list2] print(list5)['night', 'world'] ['night', 'world'] ['world', 'night', 'world']

求list的对称差集，只属于list1的元素和只属于list2的元素

# 对称差集 list3 = list(set(list1).symmetric_difference(set(list2))) print(list3)list4 = list(set(list1)^(set(list2))) print(list4)# 不求唯一保持顺序 list5 = [x for x in list1 if x not in list2] + [x for x in list2 if x not in list1] print(list5)['night', 'world', 'spring'] ['night', 'world', 'spring'] ['world', 'night', 'world', 'spring']

性能方面，因为set内部有哈希表，所以远高于只用list处理，set的两种写法性能差异不大。这里做一个小实验，list1和list2都是有10万数字的list，用不同的方法求解其交集，并用time计时。在这个数量级上，仅用list方法性能较慢，所以如果不要求结果保留所有元素并保持原顺序，借用set是更推荐的方法。

import randomlist1 = [] list2 = [] for i in range(100000): n = random.randint(0, 100000) list1.append(n) m = random.randint(5000, 105000) list2.append(m)%%time # 交集1 list3 = list(set(list1) & set(list2)) CPU times: user 26.4 ms, sys: 1.86 ms, total: 28.2 ms Wall time: 27.6 ms%%time # 交集2 list4 = list(set(list1).intersection(set(list2))) CPU times: user 33.5 ms, sys: 1.17 ms, total: 34.7 ms Wall time: 34 ms%%time # 交集3 list5 = [x for x in list1 if x in list2] CPU times: user 2min 20s, sys: 243 ms, total: 2min 20s Wall time: 2min 20s

4. list的排序操作
list的排序方法可以使用内置的sort和sorted，sorted有返回值，返回排序后的列表；sort是改变list本身的顺序，无返回值。
sorted方法

list1 = [5, 2, 3, 1, 4] list2 = sorted(list1) print(list2)[1, 2, 3, 4, 5]

sort方法

list1 = [5, 2, 3, 1, 4] list1.sort() print(list1)[1, 2, 3, 4, 5]

还可以在排序时通过key参数来指定一个函数用于计算待比较的值，此函数将在每个元素比较前被调用，所以复杂的对象的list，可以通过指定key来排序。比如按某一个分量排序，按某一个分量的长度排序等等。

list1 = [[1,'c','hello'],[2,'a','morning'],[3,'a','cat']] # 按元素中的某一分量排序 list1.sort(key=lambda x:x[1]) print(list1) [[2, 'a', 'morning'], [3, 'a', 'cat'], [1, 'c', 'hello']]# 按元素的某一个分量的函数值排序 list1.sort(key=lambda x:len(x[2])) print(list1) [[3, 'a', 'cat'], [1, 'c', 'hello'], [2, 'a', 'morning']]

注：排序结果是稳定的，关键key相同时，先出现在list中的元素在排序结果中也在前面。
如果list中的元素是某个class的对象，还可以通过itemgetter、attrgetter获取元素或者对象的属性，再排序。示例如下，如果list的元素本身是可以按下标索引的（例如嵌套list），可以使用itemgetter获得分量。

from operator import itemgetter list1 = [[1,'c','hello'],[2,'a','morning'],[3,'b','cat']] # 对可以使用下标索引的如按第1个分量排序 list1.sort(key=itemgetter(1)) print(list1)[[1, 'a', 'morning'], [3, 'b', 'cat'], [1, 'c', 'hello']]

如果list中是复杂的class对象，可以用attrgetter按照属性名字获取属性的值，并按此排序。举例说明，先创建一个Person对象的list：

class Person: def __init__(self, name, age, work): self.name = name self.age = age self.work = work def __repr__(self): return repr((self.name, self.age, self.work))list1 = [Person('赵赵',45,'月亮中学'), Person('李李', 20, '宇宙电子厂'),Person('王王', 35, '宇宙电子厂')]

然后按照Person的age属性排序

from operator import attrgetter # 对对象的某个属性排序 list2 = [Person('赵赵',45,'月亮中学'), Person('李李', 20, '宇宙电子厂'),Person('王王', 35, '宇宙电子厂')] list2.sort(key=attrgetter('age')) print(list2)[('李李', 20, '宇宙电子厂'), ('王王', 35, '宇宙电子厂'), ('赵赵', 45, '月亮中学')]

itemgetter、attrgetter更方便的一点是支持多级排序，即可以传入多个key，先按第一个key排序，第一个key相同的，再按第二个key排序。

# 先按第0个元素排序，再按第1个元素排序 list1 = [[1,'c','hello'],[1, 'a','morning'],[3, 'b','cat']] list1.sort(key=itemgetter(0,1)) print(list1) [[1, 'a', 'morning'], [1, 'c', 'hello'], [3, 'b', 'cat']]# 先按work排序，再按age排序 list2 = [Person('赵赵',45,'月亮中学'), Person('李李', 20, '宇宙电子厂'),Person('王王', 35, '宇宙电子厂')] list2.sort(key=attrgetter('work','age')) print(list2) [('李李', 20, '宇宙电子厂'), ('王王', 35, '宇宙电子厂'), ('赵赵', 45, '月亮中学')]

小结