[Python知识库]Python 数据结构之列表

列表

列表的创建

list函数与range函数搭配生成列表

In [50]: c_list = list(range(10))

In [51]: c_list
Out[51]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

向列表中添加元素

append在列表末尾添加单个元素

In [52]: b_list.append('hello')

In [53]: b_list
Out[53]: ['a', 4, 9, 'hello']

insert可以在指定位置插入元素

In [54]: b_list.insert(1, 'worf')

In [55]: b_list
Out[55]: ['a', 'worf', 4, 9, 'hello']

删除列表中的元素

pop可以删除特定位置的元素，并返回该元素

In [56]: b_list.pop(3)
Out[56]: 9

remove删除某个值，remove会先找到第一个值删除，然后再删除第二个，依次类推

In [57]: d_list = ['foo', 'exo', 'fx', 'foo']

In [58]: d_list.remove('foo')
In [60]: d_list
Out[60]: ['exo', 'fx', 'foo']

In [62]: d_list.remove('foo')
In [63]: d_list
Out[63]: ['exo', 'fx']

列表的串联

使用加号将两个列表串联起来

In [66]: [3, None, 0] + ['a', 'is', 1]
Out[66]: [3, None, 0, 'a', 'is', 1]

使用extend方法在列表末尾追加新列表

In [67]: x = [1, None, 'a']

In [68]: x.extend([7, 9, 0, 1])  # extend()的参数是一个列表
In [69]: x
Out[69]: [1, None, 'a', 7, 9, 0, 1]

注：使用加法和extend方法都可以将两个列表串联起来，但是extend方法的效率更高。因为使用“+”需要建立一个新列表，并将两个列表中的元素复制过来。而extend方法是在原有列表的后面追加一个新列表，无需复制。即：

everything = []
for chunk in list_of_lists:
	everything.extend(chunk)

效率高于：

everything = []
for chunk in list_in_lists:
	everything += chunk

对列表的元素进行排序

sort函数对原列表进行排序（不创建新的列表）

In [70]: a = [1, 3, 9, 2, 7]

In [71]: a.sort()
In [72]: a
Out[72]: [1, 2, 3, 7, 9]

sort函数的key参数，可以指定排序方式

In [77]: a = ['saw', 'he', 'small', 'foxes', 'six']

In [78]: a.sort(key=len)  # 指定按照元素的长度进行排序
In [79]: a
Out[79]: ['he', 'saw', 'six', 'small', 'foxes']

sorted方法基于任意一个列表返回一个新的排好序的列表，而不改变原列表

In [1]: some_list = [7, 1, 2, 5, 6, 0, 3]

In [2]: sorted(some_list)
Out[2]: [0, 1, 2, 3, 5, 6, 7]

In [3]: some_list
Out[3]: [7, 1, 2, 5, 6, 0, 3]

sorted方法可以接受与sort方法相同的参数

In [4]: some_list = ['a', 'boy', 'is', 'crying']

In [5]: sorted(some_list, key=len)
Out[5]: ['a', 'is', 'boy', 'crying']

维护已排序的列表

bisect模块支持向已排序的列表中插入值，插入后仍能保持正确排序。bisect.bisect可以找到插入值后仍保证正确排序的位置，bisect.insert是向这个位置插入值。

In [80]: import bisect

In [81]: c = [1, 2, 2, 2, 3, 4, 7]
In [82]: bisect.bisect(c, 2) #参数表示向列表c插入2，返回能保证正确排序的索引
Out[82]: 4  # 返回值表示向索引为4的位置插入2，可以保持正确排序

In [84]: bisect.insort(c, 6)  # 将6插入正确的位置
In [85]: c
Out[85]: [1, 2, 2, 2, 3, 4, 6, 7]  # 6自动的被插入正确的位置

注意，bisect模块不会检查一个列表是否已经排好序。因此，对未排序的列表使用bisect模块不会报错，但不一定得出正确的结果。

