Python数据类型之列表和元组的方法实例详解

引言

我们前面的文章介绍了数字和字符串，比如我计算今天一天的开销花了多少钱我可以用数字来表示，如果是整形用 int ,如果是小数用 float ,如果你想记录某件东西花了多少钱，应该使用 str 字符串型,如果你想记录表示所有开销的物品名称，你应该用什么表示呢？

可能有人会想到我可以用一个较长的字符串表示，把所有开销物品名称写进去，但是问题来了，如果你发现你记录错误了，想删除掉某件物品的名称，那你是不是要在这个长字符串中去查找到，然后删除，这样虽然可行，那是不是比较麻烦呢。

这种情况下，你是不是需要Python给我们提供一种新的数据结构，可以存储很多个字符串，能让我们方便的添加修改和删除，就完美了。

列表(list)同字符串一样都是有序的，因为他们都可以通过切片和索引进行数据访问，列表是可变(mutable)的，你可以修改、更新和删除。

列表是一组有序项目的集合 ,可变的数据类型可 进行增删改查 ; 列表中可以包含Python中任何数据类型和对象，也可包含另一个列表 可任意组合嵌套 列表是以方括号 [] 包围的数据集合,不同成员以 , 分隔,列表可通过序号访问其中成员。

列表可以装入Python中所有的对象，看下面的例子就知道:

1. all_list = [
2. 'nock', # 字符串
3. 1, # 整数
4. 2.0, # 浮点数
5. print('hello'), # 函数
6. True, # 布尔值
7. None, # 空值
8. [1, 2], # 列表
9. (3,4), # 元组
10. {'name': 'nock', 'age': 18} # 字典
11. ]

列表的定义和创建

定义： [] 内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

列表的创建:

第一种:

fruit = ['pineapple', 'pear']

第二种:

fruit = list(['pineapple', 'pear'])

其他数据类型转为列表:

1、把一个字符串转化成列表

1. >>> alphabet = 'abcd'
2. >>> alphabet_list = list(alphabet)
3. >>> alphabet_list
4. ['a', 'b', 'c', 'd']

list在把字符串转换成列表的时候，会把字符串用for循环迭代一下，然后把每个值当作list的一个元素。

2、把元组转换成列表

1. >>> jobs = ('pm', 'dev', 'qa', 'ops')
2. >>> jobs_list = list(jobs)
3. >>> type(jobs_list)
4. <type 'list'>
5. >>> jobs_list
6. ['pm', 'dev', 'qa', 'ops']

3、把字典转成列表

1. >>> age = {'tom': 15, 'jim': 18, 'jerry': 20}
2. >>> age_list = list(age)
3. >>> type(age_list)
4. <type 'list'>
5. >>> age_list
6. ['jim', 'jerry', 'tom']
7. >>> values_list = list(age.values())
8. >>> values_list
9. [18, 20, 15]

list在把字典转换成列表的时候,默认循环的是字典的key，所以会把key当作列表的元素;如果指定循环的是values，那么就会把values当作列表的元素。

列表的特点和常用方法

特征：

1. 多值: 可存放多个值
2. 有序: 按照从左到右的顺序定义列表元素，下标从0开始顺序访问

3.可变: 可修改指定索引位置对应的值

列表的增删改查:

增加操作:

1. # 增 插入 可插入到任何位置
2. >>> fruit = ['pineapple', 'pear']
3. >>> fruit.insert(1, 'grape')
4. >>> fruit
5. ['pineapple', 'grape', 'pear']

在使用 insert 方法的时候，必须要指定列表中要插入的新元素的位置，插入元素的实际位置是在 指定位置元素的前面的

位置 ，如果指定插入的位置在列表中不存在，实际上也就是超出指定列表的长度，程序运行不会报错，但是这个元素一定会被放到这个列表的最后位置。

1. >>> fruit = ['pineapple', 'pear']
2. >>> fruit.insert(4, 'grape')
3. >>> fruit
4. ['pineapple', 'pear', 'grape']
5. # 增 append方法 数据会追加到尾部
6. >>> fruit = ['pineapple', 'pear']
7. >>> fruit.append('grape')
8. >>> fruit
9. ['pineapple', 'pear', 'grape']

1. # 合并 extend 把一个列表的值合并到当前一个列表中
2. >>> fruit_one = ['banana', 'apple', 'orange']
3. >>> fruit_two = ['pineapple', 'grape', 'pear']
4. >>> fruit_one.extend(fruit_two)
5. >>> fruit_one
6. ['banana', 'apple', 'orange', 'pineapple', 'grape', 'pear']

删除操作:

1. # del 直接删除
2. >>> jobs = ['PM', 'UI', 'QA', 'OPS']
3. >>> del jobs[0]
4. >>> jobs
5. ['UI', 'QA', 'OPS']
6.  
7. # remove 根据remove方法，
8. >>> jobs = ['PM', 'UI', 'QA', 'OPS']
9. >>> jobs.remove('PM')
10. >>> jobs
11. ['UI', 'QA', 'OPS']
12.  
13. # pop 默认删除列表最后一个元素
14. >>> jobs = ['PM', 'UI', 'QA', 'OPS']
15. >>> jobs.pop() # pop方法，默认删除最后一个，返回删除元素
16. 'OPS'
17. >>> jobs
18. ['PM', 'UI', 'QA']
19. >>> help(jobs.pop)
20. Help on built-in function pop:
21.  
22. pop(...) method of builtins.list instance
23. L.pop([index]) -> item -- remove and return item at index (default last).
24. Raises IndexError if list is empty or index is out of range.
25. >>> jobs.pop(1) # pop还可以指定元素下标，指定删除
26. 'UI'
27. >>> jobs
28. ['PM', 'QA']
29.  
30. # clear 方法清空一个列表
31. >>> jobs = ['PM', 'UI', 'QA', 'OPS']
32. >>> jobs.clear()
33. >>> jobs
34. []

