This chapter describes some things you’ve learned about already in more detail, and adds some new things as well.
本章详细讨论了你已经学过的一些知识，同样也添加了一些新内容。
The list data type has some more methods. Here are all of the methods of list objects:
Python的列表数据类型包含更多的方法。 这里是所有的列表对象方法：
Add an item to the end of the list; equivalent to a[len(a):] = [x].
在列表末尾添加一个元素，等同于 a[len(a):] = [x] 。
Extend the list by appending all the items in the given list; equivalent to a[len(a):] = L.
通过添加指定列表的所有元素扩展列表，等同于 a[len(a):] = L 。
Insert an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).
在指定位置插入一个元素。 第一个参数是将要插入在前面的元素的索引，因此 a.insert(0, x) 会插入在列表头部，同样 a.insert(len(a), x) 就等同于 a.append(x) 。
Remove the first item from the list whose value is x. It is an error if there is no such item.
删除列表中值为 x 的第一个元素。 如果不存在这样的元素则引发错误。
Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list. (The square brackets around the i in the method signature denote that the parameter is optional, not that you should type square brackets at that position. You will see this notation frequently in the Python Library Reference.)
删除列表中指定位置元素并返回它（指元素值）。 如果省略索引， a.pop() 会删除并返回列表中的最后一个元素。 （方法中围绕 i 的方括号表示此参数是可选的，而不是你也要那个位置输入方括号。你会在Python库参考手册中经常看到此用法。）
Return the index in the list of the first item whose value is x. It is an error if there is no such item.
返回列表中值为 x 的第一个元素的索引。 如果不存在这样的元素则引发错误。
Return the number of times x appears in the list.
返回列表中元素 x 出现的次数。
Sort the items of the list, in place.
对列表中的元素进行排序。
Reverse the elements of the list, in place.
反转列表中的元素。
An example that uses most of the list methods:
一个演示列表大多数方法的列子：
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
The list methods make it very easy to use a list as a stack, where the last element added is the first element retrieved (“last-in, first-out”). To add an item to the top of the stack, use append(). To retrieve an item from the top of the stack, use pop() without an explicit index. For example:
列表方法使其可以很容易的实现堆栈功能，即最后添加的元素是第一个被返回的元素（LIFO）。 要想在堆栈顶部添加一个元素，可以使用 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]
You can also use a list conveniently as a queue, where the first element added is the first element retrieved (“first-in, first-out”). To add an item to the back of the queue, use append(). To retrieve an item from the front of the queue, use pop() with 0 as the index. For example:
你也可以方便的使用列表实现一个队列，即第一个被添加的元素第一个被返回（FIFO）。 想要在队列尾部添加一个元素，可以使用 append() 方法。 想要返回队列首部的元素，可以使用指定参数为0的 pop() 方法（即 list.pop(0) ）。 例如：
>>> queue = ["Eric", "John", "Michael"]
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.pop(0)
'Eric'
>>> queue.pop(0)
'John'
>>> queue
['Michael', 'Terry', 'Graham']
List comprehensions provide a concise way to create lists from sequences. Common applications are to make lists where each element is the result of some operations applied to each member of the sequence, or to create a subsequence of those elements that satisfy a certain condition.
列表推导式为从序列中创建列表提供了一个简单的方法。 普通的应用程式通过将一些操作应用于序列的每个成员并通过返回的元素创建列表，或者通过满足特定条件的元素创建子序列。
A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a list resulting from evaluating the expression in the context of the for and if clauses which follow it. If the expression would evaluate to a tuple, it must be parenthesized.
列表推导式由包含一个表达式的括号组成，表达式后面跟随一个 for 子句，之后可以有零或多个 for 或 if 子句。 结果是一个列表，由表达式依据其后面的 for 和 if 子句上下文计算而来的结果构成。 如果希望表达式产生一个元组，则必须用括号包裹。
Here we take a list of numbers and return a list of three times each number:
这里我们通过将列表中的每个元素乘3返回一个新列表：
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
Now we get a little fancier:
现在我们玩点小花样：
>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
Here we apply a method call to each item in a sequence:
下面我们对序列中的每个元素应用方法：
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
Using the if clause we can filter the stream:
我们还可以使用 if 子句进行过滤：
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
Tuples can often be created without their parentheses, but not here:
经常可以不适用括号创建元组，但这里不行：
>>> [x, x**2 for x in vec] # error - parens required for tuples
File "<stdin>", line 1, in ?
[x, x**2 for x in vec]
^
SyntaxError: invalid syntax
>>> [(x, x**2) for x in vec]
[(2, 4), (4, 16), (6, 36)]
Here are some nested for loops and other fancy behavior:
这里有一个嵌套循环和其他小技巧的演示：
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
List comprehensions can be applied to complex expressions and nested functions:
列表推导式亦可以使用复杂的表达式和嵌套函数：
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
If you’ve got the stomach for it, list comprehensions can be nested. They are a powerful tool but – like all powerful tools – they need to be used carefully, if at all.
如果你已对此抱有兴趣，是的，列表推导式可以嵌套。 他们是一种功能强大的工具，但和所有功能强大的工具一样，如果确实需要使用，你需要格外谨慎。
Consider the following example of a 3x3 matrix held as a list containing three lists, one list per row.
考虑以下由包含三个列表的列表构成的3x3矩阵，每行一个列表。
>>> mat = [
... [1, 2, 3],
... [4, 5, 6],
... [7, 8, 9],
... ]
Now, if you wanted to swap rows and columns, you could use a list comprehension.
现在，如果想要交换行和列你应该使用列表推导式。
>>> print([[row[i] for row in mat] for i in [0, 1, 2]])
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
Special care has to be taken for the nested list comprehension:
To avoid apprehension when nesting list comprehensions, read from right to left.
嵌套 列表推导式需要特别注意：
当嵌套列表推导式时，想要避免麻烦就从右到左读取。
A more verbose version of this snippet shows the flow explicitly:
下面是一个关于这个片段（指上文中的嵌套列表推导式）更冗长的清晰版本：
for i in [0, 1, 2]:
for row in mat:
print(row[i], end="")
print()
In real world, you should prefer built-in functions to complex flow statements. The zip() function would do a great job for this use case:
在实际中，你应该更喜欢使用内置函数组成复杂流程语句。 对此种情况 zip() 函数将会做的更好：
>>> list(zip(*mat))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
See Unpacking Argument Lists 拆分参数列表 for details on the asterisk in this line.
更多关于本行中使用的星号（*）的说明，参考 Unpacking Argument Lists 拆分参数列表 章节。
There is a way to remove an item from a list given its index instead of its value: the del statement. This differs from the pop() method which returns a value. The del statement can also be used to remove slices from a list or clear the entire list (which we did earlier by assignment of an empty list to the slice). For example:
有一个方法可以使用索引而不是值从列表中删除一个元素： 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 can also be used to delete entire variables:
del 也可以用来删除整个变量：
>>> del a
Referencing the name a hereafter is an error (at least until another value is assigned to it). We’ll find other uses for del later.
此后，任何对 a 名字的引用就会出错（至少在对它赋其它值前）。 稍后，我们会发现 del 的其他用法。
We saw that lists and strings have many common properties, such as indexing and slicing operations. They are two examples of sequence data types (see Sequence Types — str, bytes, bytearray, list, tuple, range). Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the tuple.
我们知道列表和字符串具有很多通用的属性，例如索引和切片操作。 他们是 序列 数据类型（参考 Sequence Types — str, bytes, bytearray, list, tuple, range ）的两个例子。 因为Python是一中不断进化的语言，也可能添加其他序列数据类型（支持）。 这里是另一种标准序列数据类型： 元组（tuple） 。
A tuple consists of a number of values separated by commas, for instance:
元组由若干逗号分隔的值组成，例如：
>>> 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))
As you see, on output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly; they may be input with or without surrounding parentheses, although often parentheses are necessary anyway (if the tuple is part of a larger expression).
如你所见，元组输出时总是用括号包裹的，这便于正确的表达嵌套元组。 在输入时两边的括号是可选的，但不论如何括号通常是必须得（如果元组是更大的表达式的一部分）。
Tuples have many uses. For example: (x, y) coordinate pairs, employee records from a database, etc. Tuples, like strings, are immutable: it is not possible to assign to the individual items of a tuple (you can simulate much of the same effect with slicing and concatenation, though). It is also possible to create tuples which contain mutable objects, such as lists.
元组有很多用处。 例如：(x, y)坐标点，数据库中员工的记录，等等。 像字符串一样，元组是不可变的：不能给元组的独立元素赋值（尽管你可以使用切片和连接来模仿这些功能）。 也可以使用包含可变对象创建元组，比如列表。
A special problem is the construction of tuples containing 0 or 1 items: the syntax has some extra quirks to accommodate these. Empty tuples are constructed by an empty pair of parentheses; a tuple with one item is constructed by following a value with a comma (it is not sufficient to enclose a single value in parentheses). Ugly, but effective. For example:
一个特殊的问题就是构造包含0或1个元素的元组：为了适用此情况，语法上需要一个额外的做法。 空元组由一对空括号构成，包含一个元素的元组需要在其后面跟一个逗号来构成（在括号中包含一个值是不够得）。 丑陋，但这有效。比如：
>>> empty = ()
>>> singleton = 'hello', # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)
The statement t = 12345, 54321, 'hello!' is an example of tuple packing: the values 12345, 54321 and 'hello!' are packed together in a tuple. The reverse operation is also possible:
t = 12345, 54321, 'hello!' 语句是 元组封装 的一个示例：值 12345 、 54321 和 hello! 被封装进一个元组。 其逆反操作也是可以的：
>>> x, y, z = t
This is called, appropriately enough, sequence unpacking and works for any sequence on the right-hand side. Sequence unpacking requires that there are as many variables on the left side of the equals sign as there are elements in the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking.
这非常适合称为 序列拆分 ，并且对所有的右操作序列都可以工作。 序列拆分要求等号左边的变量数目和序列中的元素数目要相同。 注意：多重赋值其实就是元组封装和序列拆分的结合。
Python also includes a data type for sets. A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.
Python同样包含一种 集合 数据类型。 集合就是一个包含不同元组的无序集。 基本功能包括关系测试和剔除重复记录。 集合对象同样支持数学操作，像联合（union）、交（intersection）、差（difference）和对称差（symmetric difference）。
Curly braces or the set() function can be use to create sets. Note: To create an empty set you have to use set(), not {}; the latter creates an empty dictionary, a data structure that we discuss in the next section.
大括号或 set() 函数可以用来创建集合。 注意：想要创建空集合，你必须使用 set() 而不是 {} 。后者用于创建空字典，我们在下一节中介绍的一种数据结构。
Here is a brief demonstration:
一下是简单的演示：
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)
{'orange', 'banana', 'pear', 'apple'}
>>> fruit = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket) # create a set without duplicates
>>> fruit
{'orange', 'pear', 'apple', 'banana'}
>>> fruit = {'orange', 'apple'} # {} syntax is equivalent to [] for lists
>>> fruit
{'orange', 'apple'}
>>> 'orange' in fruit # fast membership testing
True
>>> 'crabgrass' in fruit
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 either a or b
{'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'}
Like for lists, there is a set comprehension syntax:
类似 for lists ，这里有一种集合推导式语法：
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
Another useful data type built into Python is the dictionary (see Mapping Types — dict). Dictionaries are sometimes found in other languages as “associative memories” or “associative arrays”. Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by keys, which can be any immutable type; strings and numbers can always be keys. Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key. You can’t use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like append() and extend().
另一种使用的Python内建数据类型是 字典 （参考 Mapping Types — dict ）。 字典有时在其他语言中称为“关联记忆”（ associative memories ）或“关联数组”（ associative arrays ）。 与序列不同，序列是以连续的数字作为索引，而字典是以 关键字 作为索引。 关键字可以是任意不可变类型，数字和字符串都可以作为关键字。 如果元组只包含数字、字符串或元组，那么也可以作为关键字使用。 如果元组直接或间接包含可变对象，那么就不可以作为关键字使用。 你不能将列表作为关键字（使用），因为列表可以通过索引赋值、切片赋值或 append() 和 extend() 方法改变。
It is best to think of a dictionary as an unordered set of key: value pairs, with the requirement that the keys are unique (within one dictionary). A pair of braces creates an empty dictionary: {}. Placing a comma-separated list of key:value pairs within the braces adds initial key:value pairs to the dictionary; this is also the way dictionaries are written on output.
最好将字典理解成一个无序的 key: value 对（集合），其中关键字必须是互不相同的（在统一字典中）。 可以用一对大括号 {} 会创建一个空字典。 在大括号中放置用逗号分隔的 key: value 对将给字典添加初始化值，这也是字段输出的方式。
The main operations on a dictionary are storing a value with some key and extracting the value given the key. It is also possible to delete a key:value pair with del. If you store using a key that is already in use, the old value associated with that key is forgotten. It is an error to extract a value using a non-existent key.
字典主要的操作就是根据关键字来存储或获取值。 同样可以使用 del 删除 key: value 对。 如果你使用一个已存在的关键字存储（新值），旧的值将被覆盖。 试图使用一个不存在的关键字获取值将导致错误。
Performing list(d.keys()) on a dictionary returns a list of all the keys used in the dictionary, in arbitrary order (if you want it sorted, just use sorted(d.keys()) instead). [1] To check whether a single key is in the dictionary, use the in keyword.
对一个字典执行 list(d.keys()) 将返回一个字典中所有关键字组成的无序列表（如果你想要排序，只需使用 sorted(d.keys()) ）。 [1] 使用 in 关键字（指Python语法）可以检查字典中是否存在某个关键字（指字典）。
Here is a small example using a dictionary:
这里是使用字典的一个小示例：
>>> 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
The dict() constructor builds dictionaries directly from sequences of key-value pairs:
dict() 构造函数可以直接从 key-value 对中创建字典：
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
In addition, dict comprehensions can be used to create dictionaries from arbitrary key and value expressions:
此外，字典推导式可以从任意的键值表达式中创建字典：
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments:
如果关键字都是简单的字符串，有时通过关键字参数指定 key-value 对更为方便：
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
When looping through dictionaries, the key and corresponding value can be retrieved at the same time using the items() method.
当遍历字典时，关键字及其对应的值可以使用 items() 方法同时获得。
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
When looping through a sequence, the position index and corresponding value can be retrieved at the same time using the enumerate() function.
当遍历一个序列时，位置索引及其对应的值可以使用 enumerate() 函数同时获取。
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
To loop over two or more sequences at the same time, the entries can be paired with the zip() function.
想要同时遍历两个或更多序列，可以使用 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.
To loop over a sequence in reverse, first specify the sequence in a forward direction and then call the reversed() function.
想要反序遍历一个序列，首先以正序指定这个序列，然后对其调用 reversed() 函数。
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
To loop over a sequence in sorted order, use the sorted() function which returns a new sorted list while leaving the source unaltered.
想要按顺序遍历一个序列，使用 sorted() 函数返回一个新的排序列表，这不会改变原序列。
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
The conditions used in while and if statements can contain any operators, not just comparisons.
在 while 和 if 语句中使用的条件可以是任何操作符，不仅仅是比较运算符。
The comparison operators in and not in check whether a value occurs (does not occur) in a sequence. The operators is and is not compare whether two objects are really the same object; this only matters for mutable objects like lists. All comparison operators have the same priority, which is lower than that of all numerical operators.
比较操作符 in 和 not in 检查某个值是否存在（不存在）于某个序列中。 操作符 is 和 is not 比较两个对象是否是同一个对象，这只和类似列表这样的可变对象有关。 所有的比较操作符具有相同的优先级，比所有的数值操作符低。
Comparisons can be chained. For example, a < b == c tests whether a is less than b and moreover b equals c.
比较操作可以串联（使用）。 列如： a < b == c 会检查 a 是否小于 b ，并且 b 是否等于 c 。
Comparisons may be combined using the Boolean operators and and or, and the outcome of a comparison (or of any other Boolean expression) may be negated with not. These have lower priorities than comparison operators; between them, not has the highest priority and or the lowest, so that A and not B or C is equivalent to (A and (not B)) or C. As always, parentheses can be used to express the desired composition.
比较操作可以混合使用逻辑操作符 and 和 or ，并且比较的结果（或者任何其他逻辑表达式）可以使用 not 操作取反。 这些操作符（指 and , or 和 not ）的优先级低于比较操作符，在它们之中 not 具有最高的优先级， or 则最低。 所以 A and not B or C 与 (A and (not B)) or C 是等价的。 当然，可以使用括号表达期望的比较操作。
The Boolean operators and and or are so-called short-circuit operators: their arguments are evaluated from left to right, and evaluation stops as soon as the outcome is determined. For example, if A and C are true but B is false, A and B and C does not evaluate the expression C. When used as a general value and not as a Boolean, the return value of a short-circuit operator is the last evaluated argument.
逻辑操作符 and 和 or 也被称作 短路 操作符。 从左到右计算它们的参数，一旦结果确定就停止。 例如：如果 A 和 C 是真，但 B 是假， A and B and C 就不会计算 C 表达式的值。 当作为一个普通的值而非逻辑值时，短路操作的返回值是最后一个被计算的参数。
It is possible to assign the result of a comparison or other Boolean expression to a variable. For example:
可以将比较操作或其他逻辑表达式的结果赋值给一个变量。例如：
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
Note that in Python, unlike C, assignment cannot occur inside expressions. C programmers may grumble about this, but it avoids a common class of problems encountered in C programs: typing = in an expression when == was intended.
注意：在Python中与C语言不同，赋值操作不能出现在表达式中。 C程序员可能会对此抱怨，但是它避免了一个在C程序中经常遇到的典型的问题：想要在一个表达式中使用 == 操作时却输入了 = 。
Sequence objects may be compared to other objects with the same sequence type. The comparison uses lexicographical ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted. If two items to be compared are themselves sequences of the same type, the lexicographical comparison is carried out recursively. If all items of two sequences compare equal, the sequences are considered equal. If one sequence is an initial sub-sequence of the other, the shorter sequence is the smaller (lesser) one. Lexicographical ordering for strings uses the Unicode codepoint number to order individual characters. Some examples of comparisons between sequences of the same type:
相同的序列对象可以进行比较操作。 比较操作按 字典序 进行：首先比较前两个元素，如果它们不同就会决定比较的结果； 如果它们相等就会比较下两个元素，依次类推，直到两个序列末尾。 如果被比较的两个元素也为相同类型的序列对象，就对其作递归字典序比较。 如果两个序列的所有元素都相等，那么这两个序列就被认为是相等的。 如果一个序列是另一个序列的初始子序列，较短的序列就小于另外一个。 字符串的字典序按照单个字符的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)
Note that comparing objects of different types with < or > is legal provided that the objects have appropriate comparison methods. For example, mixed numeric types are compared according to their numeric value, so 0 equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, the interpreter will raise a TypeError exception.
注意：只要对象含有合适的比较方法，不同类型对象之间通过 < 或 > 的比较是合法的。 例如，不同数字类型会根据他们的值进行比较，因此0等于0.0，等等。 此外，如果没有确定的排序，解释器将会抛出 TypeError 异常。
Footnotes
| [1] | (1, 2) Calling d.keys() will return a dictionary view object. It supports operations like membership test and iteration, but its contents are not independent of the original dictionary – it is only a view. 调用 d.keys() 会返回一个 dictionary view 对象。 它支持类似关系测试和迭代的操作，但是它并非原始字典的副本——它仅是一个 视图 。 |