切片

切片的基本形式是在方括号中使用start:stop:step,start是起始位置，stop是终止位置，step是步长。切片的列表包含起始位置的元素，不包含结束位置的元素。

In [86]: seq = [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [87]: seq[0:3:1]
Out[87]: [1, 2, 3]  # 包含起始位置0，不包含终止位置3，要切片的元素的索引是0,1,2

step是步长，通过步长，可以设置取数间隔和方向。step默认为1(可以省略)，表示不间隔取数。步长为2，表示隔一个数取一个数；步长为负，表示从后往前切片，步长为-1，可以实现列表的逆转。

In [96]: seq[::2]  # 步长为2，隔一个数取一个数
Out[96]: [1, 3, 5, 7, 9]

In [97]: seq[::-1]  # 步长为-1，可以翻转列表
Out[97]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

start和stop都可以省略。省略start默认从序列的头开始，省略stop默认到序列尾结束。

In [90]: seq[:3]
Out[90]: [1, 2, 3]

In [92]: seq[6:]
Out[92]: [7, 8, 9]

start和stop可以为负，负数表示从后往前数。注意，从前往后的顺序依次是0，1，2，3，…；从后往前的顺序是-1，-2，-3，…

In [94]: seq[-6:]
Out[94]: [4, 5, 6, 7, 8, 9]  # 表示从倒数第六个元素开始，一直到列表尾部结束

In [95]: seq[-6:-2]  # 从倒数第6个元素开始，到倒数第2个元素为止（不包括倒数第2个元素）
Out[95]: [4, 5, 6, 7]

通过切片还可以为列表赋值

In [88]: seq[0:3] = [10, 100, 1000]

In [89]: seq
Out[89]: [10, 100, 1000, 4, 5, 6, 7, 8, 9]

序列函数

enumrate函数

当遍历一个序列时，可能想跟踪当前项的序号。可能的一个做法是

In [6]: i = 0
In [7]: for value in some_list:
   ...:     i += 1

Python内置的enumerate函数可以轻松的实现该功能

In [8]: some_list = ['foo', 'bar', 'baz']  # 只有当列表的元素是唯一的，才可以将其全部遍历到字典中。

In [11]: mapping = {}
In [12]: for i, value in enumerate(some_list):
    ...:     mapping[value] = i

In [13]: mapping
Out[13]: {'foo': 0, 'bar': 1, 'baz': 2}

zip函数

zip函数可以将多个列表、元组或者其他序列组合成一个元组列表

In [14]: seq1 = ['foo', 'bar', 'baz']
In [15]: seq2 = ['one', 'two', 'three']

In [16]: zipped = zip(seq1, seq2)

In [17]: list(zipped)
Out[17]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

zip可以组合任意多的序列，但是元素的个数取决于最短的序列

In [18]: seq3 = [False, True]

In [19]: list(zip(seq1, seq2, seq3))
Out[19]: [('foo', 'one', False), ('bar', 'two', True)]

zip的常见用法之一是同时遍历多个序列，可以结合enumerate使用

In [20]: for i, (a, b) in enumerate(zip(seq1, seq2)):
    ...:     print('{0}: {1}, {2}'.format(i, a, b))

0: foo: one
1: bar: two
2: baz: three

给出一个“被压缩”的序列，zip还可以用来解压序列。即实现相反的操作

In [21]: pichers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'), ('Schilling', 'Curt')]
In [22]: first_name, last_name = zip(*pichers)

In [23]: first_name
Out[23]: ('Nolan', 'Roger', 'Schilling')
In [24]: last_name
Out[24]: ('Ryan', 'Clemens', 'Curt')

reversed函数

reversed函数可以反转一个序列

In [25]: some_list = [1, 2, 3, 4, 5, 6, 7, 8]

In [26]: list(reversed(some_list))
Out[26]: [8, 7, 6, 5, 4, 3, 2, 1]