remove方法删除一个元素，必须是在列表中的，否则会报错，del利用下标来删除元素，pop默认删除最后一个元素，也可以指定元素下标来删除。

修改操作:

1. >>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
2. >>> jobs[2] = 'QA' # 把下标为2的元素替换成QA，根据下标然后给元素重新赋值
3. >>> jobs
4. ['PM', 'UI', 'QA', 'OPS', 'DBA', 'DEV']
5. >>> jobs[-2] = 'Sales' # 把下标为12的元素替换成Sales，根据下标然后给元素重新赋值
6. >>> jobs
7. ['PM', 'UI', 'QA', 'OPS', 'Sales', 'DEV']

查询操作:

1. >>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
2. >>> jobs[1]
3. 'UI'
4. >>> jobs[2]
5. 'UE'
6. >>> jobs[4]
7. 'DBA'
8. >>> jobs[-2] # 还可以倒数着来，不过下标从-1开始
9. 'DBA'

列表索引:

1. >>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 'UE']
2. >>> jobs.index('OPS')
3. 2
4. >>> jobs.index('UE')
5. 3
6. >>> jobs.index('xx')
7. Traceback (most recent call last):
8. File "<stdin>", line 1, in <module>
9. ValueError: 'xx' is not in list
10. >>> if 'OPS' in jobs:
11. ... print(jobs.index('OPS'))
12. ...
13. 2

索引下标，只会返回第一个元素的下标,如果元素不在列表中，会报错，我们可以利用 in 这个关键之来判断元素是否在列表中。

列表切片:

1. >>> jobs = ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
2. >>> jobs[1:4] # 取下标从1到4的元素，但是不包括4，列表切片的特征就是左开右闭，也就是左取右弃。
3. ['UI', 'UE', 'OPS']
4. >>> jobs[1:-1] # 取下标为1到-1的元素，不包括-1，也就是最后一个元素不会被取出来。
5. ['UI', 'UE', 'OPS', 'DBA']
6. >>> jobs[:] # 这个在切片符左右没有下标限制，所以就是代表全取
7. ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
8. >>> jobs[::] # 效果和上面一样，但是你会发现有两切片符，这是因为切片有一个步长的概念
9. ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
10. >>> jobs[0:3] # 取下标0到3的元素，但不包括3
11. ['PM', 'UI', 'UE']
12. >>> jobs[:3] # 和上面效果一样
13. ['PM', 'UI', 'UE']
14. >>> jobs[3:] # 从下标3开始，到最后一个元素
15. ['OPS', 'DBA', 'DEV']
16. >>> jobs[3:-1] # 从下标3开始，到最后一个元素，但是不包括最后一个元素
17. ['OPS', 'DBA']
18. >>> jobs[0::2] # 从下标0开始，按照2个步长取值
19. ['PM', 'UE', 'DBA']
20. >>> jobs[::2] # 和上面效果一样
21. ['PM', 'UE', 'DBA']

利用下标取出的一个单独元素是str类型，而利用分片取出的是一个list类型。

列表元素统计:

1. >>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV']
2. >>> jobs.count('OPS') # 因为列表是有序的一种数据类型，所以它的元素是可以重叠的，所以有元素统计。
3. 2

列表排序和翻转:

1. >>> jobs = ['PM', 'UI', 'OPS', 'UE', 'OPS', 'DBA', 'DEV', 1, 2, 3]
2. >>> jobs.sort()
3. Traceback (most recent call last):
4. File "<stdin>", line 1, in <module>
5. TypeError: unorderable types: int() < str() # Python3.0里不同数据类型不能放在一起排序了，擦
6. >>> jobs[-1] = '3'
7. >>> jobs[-2] = '2'
8. >>> jobs[-3] = '1'
9. >>> jobs
10. ['DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI', '1', '2', '3']
11. >>> jobs.sort()
12. >>> jobs
13. ['1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']
14. >>> jobs.append('#')
15. >>> jobs.append('&')
16. >>> jobs.sort()
17. >>> jobs
18. ['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI'] # 可以看出排序的顺序 特殊字符->数字->字母 这么一个优先级
19. >>> jobs.reverse() # 翻转最后到最前面
20. >>> jobs
21. ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']

sort() 方法会修改原列表，而不是创建一个新的有序列表， reverse() 也会修改原列表，但是你希望排序，但是又不希望修改原列表，你只能利用Python中一个名为 sorted() 的内置函数来操作：

1. >>> jobs = ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
2. >>> newlist = sorted(jobs)
3. >>> jobs
4. ['UI', 'UE', 'PM', 'OPS', 'OPS', 'DEV', 'DBA', '3', '2', '1', '&', '#']
5. >>> newlist
6. ['#', '&', '1', '2', '3', 'DBA', 'DEV', 'OPS', 'OPS', 'PM', 'UE', 'UI']

列表拷贝:

