python笔记--列表(切片，排序，enumerate，sorted，zip,reversed)

列表

与元组对⽐，列表的⻓度可变、内容可以被修改。你可以⽤⽅括号定义，或⽤ list 函数：

In [36]: a_list = [2, 3, 7, None]
In [37]: tup = ('foo', 'bar', 'baz')
In [38]: b_list = list(tup)
In [39]: b_list
Out[39]: ['foo', 'bar', 'baz']
In [40]: b_list[1] = 'peekaboo'
In [41]: b_list
Out[41]: ['foo', 'peekaboo', 'baz']

添加和删除元素

可以⽤ append 在列表末尾添加元素：

In [45]: b_list.append('dwarf')
In [46]: b_list
Out[46]: ['foo', 'peekaboo', 'baz', 'dwarf']

insert 可以在特定的位置插⼊元素：

In [47]: b_list.insert(1, 'red')
In [48]: b_list
Out[48]: ['foo', 'red', 'peekaboo', 'baz', 'dwarf']

tip:与 append 相⽐， insert 耗费的计算量⼤，因为对后续元素的引⽤必须在内部迁移，以便为新元素提供空间。

insert的逆运算是pop，它移除并返回指定位置的元素：

In [49]: b_list.pop(2)
Out[49]: 'peekaboo'
In [50]: b_list
Out[50]: ['foo', 'red', 'baz', 'dwarf']

可以⽤ remove 去除某个值， remove 会先寻找第⼀个值并除去：

In [51]: b_list.append('foo')
In [52]: b_list
Out[52]: ['foo', 'red', 'baz', 'dwarf', 'foo']
In [53]: b_list.remove('foo')
In [54]: b_list
Out[54]: ['red', 'baz', 'dwarf', 'foo']

串联和组合列表

与元组类似，可以⽤加号将两个列表串联起来：

In [57]: [4, None, 'foo'] + [7, 8, (2, 3)]
Out[57]: [4, None, 'foo', 7, 8, (2, 3)]

如果已经定义了⼀个列表，⽤ extend ⽅法可以追加多个元素：

In [58]: x = [4, None, 'foo']
In [59]: x.extend([7, 8, (2, 3)])
In [60]: x
Out[60]: [4, None, 'foo', 7, 8, (2, 3)]

tip:通过加法将列表串联的计算量较⼤，因为要新建⼀个列表，并且要复制对象。⽤ extend 追加元素，尤其是到⼀个⼤列表中，更为可取。

排序

你可以⽤ sort 函数将⼀个列表原地排序（不创建新的对象）：

In [61]: a = [7, 2, 5, 1, 3]
In [62]: a.sort()
In [63]: a
Out[63]: [1, 2, 3, 5, 7]

sort 有⼀些选项，有时会很好⽤。其中之⼀是⼆级排序key，可以⽤这个key进⾏排序。例如，我们可以按⻓度对字符串进⾏排序：

In [64]: b = ['saw', 'small', 'He', 'foxes', 'six']
In [65]: b.sort(key=len)
In [66]: b
Out[66]: ['He', 'saw', 'six', 'small', 'foxes']

切⽚

⽤切边可以选取⼤多数序列类型的⼀部分，切⽚的基本形式是在⽅括号中使⽤ start:stop ：

In [73]: seq = [7, 2, 3, 7, 5, 6, 0, 1]
In [74]: seq[1:5]
Out[74]: [2, 3, 7, 5]

切⽚也可以被序列赋值：

In [75]: seq[3:4] = [6, 3]
In [76]: seq
Out[76]: [7, 2, 3, 6, 3, 5, 6, 0, 1]

负数表明从后向前切⽚：

In [79]: seq[-4:]
Out[79]: [5, 6, 0, 1]
In [80]: seq[-6:-2]
Out[80]: [6, 3, 5, 6]

⼀个聪明的⽅法是使⽤ -1 ，它可以将列表或元组颠倒过来：

In [82]: seq[::-1]
Out[82]: [1, 0, 6, 5, 3, 6, 3, 2, 7]

序列函数

enumerate函数

Python内建了⼀个 enumerate 函数，可以返回 (i, value) 元组序列,当你索引数据时，使⽤ enumerate 的⼀个好⽅法是计算序列（唯⼀的） dict 映射到位置的值：

In [83]: some_list = ['foo', 'bar', 'baz']
In [84]: mapping = {}
In [85]: for i, v in enumerate(some_list):
....: mapping[v] = i
In [86]: mapping
Out[86]: {'bar': 1, 'baz': 2, 'foo': 0}

sorted函数

sorted 函数可以从任意序列的元素返回⼀个新的排好序的列表：

In [87]: sorted([7, 1, 2, 6, 0, 3, 2])
Out[87]: [0, 1, 2, 2, 3, 6, 7]
In [88]: sorted('horse race')
Out[88]: [' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']

zip函数

zip 可以将多个列表、元组或其它序列成对组合成⼀个元组列表：

In [89]: seq1 = ['foo', 'bar', 'baz']
In [90]: seq2 = ['one', 'two', 'three']
In [91]: zipped = zip(seq1, seq2)
In [92]: list(zipped)
Out[92]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

zip 的常⻅⽤法之⼀是同时迭代多个序列，可能结合 enumerate 使⽤：

In [95]: 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

reversed函数

reversed 可以从后向前迭代⼀个序列：

In [100]: list(reversed(range(10)))
Out[100]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]