[译]The Python Tutorial#5. Data Structures

[译]The Python Tutorial#Data Structures

5.1 Data Structures

本章节详细介绍之前介绍过的一些内容，并且也会介绍一些新的内容。

5.1 More on Lists

列表数据类型拥有更多方法，以下是列表对象的所有方法：

• list.append(x)
  
  在列表末尾添加新项，等同于a[len(a):] = [x]

• list.extend(iterable)
  
  添加可迭代对象中所有的项来扩展列表，等同于a[len(a):] = iterable

• list.insert(i, x)
  
  在指定位置插入项。第一个参数为元素索引，新的项会在这个索引之前插入，因此a.insert(0, x)会在列表最前面插入，a.insert(len(a), x)等同于a.append(x)。

• list.remove(x)
  
  从列表中移除值为x的第一个项，若x不存在，方法抛出异常(ValueError异常)

• list.pop([i])
  
  从列表中移除指定位置的项并返回。如果没有指定索引，a.pop()移除并返回列表中最后一个项。（方法签名中包裹i的方括号表示参数是可选的，而不是在这个位置写一个方括号。这种记号法在Python Library Reference中经常用到）

• list.clear()
  
  移除列表中的所有项，等同于del a[:]

• list.index(x[, start[, end]])
  
  返回第一个值为x的项的基于0的索引，如果x不存在抛出ValueError异常。
  
  可选参数start和end被解释为切片记号法，用来将搜索限制在列表特定的子列表内。返回的索引是相对于完整列表索引，而不是相对于start参数的。

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

• list.sort(key=None, reverse=False)
  
  对列表的所有项进行排序（参数用来自定义排序，参见sorted()获取更多信息）

• list.reverse()
  
  反转列表元素

• list.copy()
  
  返回列表的浅拷贝，等同于a[:]

以下是演示列表方法的例子：

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'

诸如insert, reverse或者sort的这样，只改变了列表但是没有返回值打印，它们返回默认的None^[1]。这是Python可变数据结构适用的设计原则。

5.1.1 Using Lists as Stacks

列表方法使得将其用作栈非常容易，栈中最后一个加入的元素第一个被释放（后进先出）。使用append()方法添加元素到栈顶，使用不带参数的pop()将栈顶元素出栈。示例：

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

5.1.2 Using Lists as Queues

将列表用作队列也是可能的，队列中先添加的元素先释放（先进先出）；然而，这样用列表效率非常不高。因为在列表末尾添加和取出元素很快，但是在列表开头插入或者删除元素很慢（因为不得不将其他所有元素位移一位）。

经过特殊设计的collections.deque在首尾两端添加和删除元素都很快，可以使用它来实现队列。示例：

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

5.1.3 List Comprehensions

列表推导式为创建列表提供了简洁方式。一般的应用方式是：创建新列表，列表元素是对其他序列或者可迭代对象操作的结果；或者创建元素满足特定条件的子序列。

假如希望创建一个平方列表：

>>> 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子句的计算结果。例如，以下列表推导式组合两个列表中不相等的元素：

>>> [(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)]

注意上面两个代码段中for和if语句的顺序是相同的。

如果表达式是一个元组（如上所示的(x, y)），必须将其加上括号。

>>> vec = [-4, -2, 0, 2, 4]
>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # create a list of 2-tuples like (number, square)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)]
  File "<stdin>", line 1, in <module>
    [x, x**2 for x in range(6)]
               ^
SyntaxError: invalid syntax
>>> # flatten a list using a listcomp with two 'for'
>>> 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 Nested List Comprehensions

列表推导式开头的表达式可以是任意表达式，包括另一个列表推导式。

考虑以下示例，一个包含3个长度为4的列表的列表实现了3x4的矩阵：

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]]

依次等同于：

>>> transposed = []
>>> for i in range(4):
...		# the following 3 lines implement the nested listcomp
...		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]]

在实践中，应该选择built-in函数来复合流程语句。在以上的用例中zip()函数更有用：

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

参见 Unpacking Argument Lists了解关于上面*使用的更多详细信息。

5.2 The del statement

在提供列表索引而不是值的情况下，有一种方法可以移除列表中的元素：del语句。这种方式与返回值的pop()方法不同。del语句也可以用来移除部分列表或者清除整个列表（之前使用将空的列表赋值给列表片段的方式实现）。示例：

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

del也可以用来删除整个变量：

>>> del a

此后引用名字a会抛出异常（至少在其他值赋值给名字a之前）。接下来会有更多del的使用

5.3 Tuples and Sequences

列表和字符串有很多常用属性，比如索引和切片操作。它们是序列数据类型（参见 Sequence Types - list, tuple, range）的两种。Python是一种不断进化的语言，其他的序列类型也可以加入。元组是另一种标准的序列数据类型。

元组包含若干由逗号分隔的值，示例：

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

可见，输出的元组总是放在圆括号中，以便于嵌套的元组可以被正确解析；虽然圆括号总是必须的（如果元组是其他更大表达式的一部分），但是在输入元组的时候可以选择使用圆括号。不能对元组的单个项赋值，但是可以创建包含如列表的可变对象的元组。

虽然元组和列表有些相似，但是他们通常以不同的目的，用于不同的场景。元组是不可变的，通常包含不同类型的元素，可以通过拆包操作（参见后续章节）或者索引（或者当元组是命名元组时，甚至可以通过属性来访问）来访问。列表是可变的，通常其元素也是不同类型的，可以通过对列表的迭代访问元素。

构建包含零个或者1个项的元组比较特殊：一种额外的奇怪语法可以适用于这种情况。空元组由一对空的圆括号创建；一个元素的元组由一个跟着逗号的值创建（在圆括号中放入单个值是不够的。译注：这种情况：(1)表示整数而不是元组，使用(1, )表示元组也是可行的）。丑陋但是有效。示例：