1. >>> jobs
2. ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
3. >>> jobs_copy = jobs.copy() # 复制一份jobs列表
4. >>> jobs_copy
5. ['PM', 'UI', 'UE', 'OPS', 'DBA', 'DEV']
6. >>> jobs = ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 嵌入式列表
7. >>> jobs_copy2 = jobs.copy()
8. >>> jobs_copy2
9. ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']]
10. >>> jobs[0] = 'HR' # 改变小标为0的元素
11. >>> jobs
12. ['HR', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 改变了
13. >>> jobs_copy2
14. ['PM', 'UI', 'UE', 'OPS', ['DBA', 'QA', 'DEV']] # 没变
15. >>> jobs[-1][0] = 'Sales' # 改变内嵌列表的下标为0的元素
16. >>> jobs
17. ['HR', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改变了
18. >>> jobs_copy2
19. ['PM', 'UI', 'UE', 'OPS', ['Sales', 'QA', 'DEV']] # 改变了

从上面可以看出列表的copy方法是一个浅copy的栗子，只会拷贝第一次，而多层嵌入的话，会随着源列表的变化为变化，关于深拷贝和浅拷贝后面详细介绍。

列表所有的方法如下：

1. class list(object):
2. """
3. list() -> new empty list
4. list(iterable) -> new list initialized from iterable's items
5. """
6. def append(self, p_object): # real signature unknown; restored from __doc__
7. """ L.append(object) -> None -- append object to end """
8. pass
9.  
10. def clear(self): # real signature unknown; restored from __doc__
11. """ L.clear() -> None -- remove all items from L """
12. pass
13.  
14. def copy(self): # real signature unknown; restored from __doc__
15. """ L.copy() -> list -- a shallow copy of L """
16. return []
17.  
18. def count(self, value): # real signature unknown; restored from __doc__
19. """ L.count(value) -> integer -- return number of occurrences of value """
20. return 0
21.  
22. def extend(self, iterable): # real signature unknown; restored from __doc__
23. """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
24. pass
25.  
26. def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
27. """
28. L.index(value, [start, [stop]]) -> integer -- return first index of value.
29. Raises ValueError if the value is not present.
30. """
31. return 0
32.  
33. def insert(self, index, p_object): # real signature unknown; restored from __doc__
34. """ L.insert(index, object) -- insert object before index """
35. pass
36.  
37. def pop(self, index=None): # real signature unknown; restored from __doc__
38. """
39. L.pop([index]) -> item -- remove and return item at index (default last).
40. Raises IndexError if list is empty or index is out of range.
41. """
42. pass
43.  
44. def remove(self, value): # real signature unknown; restored from __doc__
45. """
46. L.remove(value) -> None -- remove first occurrence of value.
47. Raises ValueError if the value is not present.
48. """
49. pass
50.  
51. def reverse(self): # real signature unknown; restored from __doc__
52. """ L.reverse() -- reverse *IN PLACE* """
53. pass
54.  
55. def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
56. """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
57. pass

列表推导式:

列表推导式（又称列表解析式）提供了一种简明扼要的方法来创建列表，它的语法简单，很有实用价值。

它的结构是在一个中括号里包含一个表达式，然后是一个for语句，然后是0个或多个for或者if语句。那个表达式可以是任意的，意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表，在这个以if和for语句为上下文的表达式运行完成之后产生。

列表解析的一般形式：

1. [expr for item in itratorable]
2. L = [x**2 for x in range(10)]
3. print(L)
4. Result:
5. [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

列表解析返回的是列表， 列表的内容是表达式执行的结果.

1. [expr for item in iterable if cond]
2. [x ** 0.5 for x in range(10) if x % 2 == 0]
3. [0.0, 1.4142135623730951, 2.0, 2.449489742783178, 2.8284271247461903]
4. [expr for item in iterable if cond1 if cond2]
5. [x for x in range(10) if x % 2 == 0 if x > 1]
6. [2, 4, 6, 8]
7. [expr for item1 in iterable1 for item2 in iterable2]
8. [(x, y) for x in range(10) for y in range(10) if (x+y) %2 == 0]

列表解析用于对可迭代对象做过滤和转换，返回值是列表.

特性一:代码变短，可读性更好

从上图代码示例中我们明显可以看出，列表推导式相比常规方法，写出来的代码更加符合pythonic,更加简短，可读性更好。

有些人甚至更喜欢使用它而不是filter函数生成列表，但是当你使用列表推导式效果会更加，列表推导式在有些情况下超赞，特别是当你需要使用for循环来生成一个新列表.

特征二:推导式速度更快

1. #!/usr/bin/env python3
2. # author: nock
3. import timeit
4.  
5. lst = list(range(10))
6. # 常规方法
7. def origin(lst):
8. plus_one = []
9. for i in lst:
10. plus_one.append(i + 1)
11. return plus_one
12.  
13. # 列表推导式
14. def fast(lst):
15. return [ x + 1 for x in lst ]
16.  
17. otime = timeit.timeit('origin(range(10))', globals=globals())
18. print("func origin exec time is {0}".format(otime))
19.  
20. ftime = timeit.timeit('fast(range(10))', globals=globals())
21. print("func origin exec time is {0}".format(ftime))

结果：

1. func origin exec time is 2.1059355960023822
2. func origin exec time is 1.6507169340038672

如果你使用map或者filter结合lambda生成列表，也是没有列表推导式速度快的，有兴趣的可以自己Coding一下。

列表的遍历

在Python中常用循环对象来遍历列表，在这里for循环自动调用 next() 方法，将该方法的返回值赋予给循环对象。循环检测到StopIteration的时候才结束。相对于序列，用循环对象的好处在于：不用在循环还没有开始的时候，就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样，节省了空间，提高了效率，编程更灵活。

1. for循环遍历

1. #!/usr/bin/env python3
2.  
3. map_list = ['China', 'America', 'Japan', 'Korea']
4.  
5. for countries in map_list:
6. print(countries) # 自动调用迭代器，自动检测StopIteration
7.  
8. # 在上面的程序中，无法知道当前访问元素的索引，于是有如下代码：
9. for index in range(len(map_list)):
10. print("key is %s index is %s" % (map_list[index], index))

2. while循环遍历

1. #!/usr/bin/env python3
2.  
3. map_list = ['China', 'America', 'Japan', 'Korea']
4.  
5. index = 0
6. while index < len(map_list):
7. print(index, map_list[index])
8. index+=1

3. 拉链(zip)方法遍历

1. #!/usr/bin/env python3
2. map_list = ['China', 'America', 'Japan', 'Korea']
3. for index, value in zip(range(len(map_list)), map_list):
4. print(index, value)

4. 利用Python内置函数 enumerate() 列举

enumerate(iterable [, start ]) 返回枚举对象, 参数：

1. iterable: 一个序列、迭代器或其他支持迭代的对象
2. start: 下标起始位置
3. #!/usr/bin/env python3
4. map_list = ['China', 'America', 'Japan', 'Korea']
5. for value in enumerate(map_list):
6. print(value)

5. 使用 iter() 迭代器

iter(collection [, sentinel ]) 函数用来生成迭代器，返回迭代对象， 参数:

collection: 支持迭代的集合对象

sentinel: 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时， iter 创建了一个迭代器对象，每次调用这个迭代器对象的 __next__() 方法时，都会调用object。

1. #!/usr/bin/env python3
2. map_list = ['China', 'America', 'Japan', 'Korea']
3. for value in iter(map_list):
4. print(value)

由于列表在Python内部的组成方式不同于C语言等，其索引的效率相对较为低下。因此在使用python的过程中，如果需要同时用到序号和元素，最好使用enumerate()；当我们不需要使用序号时，在列表上直接进行迭代效率最高。

元组

元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表。

语法: names = ('tom', 'jack', 'andy')

它只有2个方法，一个是count,一个是index:

1. class tuple(object):
2. """
3. tuple() -> empty tuple
4. tuple(iterable) -> tuple initialized from iterable's items
5.  
6. If the argument is a tuple, the return value is the same object.
7. """
8. def count(self, value): # real signature unknown; restored from __doc__
9. """ T.count(value) -> integer -- return number of occurrences of value """
10. return 0
11.  
12. def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
13. """
14. T.index(value, [start, [stop]]) -> integer -- return first index of value.
15. Raises ValueError if the value is not present.
16. """
17. return 0

列表几种高阶常用场景

1. 解压列表赋值给多个变量

现在有一个包含 N个元素 的元组或者列表，怎样将它里面的值解压后同时赋值给 N 个变量？

任何的序列（或者是可迭代对象）可以通过一个简单的赋值语句解压并赋值给多个变量。 唯一的前提就是变量的数量必须跟序列元素的 数量一致 的。

代码示例:

1. >>> jobs = ('hr', 'dev', 'ops')
2. >>> x, y, z = jobs
3. >>> print(x, y, z)
4. hr dev ops
5.  
6. >>> data = ['nock', 8, 24, (2001, 12, 28)]
7. >>> name, shares, size, date = data
8. >>> print(name, shares, size, date)
9. nock 8 24 (2001, 12, 28)
10. >>> date
11. (2001, 12, 28)
12. >>> name, shares, size, (year, mon, day) = data
13. >>> name
14. 'nock'
15. >>> print(year, mon, day)
16. 2001 12 28

如果变量个数和列表元素的个数不匹配，会产生异常的哦。

代码示例：

1. >>> jobs = ('hr', 'dev', 'ops')
2. >>> x, y = jobs
3. Traceback (most recent call last):
4. File "<stdin>", line 1, in <module>
5. ValueError: too many values to unpack (expected 2)
6. >>> x, y, z, x = jobs
7. Traceback (most recent call last):
8. File "<stdin>", line 1, in <module>
9. ValueError: not enough values to unpack (expected 4, got 3)

实际上，这种解压赋值可以用在任何可迭代对象上面，而不仅仅是列表或者元组。 包括字符串，文件对象，迭代器和生成器。

代码示例:

1. >>> name = 'Jim'
2. >>> a, b, c = name
3. >>> a
4. 'J'
5. >>> b
6. 'i'

有时候，你可能只想解压一部分，丢弃其他的值。对于这种情况 Python 并没有提供特殊的语法。 但是你可以使用任意变量名去占位，到时候丢掉这些变量就行了。

1. >>> jobs = [18, 30000, 'duck', 100, (2000, 2, 18)]
2. >>> age, wage, _, num, _ = jobs
3. >>> age
4. 18
5. >>> wage
6. 30000
7. >>> _
8. (2000, 2, 18)

你必须保证你选用的那些占位变量名在其他地方没被使用到。

2. 删除列表中相同元素并保持顺序

怎样让一个列表保持元素顺序的同时消除重复的值，如果列表上的值都是 hashable 类型，那么可以很简单的利用集合或者生成器来解决这个问题,比如：

1. def dedupe(items):
2. seen = set()
3. for item in items:
4. if item not in seen:
5. yield item
6. seen.add(item)

下面是使用上述函数的例子：

1. >>> def dedupe(items):
2. ... seen = set()
3. ... for item in items:
4. ... if item not in seen:
5. ... yield item
6. ... seen.add(item)
7. ...
8. >>> nums = [1, 5, 2, 1, 9, 1, 5, 10]
9. >>> list(dedupe(nums))
10. [1, 5, 2, 9, 10]

这个方法仅仅在序列中元素为 hashable 的时候才管用。 如果你想消除元素不可哈希（比如 dict 类型）的序列中重复元素的话，你需要将上述代码稍微改变一下，就像这样：

1. def dedupe(items, key=None):
2. seen = set()
3. for item in items:
4. val = item if key is None else key(item)
5. if val not in seen:
6. yield item
7. seen.add(val)

这里的key参数指定了一个函数，将序列元素转换成 hashable 类型。下面是它的用法示例：

1. >>> a = [ {'x':1, 'y':2}, {'x':1, 'y':3}, {'x':1, 'y':2}, {'x':2, 'y':4}]
2. >>> list(dedupe(a, key=lambda d: (d['x'],d['y'])))
3. [{'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 2, 'y': 4}]
4.  
5. >>> list(dedupe(a, key=lambda d: d['x']))
6. [{'x': 1, 'y': 2}, {'x': 2, 'y': 4}]

如果你想基于单个字段、属性或者某个更大的数据结构来消除重复元素，第二种方案同样可以胜任。

如果你仅仅就是想消除重复元素，通常可以简单的构造一个集合。比如：

1. >>> a = [1, 5, 2, 1, 9, 1, 5, 10]
2. >>> list(set(a))
3. [1, 2, 10, 5, 9]

然而，这种方法不能维护元素的顺序，生成的结果中的元素位置被打乱,而上面的方法可以避免这种情况。

我们使用了生成器函数让我们的函数更加通用，不仅仅是局限于列表处理。 比如，如果如果你想读取一个文件，消除重复行，你可以很容易像这样做：

1. with open(somefile,'r') as f:
2. for line in dedupe(f):
3. ...

上述key函数参数模仿了 sorted() , min() 和 max() 等内置函数的相似功能。

3. 统计列表中出现次数最多的元素

怎样找出一个列表中出现次数最多的元素呢， collections.Counter 类就是专门为这类问题而设计的， 它甚至有一个有用的 most_common() 方法直接给了你答案。

为了演示，先假设你有一个单词列表并且想找出哪个单词出现频率最高。你可以这样做：

1. >>> from collections import Counter
2. >>> words = [
3. ... 'look', 'into', 'my', 'eyes', 'look', 'into', 'my', 'eyes',
4. ... 'the', 'eyes', 'the', 'eyes', 'the', 'eyes', 'not', 'around', 'the',
5. ... 'eyes', "don't", 'look', 'around', 'the', 'eyes', 'look', 'into',
6. ... 'my', 'eyes', "you're", 'under'
7. ... ]
8. >>>
9. >>> word_counts = Counter(words)
10. >>> top_three = word_counts.most_common(3)
11. >>> print(top_three)
12. [('eyes', 8), ('the', 5), ('look', 4)]

作为输入， Counter 对象可以接受任意的由可哈希( hashable )元素构成的序列对象。 在底层实现上，一个 Counter 对象就是一个字典，将元素映射到它出现的次数上, 比如:

1. >>> word_counts['not']
2. 1
3. >>> word_counts['eyes']
4. 8

如果你想手动增加计数，可以简单的用加法：

1. >>> morewords = ['why','are','you','not','looking','in','my','eyes']
2. >>> for word in morewords:
3. ... word_counts[word] += 1
4. ...
5. >>> word_counts['eyes']
6. 9

或者你可以使用 update() 方法：

word_counts.update(morewords)

Counter 实例一个鲜为人知的特性是它们可以很容易的跟数学运算操作相结合,比如：

1. >>> a = Counter(words)
2. >>> b = Counter(morewords)
3. >>> a
4. Counter({'eyes': 8, 'the': 5, 'look': 4, 'into': 3, 'my': 3, 'around': 2,
5. "you're": 1, "don't": 1, 'under': 1, 'not': 1})
6. >>> b
7. Counter({'eyes': 1, 'looking': 1, 'are': 1, 'in': 1, 'not': 1, 'you': 1,
8. 'my': 1, 'why': 1})
9. >>> # Combine counts
10. >>> c = a + b
11. >>> c
12. Counter({'eyes': 9, 'the': 5, 'look': 4, 'my': 4, 'into': 3, 'not': 2,
13. 'around': 2, "you're": 1, "don't": 1, 'in': 1, 'why': 1,
14. 'looking': 1, 'are': 1, 'under': 1, 'you': 1})
15. >>> # Subtract counts
16. >>> d = a - b
17. >>> d
18. Counter({'eyes': 7, 'the': 5, 'look': 4, 'into': 3, 'my': 2, 'around': 2,
19. "you're": 1, "don't": 1, 'under': 1})

毫无疑问， Counter 对象在几乎所有需要制表或者计数数据的场合是非常有用的工具。 在解决这类问题的时候你应该优先选择它，而不是手动的利用字典去实现。

4. 过滤列表元素

你有一个数据列表，想利用一些规则从中提取出需要的值或者是缩短列表,最简单的过滤序列元素的方法就是使用列表推导,比如：

1. >>> nums = [1, 2, -1, 4, 100, -2]
2. >>> [n for n in nums if n > 0]
3. [1, 2, 4, 100]
4. >>> [n for n in nums if n < 0]
5. [-1, -2]

使用列表推导的一个潜在缺陷就是如果输入非常大的时候会产生一个非常大的结果集，占用大量内存。 如果你对内存比较敏感，那么你可以使用生成器表达式迭代产生过滤的元素,比如：

1. >>> nums = [1, 2, -1, 4, 100, -2]
2. >>> num = (n for n in nums if n < 0)
3. >>> num
4. <generator object <genexpr> at 0x102210a50>
5. >>> for n in num:
6. ... print(n)
7. ...
8. -1
9. -2

有时候，过滤规则比较复杂，不能简单的在列表推导或者生成器表达式中表达出来。 比如，假设过滤的时候需要处理一些异常或者其他复杂情况。这时候你可以将过滤代码放到一个函数中， 然后使用内建的 filter() 函数,示例如下：

1. values = ['1', '2', '-3', '-', '4', 'N/A', '5']
2. def is_int(val):
3. try:
4. x = int(val)
5. return True
6. except ValueError:
7. return False
8. ivals = list(filter(is_int, values))
9. print(ivals)
10. # Outputs ['1', '2', '-3', '4', '5']

filter() 函数创建了一个迭代器，因此如果你想得到一个列表的话，就得像示例那样使用 list() 去转换。

列表推导和生成器表达式通常情况下是过滤数据最简单的方式。 其实它们还能在过滤的时候转换数据,比如：

1. >>> mylist = [1, 4, -5, 10, -7, 2, 3, -1]
2. >>> import math
3. >>> [math.sqrt(n) for n in mylist if n > 0]
4. [1.0, 2.0, 3.1622776601683795, 1.4142135623730951, 1.7320508075688772]

过滤操作的一个变种就是将不符合条件的值用新的值代替，而不是丢弃它们。 比如，在一列数据中你可能不仅想找到正数，而且还想将不是正数的数替换成指定的数。 通过将过滤条件放到条件表达式中去，可以很容易的解决这个问题，就像这样：

1. >>> mylist = [1, 4, -5, 10, -7, 2, 3, -1]
2. >>> clip_neg = [n if n > 0 else 0 for n in mylist]
3. >>> clip_neg
4. [1, 4, 0, 10, 0, 2, 3, 0]
5. >>> clip_pos = [n if n < 0 else 0 for n in mylist]
6. >>> clip_pos
7. [0, 0, -5, 0, -7, 0, 0, -1]

另外一个值得关注的过滤工具就是 itertools.compress() ， 它以一个 iterable 对象和一个相对应的 Boolean 选择器序列作为输入参数。 然后输出 iterable 对象中对应选择器为 True 的元素。 当你需要用另外一个相关联的序列来过滤某个序列的时候，这个函数是非常有用的。 比如，假如现在你有下面两列数据：

1. addresses = [
2. '5412 N CLARK',
3. '5148 N CLARK',
4. '5800 E 58TH',
5. '2122 N CLARK',
6. '5645 N RAVENSWOOD',
7. '1060 W ADDISON',
8. '4801 N BROADWAY',
9. '1039 W GRANVILLE',
10. ]
11. counts = [ 0, 3, 10, 4, 1, 7, 6, 1]

现在你想将那些对应 count 值大于5的地址全部输出，那么你可以这样做：

1. >>> from itertools import compress
2. >>> more5 = [n > 5 for n in counts]
3. >>> more5
4. [False, False, True, False, False, True, True, False]
5. >>> list(compress(addresses, more5))
6. ['5800 E 58TH', '1060 W ADDISON', '4801 N BROADWAY']

这里的关键点在于先创建一个 Boolean 序列，指示哪些元素符合条件。 然后 compress() 函数根据这个序列去选择输出对应位置为 True 的元素。

和 filter() 函数类似， compress() 也是返回的一个迭代器。因此，如果你需要得到一个列表，那么你需要使用 list() 来将结果转换为列表类型。

5. 列表上索引值迭代

你想在迭代一个列表的同时跟踪正在被处理的元素索引，内置的 enumerate() 函数可以很好的解决这个问题：

1. >>> my_list = ['a', 'b', 'c']
2. >>> for idx, val in enumerate(my_list):
3. ... print(idx, val)
4. ...
5. 0 a
6. 1 b
7. 2 c

为了按传统行号输出(行号从1开始)，你可以传递一个开始步长值：

1. >>> my_list = ['a', 'b', 'c']
2. >>> for idx, val in enumerate(my_list, 1):
3. ... print(idx, val)
4. ...
5. 1 a
6. 2 b
7. 3 c

这种情况在你遍历文件时想在错误消息中使用行号定位时候非常有用：

1. def parse_data(filename):
2. with open(filename, 'rt') as f:
3. for lineno, line in enumerate(f, 1):
4. fields = line.split()
5. try:
6. count = int(fields[1])
7. ...
8. except ValueError as e:
9. print('Line {}: Parse error: {}'.format(lineno, e))

enumerate() 对于跟踪某些值在列表中出现的位置是很有用的。 所以，如果你想将一个文件中出现的单词映射到它出现的行号上去，可以很容易的利用 enumerate() 来完成：

1. word_summary = defaultdict(list)
2.  
3. with open('myfile.txt', 'r') as f:
4. lines = f.readlines()
5.  
6. for idx, line in enumerate(lines):
7. # Create a list of words in current line
8. words = [w.strip().lower() for w in line.split()]
9. for word in words:
10. word_summary[word].append(idx)

如果你处理完文件后打印 word_summary ，会发现它是一个字典(准确来讲是一个 defaultdict )， 对于每个单词有一个 key ，每个 key 对应的值是一个由这个单词出现的行号组成的列表。 如果某个单词在一行中出现过两次，那么这个行号也会出现两次， 同时也可以作为文本的一个简单统计。

当你想额外定义一个计数变量的时候，使用 enumerate() 函数会更加简单。你可能会像下面这样写代码：

1. lineno = 1
2. for line in f:
3. # Process line
4. ...
5. lineno += 1

但是如果使用 enumerate() 函数来代替就显得更加优雅了：

1. for lineno, line in enumerate(f):
2. # Process line
3. ...

enumerate() 函数返回的是一个 enumerate 对象实例， 它是一个迭代器，返回连续的包含一个计数和一个值的元组， 元组中的值通过在传入序列上调用 next() 返回。

还有一点可能并不很重要，但是也值得注意， 有时候当你在一个已经解压后的元组序列上使用 enumerate() 函数时很容易调入陷阱。 你得像下面正确的方式这样写：

1. data = [ (1, 2), (3, 4), (5, 6), (7, 8) ]
2. # Correct!
3. for n, (x, y) in enumerate(data):
4. ...
5. # Error!
6. for n, x, y in enumerate(data):
7. ...

6. 同时迭代多个列表

你想同时迭代多个列表，每次分别从一个序列中取一个元素， 为了同时迭代多个序列，使用 zip() 函数,比如：

1. >>> xpts = [1, 5, 4, 2, 10, 7]
2. >>> ypts = [101, 78, 37, 15, 62, 99]
3. >>> for x, y in zip(xpts, ypts):
4. ... print(x,y)
5. ...
6. 1 101
7. 5 78
8. 4 37
9. 2 15
10. 10 62
11. 7 99

zip(a, b) 会生成一个可返回元组 (x, y) 的迭代器，其中x来自a，y来自b。 一旦其中某个序列到底结尾，迭代宣告结束。 因此迭代长度跟参数中最短序列长度一致。

1. >>> a = [1, 2, 3]
2. >>> b = ['w', 'x', 'y', 'z']
3. >>> for i in zip(a,b):
4. ... print(i)
5. ...
6. (1, 'w')
7. (2, 'x')
8. (3, 'y')

如果这个不是你想要的效果，那么还可以使用 itertools.zip_longest() 函数来代替,比如：

1. >>> from itertools import zip_longest
2. >>> for i in zip_longest(a,b):
3. ... print(i)
4. ...
5. (1, 'w')
6. (2, 'x')
7. (3, 'y')
8. (None, 'z')
9.  
10. >>> for i in zip_longest(a, b, fillvalue=0):
11. ... print(i)
12. ...
13. (1, 'w')
14. (2, 'x')
15. (3, 'y')
16. (0, 'z')

当你想成对处理数据的时候 zip() 函数是很有用的。 比如，假设你headers列表和一个values列表，就像下面这样：

1. headers = ['name', 'shares', 'price']
2. values = ['ACME', 100, 490.1]

使用zip()可以让你将它们打包并生成一个字典：

1. s = dict(zip(headers,values))

或者你也可以像下面这样产生输出：

1. for name, val in zip(headers, values):
2. print(name, '=', val)

虽然不常见，但是 zip() 可以接受多于两个的序列的参数。 这时候所生成的结果元组中元素个数跟输入序列个数一样, 比如:

1. >>> a = [1, 2, 3]
2. >>> b = [10, 11, 12]
3. >>> c = ['x','y','z']
4. >>> for i in zip(a, b, c):
5. ... print(i)
6. ...
7. (1, 10, 'x')
8. (2, 11, 'y')
9. (3, 12, 'z')

最后强调一点就是, zip() 会创建一个迭代器来作为结果返回。 如果你需要将结对的值存储在列表中，要使用 list() 函数,比如：

1. >>> zip(a, b)
2. <zip object at 0x1007001b8>
3. >>> list(zip(a, b))
4. [(1, 10), (2, 11), (3, 12)]

7. 展开嵌透的列表

你想将一个多层嵌套的列表展开成一个单层列表, 可以写一个包含 yield from 语句的递归生成器来轻松解决这个问题。比如：

1. from collections import Iterable
2. def flatten(items, ignore_types=(str, bytes)):
3. for x in items:
4. if isinstance(x, Iterable) and not isinstance(x, ignore_types):
5. yield from flatten(x)
6. else:
7. yield x
8.  
9. items = [1, 2, [3, 4, [5, 6], 7], 8]
10. # Produces 1 2 3 4 5 6 7 8
11. for x in flatten(items):
12. print(x)

在上面代码中， isinstance(x, Iterable) 检查某个元素是否是可迭代的。 如果是的话 yield from 就会返回所有子例程的值。最终返回结果就是一个没有嵌套的简单列表了。

额外的参数 ignore_types 和检测语句 isinstance(x, ignore_types) 用来将字符串和字节排除在可迭代对象外，防止将它们再展开成单个的字符。 这样的话字符串数组就能最终返回我们所期望的结果了。比如：

1. >>> items = ['Dave', 'Paula', ['Thomas', 'Lewis']]
2. >>> for x in flatten(items):
3. ... print(x)
4. ...
5. Dave
6. Paula
7. Thomas
8. Lewis

语句 yield from 在你想在生成器中调用其他生成器作为子例程的时候非常有用。 如果你不使用它的话，那么就必须写额外的 for 循环了,比如：

1. def flatten(items, ignore_types=(str, bytes)):
2. for x in items:
3. if isinstance(x, Iterable) and not isinstance(x, ignore_types):
4. for i in flatten(x):
5. yield i
6. else:
7. yield x

尽管只改了一点点，但是 yield from 语句看上去感觉更好，并且也使得代码更简洁清爽。

之前提到的对于字符串和字节的额外检查是为了防止将它们再展开成单个字符。 如果还有其他你不想展开的类型，修改参数 ignore_types 即可。

最后要注意的一点是 yield from 在涉及到基于协程和生成器的并发编程中扮演着更加重要的角色。

8. 映射名称到列表元素

你有一段通过下标访问列表或者元组中元素的代码，但是这样有时候会使得你的代码难以阅读， 于是你想通过名称来访问元素。

·collections.namedtuple()·函数通过使用一个普通的元组对象来帮你解决这个问题。 这个函数实际上是一个返回Python中标准元组类型子类的一个工厂方法。 你需要传递一个类型名和你需要的字段给它，然后它就会返回一个类，你可以初始化这个类，为你定义的字段传递值等。 代码示例：

1. >>> from collections import namedtuple
2. >>> Subscriber = namedtuple('Subscriber', ['addr', 'joined'])
3. >>> sub = Subscriber('jonesy@example.com', '2012-10-19')
4. >>> sub
5. Subscriber(addr='jonesy@example.com', joined='2012-10-19')
6. >>> sub.addr
7. 'jonesy@example.com'
8. >>> sub.joined
9. '2012-10-19'

尽管 namedtuple 的实例看起来像一个普通的类实例，但是它跟元组类型是可交换的，支持所有的普通元组操作，比如索引和解压。 比如：

1. >>> len(sub)
2. 2
3. >>> addr, joined = sub
4. >>> addr
5. 'jonesy@example.com'
6. >>> joined
7. '2012-10-19'

命名元组的一个主要用途是将你的代码从下标操作中解脱出来。 因此，如果你从数据库调用中返回了一个很大的元组列表，通过下标去操作其中的元素， 当你在表中添加了新的列的时候你的代码可能就会出错了。但是如果你使用了命名元组，那么就不会有这样的顾虑。

为了说明清楚，下面是使用普通元组的代码：

1. def compute_cost(records):
2. total = 0.0
3. for rec in records:
4. total += rec[1] * rec[2]
5. return total

下标操作通常会让代码表意不清晰，并且非常依赖记录的结构。 下面是使用命名元组的版本：

1. from collections import namedtuple
2.  
3. Stock = namedtuple('Stock', ['name', 'shares', 'price'])
4. def compute_cost(records):
5. total = 0.0
6. for rec in records:
7. s = Stock(*rec)
8. total += s.shares * s.price
9. return total

命名元组另一个用途就是作为字典的替代，因为字典存储需要更多的内存空间。 如果你需要构建一个非常大的包含字典的数据结构，那么使用命名元组会更加高效。 但是需要注意的是，不像字典那样，一个命名元组是不可更改的。比如：

1. >>> s = Stock('ACME', 100, 123.45)
2. >>> s
3. Stock(name='ACME', shares=100, price=123.45)
4. >>> s.shares = 75
5. Traceback (most recent call last):
6. File "<stdin>", line 1, in <module>
7. AttributeError: can't set attribute

如果你真的需要改变属性的值，那么可以使用命名元组实例的 _replace() 方法， 它会创建一个全新的命名元组并将对应的字段用新的值取代。比如：

1. >>> s = s._replace(shares=75)
2. >>> s
3. Stock(name='ACME', shares=75, price=123.45)

_replace() 方法还有一个很有用的特性就是当你的命名元组拥有可选或者缺失字段时候， 它是一个非常方便的填充数据的方法。 你可以先创建一个包含缺省值的原型元组，然后使用 _replace() 方法创建新的值被更新过的实例。比如：

1. from collections import namedtuple
2. Stock = namedtuple('Stock', ['name', 'shares', 'price', 'date', 'time'])
3. # Create a prototype instance
4. stock_prototype = Stock('', 0, 0.0, None, None)
5. # Function to convert a dictionary to a Stock
6. def dict_to_stock(s):
7. return stock_prototype._replace(**s)

下面是它的使用方法：

1. >>> a = {'name': 'ACME', 'shares': 100, 'price': 123.45}
2. >>> dict_to_stock(a)
3. Stock(name='ACME', shares=100, price=123.45, date=None, time=None)
4. >>> b = {'name': 'ACME', 'shares': 100, 'price': 123.45, 'date': '12/17/2012'}
5. >>> dict_to_stock(b)
6. Stock(name='ACME', shares=100, price=123.45, date='12/17/2012', time=None)

最后要说的是，如果你的目标是定义一个需要更新很多实例属性的高效数据结构，那么命名元组并不是你的最佳选择。 这时候你应该考虑定义一个包含 slots 方法的类.

总结

以上所述是小编给大家介绍的Python数据类型之列表和元组的方法实例详解,希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对我们网站的支持！
如果你觉得本文对你有帮助，欢迎转载，烦请注明出处，谢谢！

原文链接：https://fashengba.com/post/python-list-tuple.html