[譯]The Python Tutorial#Data Structures

5.1 Data Structures

本章節(jié)詳細(xì)介紹之前介紹過(guò)的一些內(nèi)容，并且也會(huì)介紹一些新的內(nèi)容疹娶。

5.1 More on Lists

列表數(shù)據(jù)類型擁有更多方法伴栓，以下是列表對(duì)象的所有方法：

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

• list.extend(iterable)
  添加可迭代對(duì)象中所有的項(xiàng)來(lái)擴(kuò)展列表雨饺，等同于a[len(a):] = iterable

• list.insert(i, x)
  在指定位置插入項(xiàng)钳垮。第一個(gè)參數(shù)為元素索引，新的項(xiàng)會(huì)在這個(gè)索引之前插入额港，因此a.insert(0, x)會(huì)在列表最前面插入饺窿，a.insert(len(a), x)等同于a.append(x)。

• list.remove(x)
  從列表中移除值為x的第一個(gè)項(xiàng)移斩，若x不存在肚医，方法拋出異常(ValueError異常)

• list.pop([i])
  從列表中移除指定位置的項(xiàng)并返回绢馍。如果沒(méi)有指定索引，a.pop()移除并返回列表中最后一個(gè)項(xiàng)肠套。（方法簽名中包裹i的方括號(hào)表示參數(shù)是可選的舰涌，而不是在這個(gè)位置寫一個(gè)方括號(hào)。這種記號(hào)法在Python Library Reference中經(jīng)常用到）

• list.clear()
  移除列表中的所有項(xiàng)你稚，等同于del a[:]

• list.index(x[, start[, end]])
  返回第一個(gè)值為x的項(xiàng)的基于0的索引瓷耙，如果x不存在拋出ValueError異常。
  可選參數(shù)start和end被解釋為切片記號(hào)法入宦，用來(lái)將搜索限制在列表特定的子列表內(nèi)哺徊。返回的索引是相對(duì)于完整列表索引室琢，而不是相對(duì)于start參數(shù)的乾闰。

• list.count(x)
  返回列表中x出現(xiàn)的次數(shù)

• list.sort(key=None, reverse=False)
  對(duì)列表的所有項(xiàng)進(jìn)行排序（參數(shù)用來(lái)自定義排序，參見sorted()獲取更多信息）

• list.reverse()
  反轉(zhuǎn)列表元素

• 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的這樣涯肩，只改變了列表但是沒(méi)有返回值打印病苗，它們返回默認(rèn)的None^[1]。這是Python可變數(shù)據(jù)結(jié)構(gòu)適用的設(shè)計(jì)原則咬展。

5.1.1 Using Lists as Stacks

列表方法使得將其用作棧非常容易破婆，棧中最后一個(gè)加入的元素第一個(gè)被釋放（后進(jìn)先出）祷舀。使用append()方法添加元素到棧頂裳扯，使用不帶參數(shù)的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

將列表用作隊(duì)列也是可能的哟忍，隊(duì)列中先添加的元素先釋放（先進(jìn)先出）锅很；然而爆安，這樣用列表效率非常不高褐奥。因?yàn)樵诹斜砟┪蔡砑雍腿〕鲈睾芸烨寺耄窃诹斜黹_頭插入或者刪除元素很慢（因?yàn)椴坏貌粚⑵渌性匚灰埔晃唬?/p>

經(jīng)過(guò)特殊設(shè)計(jì)的collections.deque在首尾兩端添加和刪除元素都很快呜笑，可以使用它來(lái)實(shí)現(xiàn)隊(duì)列。示例：

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

列表推導(dǎo)式為創(chuàng)建列表提供了簡(jiǎn)潔方式母赵。一般的應(yīng)用方式是：創(chuàng)建新列表营罢，列表元素是對(duì)其他序列或者可迭代對(duì)象操作的結(jié)果张足；或者創(chuàng)建元素滿足特定條件的子序列。

假如希望創(chuàng)建一個(gè)平方列表：

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

注意以上創(chuàng)建（或者重寫）了名為x的變量碉咆，該變量在循環(huán)結(jié)束之后仍然存在疫铜。使用以下方法可創(chuàng)建沒(méi)有任何副作用的平方列表：

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

或者席揽，等用于：

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

這種方式更加簡(jiǎn)潔和易讀幌羞。

