這一章節(jié)介紹你之前可能學(xué)習(xí)過(guò)的部分內(nèi)容，同時(shí)添加了一些新的內(nèi)容。

更多關(guān)于列表的內(nèi)容

列表這種數(shù)據(jù)結(jié)構(gòu)有很多方法，如下是一個(gè)列表對(duì)象的全部方法：

list.append(x)

在列表的末尾插入元素x,等同于 a[len(a):] = [x]

list.extend(L)

將L中的全部元素插入到列表的末尾，以擴(kuò)展該列表. 等同于a[len(a):] = L.

list.insert(i,x)

將一個(gè)元素插入到指定位置。第一個(gè)參數(shù)是待插入元素的前一個(gè)元素的位置，所以,a.insert(0,x) 在列表的最前邊插入，而a.insert(len(a),x)等同于a.append(x)

list.remove(x)

從列表中移除第一個(gè)值為x的元素。如果沒(méi)有這樣的元素的話，該命令將會(huì)報(bào)錯(cuò)。

list.pop([i])

移除列表中給定位置的元素，并且返回它。如果未指定位置，a.pop()將移除并返回列表中的最后一個(gè)值。（方法中i周?chē)闹欣ㄌ?hào)表面該參數(shù)是可選的，而不是指你需要在這個(gè)位置輸入一個(gè)中括號(hào)，在 Python 的庫(kù)文檔中，你會(huì)經(jīng)常遇到這種表示）。

list.clear()

從列表中移除所有元素，等同于del a[:]

list.index(x)

返回列表中第一個(gè)值為i的元素的序號(hào)，如果沒(méi)有這樣的元素，該命令將會(huì)報(bào)錯(cuò).

list.count(x)

返回列表中x出現(xiàn)的次數(shù)。

list.sort()

對(duì)該列表進(jìn)行排序.

list.reverse()

翻轉(zhuǎn)列表中的元素.

list.copy()

返回該列表的一個(gè)淺拷貝，等同于a[:]

一個(gè)使用了大多數(shù)列表中方法的例子

>>> 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]
>>> a.pop()
1234.5
>>> a
[-1, 1, 66.25, 333, 333]

你可能已經(jīng)注意到，諸如insert,remove,sort這樣僅僅修改列表的方法并沒(méi)有打印出返回值，它們返回一個(gè)默認(rèn)的None，參考腳注[1]，這是 Python 中所有可變的數(shù)據(jù)結(jié)構(gòu)的一個(gè)設(shè)計(jì)準(zhǔn)則。

將列表作為棧來(lái)使用

列表的方法使得將列表作為棧來(lái)使用是非常容易的,棧是一種后進(jìn)入的元素最先被取出 (last-in, first-out) 的數(shù)據(jù)結(jié)構(gòu)。要將一個(gè)元素加入棧頂，使用append()方法，要將棧頂元素取出，使用無(wú)特定序號(hào)的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]

將列表作為隊(duì)列來(lái)使用

將列表用作隊(duì)列同樣是可以的，隊(duì)列是一種先進(jìn)入的元素被先取出 (first-in,first-out) 的數(shù)據(jù)結(jié)構(gòu)。然而，列表并不足以滿(mǎn)足這一要求，因?yàn)樵诹斜淼哪┪蔡砑雍蛷棾鰯?shù)據(jù)都是（相對(duì)）快的，但是在列表的頭部插入或彈出卻（比較）慢（因?yàn)槠渌脑匾灰粋€(gè)個(gè)地移動(dòng)）。

要實(shí)現(xiàn)一個(gè)隊(duì)列，可以使用collections.deque，它被設(shè)計(jì)用來(lái)實(shí)現(xiàn)從兩端都可以快速添加和彈出的方法。例如

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

列表推導(dǎo)式

列表推導(dǎo)式提供了一個(gè)創(chuàng)建列表的具體的方式，大多數(shù)應(yīng)用程序建立的列表，列表中元素是另一個(gè)序列或可遍歷的數(shù)據(jù)結(jié)構(gòu)中元素的運(yùn)算結(jié)果，或是滿(mǎn)足特定條件的元素的子序列。

例如，假定我們需要建立一個(gè)平方數(shù)的列表，像這樣：

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

注意，這將創(chuàng)建（或覆寫(xiě)）一個(gè)名為 x 的變量，并且這一變量在循環(huán)結(jié)束后仍將存在。而用下述的方式，我們能夠得到一個(gè)沒(méi)有任何副作用的平方數(shù)的列表。

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