>>> empty = ()
>>> singleton = 'hello',    # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

语句t = 12345, 54321, 'hello!'是封装元组的一个示例：值12345, 54321和hello!被封装到了一个元组中。逆向操作也是可行的：

>>> x, y, z = t

非常恰当地称之为序列解包，适用于任何在等号右边的序列（译注：等号右操作数）。序列解包要求等号左边待赋值的变量数量与序列包含元素数目相同。注意多重赋值只是封装元组和序列解包的结合（译注：多重赋值：i, j = 1, 2）

5.4 Set

Python也包含实现了集合的数据类型。集合是无序不重复的元素集。基本功能包括成员关系测试和重复实体消除。集合对象也支持并集，交集，差集以及对称差集等数学操作。

可以使用花括号和set()函数创建集合。谨记：创建空集合必须使用set函数，不能使用{}，后者用于创建空字典。

以下是简单示范：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

与列表推导式相同，Python也支持集合推导式：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

5.5 Dictionaries

另一个内嵌入Python中的数据结构是字典（参见 Mapping Types - dict）。字典在其他一些语言中被称为“联合存储”或者“联合数组”。与序列不同，序列以一系列数字作索引，字典以键作索引，键可以是任何不可变类型；通常使用字符串和数字作为键。只包含字符串，数字或者其他元组的元组也可以作为键；直接或者间接包含可变对象的元组不能作为键。因为列表可以使用索引赋值，切片赋值或者append()以及extend()等方法改变自身，所以列表不能作为键。

最好的理解字典的方式是将其认为是键值对的无序集合，同一集合中键唯一。一对花括号创建空字典：{}。在花括号中放置由逗号分隔键值对列表可以为字典添加初始键值对；这也是字典输出的格式。

字典提供的主要操作是：使用键存储值以及取值。可以使用del删除一个键值对。如果使用已经存在的键来存储值，那么与键关联的旧值会被重写。使用不存在的键来取值会抛出异常。

在字典上执行list(d.keys())返回字典所有键的无序列表（使用sorted(d.keys())使其有序）^[2]。使用关键字in检查键在字典中是否存在。

以下是使用字典的示例：

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

dict()构造器直接使用键值对序列构造字典：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

此外，字典推导式可以从任意键值表达式中创建字典：

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

当键是简单的字符串时，可以使用关键字参数来指定键值对：

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

5.6 Looping Techniques

遍历字典时，使用items()方法可以同时检索键及其对应的值。

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

遍历序列时，使用enumerate()函数可以同时检索位置索引及其对应的值：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

同时遍历两个或者更多序列时，使用zip()函数可以将元素组成对：

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

需要逆序遍历序列时，首先指定一个正向的序列，然后调用reversed()函数：

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

需要以特定顺序遍历序列时，使用sorted()函数返回新的有序序列，原序列不会改动：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

有时需要在遍历序列的同时修改序列，创建新的替代序列更加简单并且安全：

>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
...     if not math.isnan(value):
...         filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]

5.7 More on Conditions

while和if语句中使用的条件可以包含任意操作符，不仅仅是比较运算符。

比较运算符in和not in检查指定值在序列中是否存在（不存在）。操作符is和is not比较两个对象是否真正相同（内存地址比较）；这两个操作符只对像列表那样的可变对象重要。所有的比较运算符拥有相同的优先级，并且都低于数字运算符。

比较运算符可以链接起来。例如a < b == c测试b是否大于a同时b等于c（译注：同其他高级语言的：a < b and b == c）

比较运算符可以结合布尔运算符and和or使用，比较的结果（或者其他任何布尔表达式）可以使用not来作否定。and,or和not优先级比比较运算符低；其中not的优先级最高而or优先级最低，因此A and not B or C等同于(A and (not B)) or C。一如既往，可以使用圆括号表述想要的优先级顺序。

布尔运算符and和or号称短路运算符：它们的参数从左向右求值，一旦结果确定，求值过程就会停止。例如，如果A和C是真，B是假，A and B and C不会对表达式C求值（译注：A and B为假，已经确定了整个表达式A and B and C的值为假，表达式C的值对结果不会造成影响，因此不会对其求值）。当用作一般值而不是布尔值时，短路操作的返回值是最后一个求值的参数。

可以将比较运算或者布尔表达式赋值给变量：

>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'

注意在Python中，赋值操作不能像C语言一样在表达式内发生。C程序员也许会抱怨，但是这避免了C程序中遇到的一个普遍问题：当想要表示==时候可能误用了=。

5.8 Comparing Sequences and Other Types

相同序列类型之间的序列对象可以相互比较。比较使用字典序：首先比较两个序列的第一项，如果它们不同，比较运算的结果就可确定了；如果它们不同，比较两个序列中的下一个项，以此类推，直到其中一个序列耗尽。如果被比较的两个项是同一类型的，那么使用字典序递归比较。如果两个序列的所有项都是相等的，那么他们相等。如果其中一个序列是另一个序列的子序列，那么短的一个序列较小。字符串的字典序使用Unicode代码点数字排序单个字符。

以下是相同类型的序列对象之间的比较示例：

(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

注意当不同类型对象之间有合适的比较方式时，使用<或者>比较不同类型的对象是合法的。例如，混合数字类型之间的比较是根据其数字上的值，0等于0.0。否则，解释器会抛出TypeException异常，而不是随意提供结果

Footnotes

[1] 其他语言可能返回改变后的对象，从而允许方法链接，如：d->insert("a")>remove("b")->sort();

[2] 调用d.keys()返回一个dictionary view对象。从而支持如成员关系测试和迭代之类的操作，但是其内容并不是独立于原始字典的，只是一个视图