跟隨著for子句属桦，緊接零個(gè)或者多個(gè)for子句或者if子句的表達(dá)式再加上中括號(hào)，構(gòu)成了列表推導(dǎo)式系谐。其返回結(jié)果是一個(gè)新的列表蔚鸥，列表的元素是表達(dá)式中for和if子句的計(jì)算結(jié)果。例如混聊，以下列表推導(dǎo)式組合兩個(gè)列表中不相等的元素：

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

等價(jià)于：

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

注意上面兩個(gè)代碼段中for和if語(yǔ)句的順序是相同的。

如果表達(dá)式是一個(gè)元組（如上所示的(x, y)）咳胃，必須將其加上括號(hào)展懈。

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

列表推導(dǎo)式可以包含復(fù)雜的表達(dá)式甚至嵌套函數(shù)：

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

列表推導(dǎo)式開頭的表達(dá)式可以是任意表達(dá)式睡毒，包括另一個(gè)列表推導(dǎo)式供搀。

考慮以下示例，一個(gè)包含3個(gè)長(zhǎng)度為4的列表的列表實(shí)現(xiàn)了3x4的矩陣：

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

以下列表推導(dǎo)式反轉(zhuǎn)行列：

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

前面的章節(jié)提到军浆，嵌套的列表推導(dǎo)式是在其后跟隨的for的上下文中求值的乒融，因此這個(gè)示例等同于：

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

在實(shí)踐中，應(yīng)該選擇built-in函數(shù)來(lái)復(fù)合流程語(yǔ)句申钩。在以上的用例中zip()函數(shù)更有用：

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

參見 Unpacking Argument Lists了解關(guān)于上面*使用的更多詳細(xì)信息撒遣。

5.2 The del statement

在提供列表索引而不是值的情況下义黎，有一種方法可以移除列表中的元素：del語(yǔ)句。這種方式與返回值的pop()方法不同狐蜕。del語(yǔ)句也可以用來(lái)移除部分列表或者清除整個(gè)列表（之前使用將空的列表賦值給列表片段的方式實(shí)現(xiàn)）层释。示例：

>>> 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也可以用來(lái)刪除整個(gè)變量：

>>> del a

此后引用名字a會(huì)拋出異常（至少在其他值賦值給名字a之前）贡羔。接下來(lái)會(huì)有更多del的使用

5.3 Tuples and Sequences

列表和字符串有很多常用屬性治力，比如索引和切片操作。它們是序列數(shù)據(jù)類型（參見 Sequence Types - list, tuple, range）的兩種马澈。Python是一種不斷進(jìn)化的語(yǔ)言，其他的序列類型也可以加入勤婚。元組是另一種標(biāo)準(zhǔn)的序列數(shù)據(jù)類型。

元組包含若干由逗號(hào)分隔的值祝迂，示例：

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

可見型雳，輸出的元組總是放在圓括號(hào)中，以便于嵌套的元組可以被正確解析冤荆；雖然圓括號(hào)總是必須的（如果元組是其他更大表達(dá)式的一部分）匙赞，但是在輸入元組的時(shí)候可以選擇使用圓括號(hào)。不能對(duì)元組的單個(gè)項(xiàng)賦值欧宜，但是可以創(chuàng)建包含如列表的可變對(duì)象的元組冗茸。

雖然元組和列表有些相似夏漱，但是他們通常以不同的目的挂绰，用于不同的場(chǎng)景葵蒂。元組是不可變的秦士，通常包含不同類型的元素隧土，可以通過(guò)拆包操作（參見后續(xù)章節(jié)）或者索引（或者當(dāng)元組是命名元組時(shí)曹傀，甚至可以通過(guò)屬性來(lái)訪問(wèn)）來(lái)訪問(wèn)。列表是可變的落萎，通常其元素也是不同類型的练链，可以通過(guò)對(duì)列表的迭代訪問(wèn)元素媒鼓。

構(gòu)建包含零個(gè)或者1個(gè)項(xiàng)的元組比較特殊：一種額外的奇怪語(yǔ)法可以適用于這種情況疚沐。空元組由一對(duì)空的圓括號(hào)創(chuàng)建究流；一個(gè)元素的元組由一個(gè)跟著逗號(hào)的值創(chuàng)建（在圓括號(hào)中放入單個(gè)值是不夠的芬探。譯注：這種情況：(1)表示整數(shù)而不是元組偷仿，使用(1, )表示元組也是可行的）卡骂。丑陋但是有效全跨。示例：

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