或者，等價(jià)地：

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

后者更加精確且更具有可讀性。

一個(gè)列表推導(dǎo)式由一個(gè)包含了表達(dá)式，緊跟著for語(yǔ)句的括號(hào)，零個(gè)或更多的for或者if從句構(gòu)成。表達(dá)式的結(jié)果將會(huì)從表達(dá)式中for語(yǔ)句和if語(yǔ)句運(yùn)算得出。例如，下述的列表推導(dǎo)式結(jié)合了兩個(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的順序是一樣的。

如果表達(dá)式是一個(gè)元組(例如，前例中的(x,y))，它(元組中的數(shù)據(jù))必須加上括號(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 ?
    [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']

嵌套列表推導(dǎo)式

一個(gè)列表推導(dǎo)式中最初的表達(dá)式可以是任何表達(dá)式，包括另一個(gè)列表推導(dǎo)式。

下面的一個(gè) 3*4 的矩陣由一個(gè)包含 3 個(gè)長(zhǎng)度為 4 的列表的的列表實(shí)現(xiàn)。

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

下面的列表推導(dǎo)式將會(huì)（對(duì)該矩陣）進(jìn)行行和列的轉(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]]

正如我們?cè)谇耙还?jié)所看到的，嵌套的列表推導(dǎo)式由緊跟著上下文的for語(yǔ)句得出，所以，這個(gè)例子等價(jià)于：

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

相應(yīng)地，也等價(jià)于：

>>> 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í)際編程時(shí)，相比較于復(fù)雜的控制流語(yǔ)句，我們可能更喜歡內(nèi)建的函數(shù)。對(duì)于這種情況，zip()方法可以做的很好：

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

關(guān)于這個(gè)例子中*的含義，你可以參見(jiàn)解壓參數(shù)列表 一節(jié)

del 語(yǔ)句

我們可以使用序號(hào)而不是它的值來(lái)從一個(gè)列表中移除一項(xiàng)，有一種方式是使用del語(yǔ)句。這同要返回一個(gè)值的pop()方法不同。del語(yǔ)句也可以被用于從列表中移除切片或者整個(gè)列表(之前我們是把一個(gè)空鏈表賦給切片)，例如：

>>> 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語(yǔ)句也可被用于刪除整個(gè)變量：

>>> del a

在此之后再去使用a將會(huì)導(dǎo)致錯(cuò)誤（至少在另一個(gè)值被賦給a之前）。以后我們將介紹更多del語(yǔ)句的用法。

元組和序列

我們發(fā)現(xiàn)列表和字符串有著很多共同點(diǎn)，例如序列化和切片操作。他們是序列型數(shù)據(jù)類(lèi)型的兩個(gè)例子（參見(jiàn)序列類(lèi)型：列表，元組和范圍），因?yàn)?Python 是一門(mén)進(jìn)化中的語(yǔ)言，其他的序列型數(shù)據(jù)類(lèi)型可能會(huì)被添加進(jìn)來(lái)。還有另外一種標(biāo)準(zhǔn)的序列化數(shù)據(jù)類(lèi)型——元組 元組由一些用逗號(hào)分隔開(kāi)的值組成，例如：

>>> 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)包圍起來(lái)的，所以嵌套的元組也能夠正確的解釋。盡管括號(hào)經(jīng)常是必要的（如果元組是一個(gè)更大的表達(dá)式的一部分），但元組的輸入可以包含或者不包含括號(hào)。你不能夠給單獨(dú)的元組元素賦值，然而，你可以建立一個(gè)包含可變?cè)?，例如列表的元組。

盡管元組看起來(lái)和列表很像，但他們還是經(jīng)常用于不同的情況和不同的目的。元組是不可變的（即定長(zhǎng)-譯者注），并且經(jīng)常包含多種不同的通過(guò)解包（稍后介紹）或者索引（甚至于如果是namedtuples，可以通過(guò)屬性來(lái)訪問(wèn)）得到的元素序列。列表是可變的（即定長(zhǎng)），而且列表的元素通常通過(guò)列表的遍歷來(lái)完成。

一個(gè)特殊的問(wèn)題是，包含0個(gè)或1個(gè)元素的元組的構(gòu)造：Python 有一些特殊的語(yǔ)法來(lái)處理這種情況?？盏脑M可以通過(guò)一對(duì)空的括號(hào)來(lái)構(gòu)造，有一個(gè)元素的元組可以通過(guò)在值后邊跟隨一個(gè)逗號(hào)來(lái)構(gòu)造。（僅僅在一個(gè)單獨(dú)的值外邊加括號(hào)是不夠的）。不好看，但有效。例如：

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

