跟着官档学python 004- 数据结构（一）

5.1. 列表的更多特性

列表数据类型还有更多的方法。这里是列表对象方法的清单：

list.count(x)
返回列表中 x 出现的次数。

>>> a=[1,2,2,3,3,3,4,4,4,4,5.5]
>>> print(a.count(2),a.count(4),a.count(5))
2 4 0

list.append(x)
添加一个元素到列表的末尾。相当于 a[len(a):] = [x].

>>> a.append([6,6,6])
>>> print(a[:])
[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5.5, [6, 6, 6]]
>>> a.append(6)
>>> print(a[:])
[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5.5, [6, 6, 6], 6]

list.insert(i, x)
在给定位置插入一个元素。第一个参数为被插入元素的位置索引，因此 a.insert(0, x) 在列表头插入值， a.insert(len(a), x)相当于 a.append(x).

>>> a.insert(8,8)
>>> print(a[:])
[1, 2, 2, 3, 3, 3, 4, 4, 8, 4, 4, 5.5, [6, 6, 6], 6]

list.index(x)
返回列表中第一个值为 x 的元素的索引。如果没有这样的元素将会报错。

>>> a.index(5.5)
11

list.remove(x)
删除列表中第一个值为 x 的元素。如果没有这样的项目则会有一个错误。

>>> a.remove([6,6,6])
>>> print(a[:])
[1, 2, 2, 3, 3, 3, 4, 4, 8, 4, 4, 5.5, 6]

list.reverse()
列表中的元素按位置反转。

>>> a.reverse()
>>> a
[6, 5.5, 4, 4, 8, 4, 4, 3, 3, 3, 2, 2, 1]

list.sort(key=None, reverse=False)
排序列表中的项 (参数可被自定义, 参看 sorted() ).

>>> a.sort()
>>> a
[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5.5, 6, 8]

list.pop([i])
删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop()将会删除并返回列表中的最后一个元素。（i 两边的方括号表示这个参数是可选的，而不是要你输入方括号。你会在 Python 参考库中经常看到这种表示法)。

>>> a.pop()
8
>>> a
[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5.5, 6]

list.extend(L)
将给定列表L中的所有元素附加到原列表a的末尾。相当于 a[len(a):] = L.

>>> b=[1000,'man']
>>> a.extend(b)
>>> a
[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5.5, 6, 1000, 'man']

list.clear()
删除列表中所有的元素。相当于 del a[:].

>>> a.clear()
>>> a
[]
>>>

list.copy()
返回列表的一个浅拷贝。相当于 a[:].

>>> c=a.copy()
>>> c
[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5.5, 6, 1000, 'man']

5.1.1. 列表作为栈使用

列表方法使得将列表用作堆栈非常容易，其中添加的最后一个元素是可提取的第一个元素（“last-in，first-out”）。使用 append()添加项到栈顶。使用无参的 pop() 从栈顶检出项。例如：

>>> test=[1,1,2,3]
>>> test.append(4)
>>> test.append(5)
>>> test
[1, 1, 2, 3, 4, 5]
>>> test.pop()
5
>>> test
[1, 1, 2, 3, 4]
>>> test.pop()
4
>>> test
[1, 1, 2, 3]
>>>

5.1.2. 列表作为队列使用

列表也有可能被用来作队列——先添加的元素被最先取出 (“先进先出”)；然而列表用作这个目的相当低效。因为在列表的末尾添加和弹出元素非常快，但是在列表的开头插入或弹出元素却很慢 (因为所有的其他元素必须向右或向左移一位)。

若要实现一个队列， collections.deque 被设计用于快速地从两端操作。例如：

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")
>>> queue.append("Graham")
>>> queue.popleft()
'Eric'
>>> queue.popleft()
'John'
>>> queue
deque(['Michael', 'Terry', 'Graham'])

5.1.3. 列表推导式

列表推导式提供一个生成列表的简洁方法。应用程序通常会从一个序列的每个元素的操作结果生成新的列表，或者生成满足特定条件的元素的子序列。

例如，假设我们要创建一个平方数列表，如：

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

注意，上面这个创建（或者覆盖）了一个名为x的变量，它在循环结束时仍然存在。我们可以计算没有任何副作用的平方数列表：

>>> squares = list(map(lambda x: x**2, range(10)))

或者，等价地:

>>> squares = [x**2 for x in range(10)]

列表推导式由一对方括号组成，方括号包含一个表达式，其后跟随一个for子句，然后是零个或多个for或if子句。结果将是一个新的列表，其值来自将表达式在其后的for和if子句的上下文中求值得到的结果。例如，下面的 listcomp 组合两个列表中不相等的元素：

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

它等价于：

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

如果表达式是一个元组（例如，前面示例中的(x, y)），它必须位于圆括号中。

>>> vec=[-4,3,0,4]
>>> [x*2 for x in vec]
[-8, 6, 0, 8]
>>> [x for x in vec if x >=0]
[3, 0, 4]
>>> [abs(x) for x in vec ]
[4, 3, 0, 4]
>>> freshfruit=[' banana',' loganberry','passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> [(x,x*2) for x in range(6)]
[(0, 0), (1, 2), (2, 4), (3, 6), (4, 8), (5, 10)]
>>> vec = [[1,2,3],[4,5,6],[7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

列表推导式可以包含复杂的表达式和嵌套的函数：

>>> from math import pi
>>> [str(round(pi,i)) for i in range(1,6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

5.1.4. 嵌套的列表推导式

列表推导式的第一个表达式可以是任何表达式，包括另外一个列表推导式。
考虑下面由三个长度为 4 的列表组成的 3x4 矩阵：

>>> matrix=[
...     [1,2,3,4],
...     [5,6,7,8]
...    ,[9,10,11,12]
... ]
>>> matrix
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

下面的列表推导式将转置行和列：

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

正如在前一节中我们所见，嵌套的列表推导式在它后面的for上下文中求值，所以这个例子等效于：

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

展开后，和下面的代码相同：

>>> for i in range(4):
...     transposed_row = []
...     for row in matrix:
...         transposed_row.append(row[i])
...     transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

在实际中，与复杂的控制流比起来，你应该更喜欢内置的函数。zip()函数对这个使用场景做得非常好：

>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

未完待续。。。