語(yǔ)句t = 12345, 54321, 'hello!'是封裝元組的一個(gè)示例：值12345, 54321和hello!被封裝到了一個(gè)元組中。逆向操作也是可行的：

>>> x, y, z = t

非常恰當(dāng)?shù)胤Q之為序列解包挪钓，適用于任何在等號(hào)右邊的序列（譯注：等號(hào)右操作數(shù)）。序列解包要求等號(hào)左邊待賦值的變量數(shù)量與序列包含元素?cái)?shù)目相同馏予。注意多重賦值只是封裝元組和序列解包的結(jié)合（譯注：多重賦值：i, j = 1, 2）

5.4 Set

Python也包含實(shí)現(xiàn)了集合的數(shù)據(jù)類型。集合是無(wú)序不重復(fù)的元素集蛹尝。基本功能包括成員關(guān)系測(cè)試和重復(fù)實(shí)體消除陨收。集合對(duì)象也支持并集鸵赖，交集，差集以及對(duì)稱差集等數(shù)學(xué)操作拄衰。

可以使用花括號(hào)和set()函數(shù)創(chuàng)建集合它褪。謹(jǐn)記：創(chuàng)建空集合必須使用set函數(shù)，不能使用{}翘悉，后者用于創(chuàng)建空字典茫打。

以下是簡(jiǎn)單示范：

>>> 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'}

與列表推導(dǎo)式相同，Python也支持集合推導(dǎo)式：

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

5.5 Dictionaries

另一個(gè)內(nèi)嵌入Python中的數(shù)據(jù)結(jié)構(gòu)是字典（參見 Mapping Types - dict）。字典在其他一些語(yǔ)言中被稱為“聯(lián)合存儲(chǔ)”或者“聯(lián)合數(shù)組”老赤。與序列不同，序列以一系列數(shù)字作索引，字典以鍵作索引，鍵可以是任何不可變類型；通常使用字符串和數(shù)字作為鍵。只包含字符串孵坚，數(shù)字或者其他元組的元組也可以作為鍵扛伍；直接或者間接包含可變對(duì)象的元組不能作為鍵鼎文。因?yàn)榱斜砜梢允褂盟饕x值撑帖，切片賦值或者append()以及extend()等方法改變自身，所以列表不能作為鍵罐监。

最好的理解字典的方式是將其認(rèn)為是鍵值對(duì)的無(wú)序集合，同一集合中鍵唯一。一對(duì)花括號(hào)創(chuàng)建空字典：{}趾娃。在花括號(hào)中放置由逗號(hào)分隔鍵值對(duì)列表可以為字典添加初始鍵值對(duì)评架；這也是字典輸出的格式挣磨。

字典提供的主要操作是：使用鍵存儲(chǔ)值以及取值廊宪》怕瑁可以使用del刪除一個(gè)鍵值對(duì)屯耸。如果使用已經(jīng)存在的鍵來(lái)存儲(chǔ)值，那么與鍵關(guān)聯(lián)的舊值會(huì)被重寫患雏。使用不存在的鍵來(lái)取值會(huì)拋出異常。

在字典上執(zhí)行list(d.keys())返回字典所有鍵的無(wú)序列表（使用sorted(d.keys())使其有序）^[2]瑰艘。使用關(guān)鍵字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()構(gòu)造器直接使用鍵值對(duì)序列構(gòu)造字典：

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

此外，字典推導(dǎo)式可以從任意鍵值表達(dá)式中創(chuàng)建字典：

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

當(dāng)鍵是簡(jiǎn)單的字符串時(shí)，可以使用關(guān)鍵字參數(shù)來(lái)指定鍵值對(duì)：

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

5.6 Looping Techniques

遍歷字典時(shí)绵跷，使用items()方法可以同時(shí)檢索鍵及其對(duì)應(yīng)的值埋合。

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

遍歷序列時(shí)辫呻，使用enumerate()函數(shù)可以同時(shí)檢索位置索引及其對(duì)應(yīng)的值：

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

同時(shí)遍歷兩個(gè)或者更多序列時(shí)踩萎，使用zip()函數(shù)可以將元素組成對(duì)：

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

需要逆序遍歷序列時(shí)锭碳，首先指定一個(gè)正向的序列，然后調(diào)用reversed()函數(shù)：

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

需要以特定順序遍歷序列時(shí)锹杈，使用sorted()函數(shù)返回新的有序序列喻圃，原序列不會(huì)改動(dòng)：

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