表達(dá)式t = 12345, 54321, 'hello!'是一個(gè)元組解包的例子：值 12345,,54321 和"hello"打包在一個(gè)元組中。反過(guò)來(lái)的操作也是可以的。

>>> x, y, z = t

足夠恰當(dāng)?shù)卣f(shuō)，對(duì)所有右邊的序列來(lái)言（如上例中的 t ），這就是所謂的序列解包。元素解包時(shí)，在等式的左邊需要有和右邊序列中元素?cái)?shù)目同樣多的變量。注意：多重賦值僅僅是元組打包和序列解包的結(jié)合。

集合

Python 同樣包含一種稱(chēng)為集合的數(shù)據(jù)類(lèi)型。集合是一種無(wú)序的、不重復(fù)的數(shù)據(jù)結(jié)合。簡(jiǎn)單的使用包括測(cè)試元素是否在集合中和消除重復(fù)的元素。集合的實(shí)例同樣支持諸如并、交、補(bǔ)以及對(duì)稱(chēng)差等操作。一個(gè)簡(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 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'}

類(lèi)似于列表推導(dǎo)式，Python 也支持集合的推導(dǎo)式。

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

字典

Python 中另一種有用的數(shù)據(jù)類(lèi)型是字典（參見(jiàn)：映射類(lèi)型——字典）。在其他的語(yǔ)言中，字典有時(shí)被稱(chēng)之為關(guān)聯(lián)存儲(chǔ)或者關(guān)聯(lián)數(shù)組。與通過(guò)一組數(shù)來(lái)索引的序列不同，字典通過(guò)可以為任意常量的鍵來(lái)索引，例如字符串或者是數(shù)字。如果元組僅僅包含字符串、數(shù)字或者元組的話，那么元組也可以被用作為鍵。然而如果元組直接或間接地包含任何變量，那它就不能被用作鍵。因?yàn)榱斜砟軌蛲ㄟ^(guò)索引賦值、切片賦值或者像append()或extend()這樣的方法來(lái)改變，因而列表不能夠被當(dāng)做鍵。

最好的方式是，將字典視作一組要求鍵唯一（在同一字典內(nèi)）的無(wú)序鍵值對(duì)的集合，一對(duì)大括號(hào)可以創(chuàng)建一個(gè)空字典{}.通過(guò)放置用逗號(hào)分隔開(kāi)的鍵值對(duì)在括號(hào)里邊可以向字典增加初始的鍵值對(duì)，這也是字典被寫(xiě)入和讀取的方式。

對(duì)字典的主要的操作是存放鍵值對(duì)并通過(guò)鍵提取出值。通過(guò)del語(yǔ)句也可以刪除一個(gè)鍵值對(duì)。如果你通過(guò)一個(gè)已經(jīng)存在的鍵來(lái)存放值，和這個(gè)鍵相關(guān)聯(lián)的舊的值將會(huì)被抹掉。通過(guò)一個(gè)不存在的鍵來(lái)讀取值也是不被允許的。

通過(guò)在字典上的list(d.keys())操作可以返回在字典中用到的所有鍵，以一個(gè)任意的順序（如果需要排序的話，可以使用sorted(d.keys())來(lái)代替[2]）。如果要檢查一個(gè)單獨(dú)的鍵是否在字典中，可以使用in關(guān)鍵字。

一個(gè)使用字典的簡(jiǎn)單例子：

>>> 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)造器直接從一個(gè)鍵值對(duì)序列建立字典：

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

另外，如果要從任意的鍵值表達(dá)式中建立字典，可以使用字典推導(dǎo)式：

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

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

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

遍歷的技巧

當(dāng)遍歷一個(gè)字典時(shí)，鍵和與之對(duì)應(yīng)的值可以通過(guò)items()方法同時(shí)得到。

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

當(dāng)遍歷一個(gè)序列時(shí)，位置索引和與之對(duì)應(yīng)的值可以通過(guò)enumerate()方法同時(shí)得到。

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