有時(shí)需要在遍歷序列的同時(shí)修改序列，創(chuàng)建新的替代序列更加簡(jiǎn)單并且安全：

>>> 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語(yǔ)句中使用的條件可以包含任意操作符，不僅僅是比較運(yùn)算符志膀。

比較運(yùn)算符in和not in檢查指定值在序列中是否存在（不存在）熙宇。操作符is和is not比較兩個(gè)對(duì)象是否真正相同（內(nèi)存地址比較）；這兩個(gè)操作符只對(duì)像列表那樣的可變對(duì)象重要溉浙。所有的比較運(yùn)算符擁有相同的優(yōu)先級(jí)奇颠，并且都低于數(shù)字運(yùn)算符。

比較運(yùn)算符可以鏈接起來(lái)放航。例如a < b == c測(cè)試b是否大于a同時(shí)b等于c（譯注：同其他高級(jí)語(yǔ)言的：a < b and b == c）

比較運(yùn)算符可以結(jié)合布爾運(yùn)算符and和or使用，比較的結(jié)果（或者其他任何布爾表達(dá)式）可以使用not來(lái)作否定圆裕。and,or和not優(yōu)先級(jí)比比較運(yùn)算符低广鳍；其中not的優(yōu)先級(jí)最高而or優(yōu)先級(jí)最低，因此A and not B or C等同于(A and (not B)) or C吓妆。一如既往赊时，可以使用圓括號(hào)表述想要的優(yōu)先級(jí)順序。

布爾運(yùn)算符and和or號(hào)稱短路運(yùn)算符：它們的參數(shù)從左向右求值行拢，一旦結(jié)果確定祖秒，求值過(guò)程就會(huì)停止。例如舟奠，如果A和C是真竭缝，B是假，A and B and C不會(huì)對(duì)表達(dá)式C求值（譯注：A and B為假沼瘫，已經(jīng)確定了整個(gè)表達(dá)式A and B and C的值為假抬纸，表達(dá)式C的值對(duì)結(jié)果不會(huì)造成影響，因此不會(huì)對(duì)其求值）耿戚。當(dāng)用作一般值而不是布爾值時(shí)湿故，短路操作的返回值是最后一個(gè)求值的參數(shù)。

可以將比較運(yùn)算或者布爾表達(dá)式賦值給變量：

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

注意在Python中膜蛔，賦值操作不能像C語(yǔ)言一樣在表達(dá)式內(nèi)發(fā)生坛猪。C程序員也許會(huì)抱怨，但是這避免了C程序中遇到的一個(gè)普遍問(wèn)題：當(dāng)想要表示==時(shí)候可能誤用了=皂股。

5.8 Comparing Sequences and Other Types

相同序列類型之間的序列對(duì)象可以相互比較墅茉。比較使用字典序：首先比較兩個(gè)序列的第一項(xiàng)，如果它們不同，比較運(yùn)算的結(jié)果就可確定了躁锁；如果它們不同纷铣，比較兩個(gè)序列中的下一個(gè)項(xiàng)，以此類推战转，直到其中一個(gè)序列耗盡搜立。如果被比較的兩個(gè)項(xiàng)是同一類型的，那么使用字典序遞歸比較槐秧。如果兩個(gè)序列的所有項(xiàng)都是相等的啄踊，那么他們相等。如果其中一個(gè)序列是另一個(gè)序列的子序列刁标，那么短的一個(gè)序列較小颠通。字符串的字典序使用Unicode代碼點(diǎn)數(shù)字排序單個(gè)字符。

以下是相同類型的序列對(duì)象之間的比較示例：

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

注意當(dāng)不同類型對(duì)象之間有合適的比較方式時(shí)膀懈，使用<或者>比較不同類型的對(duì)象是合法的顿锰。例如，混合數(shù)字類型之間的比較是根據(jù)其數(shù)字上的值启搂，0等于0.0硼控。否則，解釋器會(huì)拋出TypeException異常胳赌，而不是隨意提供結(jié)果

Footnotes

<span id="jump1">[1] </span> 其他語(yǔ)言可能返回改變后的對(duì)象牢撼，從而允許方法鏈接，如：d->insert("a")>remove("b")->sort();
<span id="jump2">[2] </span> 調(diào)用d.keys()返回一個(gè)dictionary view對(duì)象疑苫。從而支持如成員關(guān)系測(cè)試和迭代之類的操作熏版，但是其內(nèi)容并不是獨(dú)立于原始字典的，只是一個(gè)視圖