如果要同時(shí)遍歷兩個(gè)或更多的序列，可以通過(guò)zip()方法來(lái)配對(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.

如果要翻轉(zhuǎn)的遍歷一個(gè)序列，首先確定序列的正方向，然后使用reversed()方法。

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

要以一個(gè)排序過(guò)的順序遍歷一個(gè)序列，使用sorted()方法。該方法返回一個(gè)新的列表，同時(shí)保持原列表不變。

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

如果要在循環(huán)內(nèi)改變一個(gè)正在遍歷的序列（例如賦值特定的元素），最好是先復(fù)制一份。遍歷序列并不隱式地復(fù)制。切片表示讓這非常的簡(jiǎn)單。

>>> words = ['cat', 'window', 'defenestrate']
>>> for w in words[:]:  # Loop over a slice copy of the entire list.
...     if len(w) > 6:
...         words.insert(0, w)
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

關(guān)于條件控制的更多內(nèi)容

用于while和if語(yǔ)句的條件控制可以包含任何的操作符，不僅僅是比較。

比較操作符in和not in可以用于檢查一個(gè)值是否在一個(gè)序列中出現(xiàn)。 is和not is 操作符可以比較兩個(gè)實(shí)例是否為同一個(gè)實(shí)例，當(dāng)然這僅僅對(duì)于如列表這樣的可變的實(shí)例有作用。所有的比較操作符都有著相同的優(yōu)先級(jí)，即比所有的數(shù)字運(yùn)算符都要低。

比較符可以連接在一起。例如a < b == c可以測(cè)試 a 是否小于 b，同時(shí) b 等于 c。

比較符可以和邏輯運(yùn)算符結(jié)合在一起，例如and和or。而且這個(gè)比較符的輸出（或者任意的邏輯表達(dá)式）可以通過(guò)not來(lái)取反。這些邏輯運(yùn)算符的優(yōu)先級(jí)都要低于比較操作符。而在他們中間，not有最高的優(yōu)先級(jí)而or有最低的優(yōu)先級(jí)，所以，A and not B or C和(A and (not B)) or C是等價(jià)的。因?yàn)槔ㄌ?hào)總是可以表達(dá)所需要的組合。

邏輯表達(dá)式and和or被稱(chēng)為短路操作符：他們的參數(shù)從左到右被傳入，并且當(dāng)?shù)玫浇Y(jié)果時(shí)立即就停止。例如，如果A和C為真而B(niǎo)為假，A and B and C并不求 C 表達(dá)式的值，如果他們被用于普通的數(shù)據(jù)，而不是作為邏輯值時(shí)，返回的結(jié)果就是最后的一個(gè)被求解的參數(shù)。

可以將比較結(jié)果或者邏輯表達(dá)式的值賦給一個(gè)變量，例如：

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

注意：在 Python 中，和 C 不同的是，賦值操作不能夠在表達(dá)式中完成。C 程序員可能會(huì)對(duì)此有所抱怨，但是這避免了在 C 中經(jīng)常遇到的一類(lèi)問(wèn)題：誤把==打成了=。

比較序列和其他的類(lèi)型

序列的實(shí)例可以與同一序列類(lèi)型的實(shí)例相比較，這一比較使用字典序：首先頭兩個(gè)元素比較，如果它們兩個(gè)是不同的，則輸出比較結(jié)果。如果它們是相同的，則比較后兩個(gè)元素，如此繼續(xù)下去。直到有一個(gè)序列到了末尾為止。如果要被比較的兩個(gè)元素本身就是同種的序列，字典序的比較將會(huì)被遞歸地執(zhí)行。如果兩個(gè)序列中所有元素都相等，這兩個(gè)序列就被認(rèn)為是相等的，如果一個(gè)序列是另一個(gè)序列的子序列，較短的序列就被認(rèn)為是更短（更?。┑囊粋€(gè)。對(duì)于字符串的字典序來(lái)說(shuō)，它使用 Unicode 編碼來(lái)比較每一個(gè)字符。下面是一個(gè)關(guān)于相同類(lèi)型的序列的比較的例子：

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

注意：只要提供了合適的比較的方法，使用<或者>來(lái)比較兩個(gè)實(shí)例是可以的。例如，混合的數(shù)值類(lèi)型可以根據(jù)數(shù)值的大小來(lái)比較，所以 0 和 0.0 是相等的等等。否則的話，編譯器將報(bào)出 TypeError 的異常，而不是提供一個(gè)任意的順序來(lái)比較。

腳注

[1] 其他的語(yǔ)言可能會(huì)返回一個(gè)可變的實(shí)例，允許方法的鏈接，例如d->insert("a")->remove("b")->sort();

[2] 使用d.keys()將會(huì)返回一個(gè)字典視圖實(shí)例。它支持一些諸如變量是否存在的檢查和遍歷操作，但是它的內(nèi)容并不是獨(dú)立于原有的字典的，它僅僅是一個(gè)視圖。