摘要：上一篇文章標(biāo)準(zhǔn)庫內(nèi)置類型數(shù)字類型下一篇文章標(biāo)準(zhǔn)庫內(nèi)置類型文本序列類型迭代器類型支持在容器中進(jìn)行迭代的概念。該對象需要支持下文所述的迭代器協(xié)議。這是同時允許容器和迭代器配合和語句使用所必須的。

上一篇文章：Python標(biāo)準(zhǔn)庫---10、內(nèi)置類型:數(shù)字類型
下一篇文章：Python標(biāo)準(zhǔn)庫---12、內(nèi)置類型:文本序列類型（str）

## 迭代器類型
Python 支持在容器中進(jìn)行迭代的概念。 這是通過使用兩個多帶帶方法來實現(xiàn)的；它們被用于允許用戶自定義類對迭代的支持。 將在下文中詳細(xì)描述的序列總是支持迭代方法。

容器對象要提供迭代支持，必須定義一個方法:

返回一個迭代器對象。 該對象需要支持下文所述的迭代器協(xié)議。 如果容器支持不同的迭代類型，則可以提供額外的方法來專門地請求不同迭代類型的迭代器。 （支持多種迭代形式的對象的例子有同時支持廣度優(yōu)先和深度優(yōu)先遍歷的樹結(jié)構(gòu)。） 此方法對應(yīng)于 Python/C API 中 Python 對象類型結(jié)構(gòu)體的 tp_iter 槽位。

迭代器對象自身需要支持以下兩個方法，它們共同組成了 迭代器協(xié)議:

返回迭代器對象本身。 這是同時允許容器和迭代器配合 for 和 in 語句使用所必須的。 此方法對應(yīng)于 Python/C API 中 Python 對象類型結(jié)構(gòu)體的 tp_iter 槽位。

從容器中返回下一項。 如果已經(jīng)沒有項可返回，則會引發(fā) StopIteration 異常。 此方法對應(yīng)于 Python/C API 中 Python 對象類型結(jié)構(gòu)體的 tp_iternext 槽位。

Python 定義了幾種迭代器對象以支持對一般和特定序列類型、字典和其他更特別的形式進(jìn)行迭代。 除了迭代器協(xié)議的實現(xiàn)，特定類型的其他性質(zhì)對迭代操作來說都不重要。

一旦迭代器的 __next__() 方法引發(fā)了 StopIteration，它必須一直對后續(xù)調(diào)用引發(fā)同樣的異常。 不遵循此行為特性的實現(xiàn)將無法正常使用。

Python 的 generator 提供了一種實現(xiàn)迭代器協(xié)議的便捷方式。 如果容器對象 __iter__() 方法被實現(xiàn)為一個生成器，它將自動返回一個迭代器對象（從技術(shù)上說是一個生成器對象），該對象提供 __iter__() 和 __next__() 方法。 有關(guān)生成器的更多信息可以參閱 yield 表達(dá)式的文檔。

有三種基本序列類型：list, tuple 和 range 對象。 為處理 二進(jìn)制數(shù)據(jù) 和 文本字符串 而特別定制的附加序列類型會在專門的小節(jié)中描述。

大多數(shù)序列類型，包括可變類型和不可變類型都支持下表中的操作。 collections.abc.Sequence ABC 被提供用來更容易地在自定義序列類型上正確地實現(xiàn)這些操作。

此表按優(yōu)先級升序列出了序列操作。 在表格中，s 和 t 是具有相同類型的序列，n, i, j 和 k 是整數(shù)，而 x 是任何滿足 s 所規(guī)定的類型和值限制的任意對象。

in 和 not in 操作具有與比較操作相同的優(yōu)先級。 + (拼接) 和 * (重復(fù)) 操作具有與對應(yīng)數(shù)值運(yùn)算相同的優(yōu)先級。

相同類型的序列也支持比較。 特別地，tuple 和 list 的比較是通過比較對應(yīng)元素的字典順序。 這意味著想要比較結(jié)果相等，則每個元素比較結(jié)果都必須相等，并且兩個序列長度必須相同。 （完整細(xì)節(jié)請參閱語言參考的 比較運(yùn)算 部分。）

注釋:

雖然 in 和 not in 操作在通常情況下僅被用于簡單的成員檢測，某些專門化序列 (例如 str, bytes 和 bytearray) 也使用它們進(jìn)行子序列檢測:

    >>>

    >>> "gg" in "eggs"
    True

小于 0 的 n 值會被當(dāng)作 0 來處理 (生成一個與 s 同類型的空序列)。

請注意序列 s 中的項并不會被拷貝；它們會被多次引用。 這一點經(jīng)常會令 Python 編程新手感到困擾；例如:

    >>>

    >>> lists = [[]] * 3
    >>> lists
    [[], [], []]
    >>> lists[0].append(3)
    >>> lists
    [[3], [3], [3]]

具體的原因在于 [[]] 是一個包含了一個空列表的單元素列表，所以 [[]] * 3 結(jié)果中的三個元素都是對這一個空列表的引用。 修改 lists 中的任何一個元素實際上都是對這一個空列表的修改。 你可以用以下方式創(chuàng)建以不同列表為元素的列表:

    >>>

    >>> lists = [[] for i in range(3)]
    >>> lists[0].append(3)
    >>> lists[1].append(5)
    >>> lists[2].append(7)
    >>> lists
    [[3], [5], [7]]

    進(jìn)一步的解釋可以在 FAQ 條目 如何創(chuàng)建多維列表？ 中查看。

如果 i 或 j 為負(fù)值，則索引順序是相對于序列 s 的末尾: 索引號會被替換為 len(s) + i 或 len(s) + j。 但要注意 -0 仍然為 0。

s 從 i 到 j 的切片被定義為所有滿足 i <= k < j 的索引號 k 的項組成的序列。 如果 i 或 j 大于 len(s)，則使用 len(s)。 如果 i 被省略或為 None，則使用 0。 如果 j 被省略或為 None，則使用 len(s)。 如果 i 大于等于 j，則切片為空。

s 從 i 到 j 步長為 k 的切片被定義為所有滿足 0 <= n < (j-i)/k 的索引號 x = i + nk 的項組成的序列。 換句話說，索引號為 i, i+k, i+2k, i+3*k，以此類推，當(dāng)達(dá)到 j 時停止 (但一定不包括 j)。 當(dāng) k 為正值時，i 和 j 會被減至不大于 len(s)。 當(dāng) k 為負(fù)值時，i 和 j 會被減至不大于 len(s) - 1。 如果 i 或 j 被省略或為 None，它們會成為“終止”值 (是哪一端的終止值則取決于 k 的符號)。 請注意，k 不可為零。 如果 k 為 None，則當(dāng)作 1 處理。

拼接不可變序列總是會生成新的對象。 這意味著通過重復(fù)拼接來構(gòu)建序列的運(yùn)行時開銷將會基于序列總長度的乘方。 想要獲得線性的運(yùn)行時開銷，你必須改用下列替代方案之一：

如果拼接 str 對象，你可以構(gòu)建一個列表并在最后使用 str.join() 或是寫入一個 io.StringIO 實例并在結(jié)束時獲取它的值

如果拼接 bytes 對象，你可以類似地使用 bytes.join() 或 io.BytesIO，或者你也可以使用 bytearray 對象進(jìn)行原地拼接。 bytearray 對象是可變的，并且具有高效的重分配機(jī)制

如果拼接 tuple 對象，請改為擴(kuò)展 list 類

對于其它類型，請查看相應(yīng)的文檔

某些序列類型 (例如 range) 僅支持遵循特定模式的項序列，因此并不支持序列拼接或重復(fù)。

當(dāng) x 在 s 中找不到時 index 會引發(fā) ValueError。 不是所有實現(xiàn)都支持傳入額外參數(shù) i 和 j。 這兩個參數(shù)允許高效地搜索序列的子序列。 傳入這兩個額外參數(shù)大致相當(dāng)于使用 s[i:j].index(x)，但是不會復(fù)制任何數(shù)據(jù)，并且返回的索引是相對于序列的開頭而非切片的開頭。

不可變序列類型普遍實現(xiàn)而可變序列類型未實現(xiàn)的唯一操作就是對 hash() 內(nèi)置函數(shù)的支持。

這種支持允許不可變類型，例如 tuple 實例被用作 dict 鍵，以及存儲在 set 和 frozenset 實例中。

嘗試對包含有不可哈希值的不可變序列進(jìn)行哈希運(yùn)算將會導(dǎo)致 TypeError。

以下表格中的操作是在可變序列類型上定義的。 collections.abc.MutableSequence ABC 被提供用來更容易地在自定義序列類型上正確實現(xiàn)這些操作。

表格中的 s 是可變序列類型的實例，t 是任意可迭代對象，而 x 是符合對 s 所規(guī)定類型與值限制的任何對象 (例如，bytearray 僅接受滿足 0 <= x <= 255 值限制的整數(shù))。

注釋:

t 必須與它所替換的切片具有相同的長度。

可選參數(shù) i 默認(rèn)為 -1，因此在默認(rèn)情況下會移除并返回最后一項。

當(dāng)在 s 中找不到 x 時 remove 操作會引發(fā) ValueError。

當(dāng)反轉(zhuǎn)大尺寸序列時 reverse() 方法會原地修改該序列以保證空間經(jīng)濟(jì)性。 為提醒用戶此操作是通過間接影響進(jìn)行的，它并不會返回反轉(zhuǎn)后的序列。

包括 clear() 和 copy() 是為了與不支持切片操作的可變?nèi)萜?(例如 dict 和 set) 的接口保持一致

3.3 新版功能: clear() 和 copy() 方法。

n 值為一個整數(shù)，或是一個實現(xiàn)了 __index__() 的對象。 n 值為零或負(fù)數(shù)將清空序列。 序列中的項不會被拷貝；它們會被多次引用，正如 通用序列操作 中有關(guān) s * n 的說明。

列表是可變序列，通常用于存放同類項目的集合（其中精確的相似程度將根據(jù)應(yīng)用而變化）。

可以用多種方式構(gòu)建列表：

使用一對方括號來表示空列表: []

使用方括號，其中的項以逗號分隔: [a], [a, b, c]

使用列表推導(dǎo)式: [x for x in iterable]

使用類型的構(gòu)造器: list() 或 list(iterable)

構(gòu)造器將構(gòu)造一個列表，其中的項與 iterable 中的項具有相同的的值與順序。 iterable 可以是序列、支持迭代的容器或其它可迭代對象。 如果 iterable 已經(jīng)是一個列表，將創(chuàng)建并返回其副本，類似于 iterable[:]。 例如，list("abc") 返回 ["a", "b", "c"] 而 list( (1, 2, 3) ) 返回 [1, 2, 3]。 如果沒有給出參數(shù)，構(gòu)造器將創(chuàng)建一個空列表 []。

其它許多操作也會產(chǎn)生列表，包括 sorted() 內(nèi)置函數(shù)。

列表實現(xiàn)了所有 一般 和 可變 序列的操作。 列表還額外提供了以下方法：

#### sort(*, key=None, reverse=False)

此方法會對列表進(jìn)行原地排序，只使用 < 來進(jìn)行各項間比較。 異常不會被屏蔽 —— 如果有任何比較操作失敗，整個排序操作將失?。ǘ斜砜赡軙幱诒徊糠中薷牡臓顟B(tài)）。

sort() 接受兩個僅限以關(guān)鍵字形式傳入的參數(shù) (僅限關(guān)鍵字參數(shù)):

key 指定帶有一個參數(shù)的函數(shù)，用于從每個列表元素中提取比較鍵 (例如 key=str.lower)。 對應(yīng)于列表中每一項的鍵會被計算一次，然后在整個排序過程中使用。 默認(rèn)值 None 表示直接對列表項排序而不計算一個多帶帶的鍵值。

可以使用 functools.cmp_to_key() 將 2.x 風(fēng)格的 cmp 函數(shù)轉(zhuǎn)換為 key 函數(shù)。

reverse 為一個布爾值。 如果設(shè)為 True，則每個列表元素將按反向順序比較進(jìn)行排序。

當(dāng)順序大尺寸序列時此方法會原地修改該序列以保證空間經(jīng)濟(jì)性。 為提醒用戶此操作是通過間接影響進(jìn)行的，它并不會返回排序后的序列（請使用 sorted() 顯示地請求一個新的已排序列表實例）。

sort() 方法確保是穩(wěn)定的。 如果一個排序確保不會改變比較結(jié)果相等的元素的相對順序就稱其為穩(wěn)定的 --- 這有利于進(jìn)行多重排序（例如先按部門、再接薪級排序）。

CPython implementation detail: 在一個列表被排序期間，嘗試改變甚至進(jìn)行檢測也會造成未定義的影響。 Python 的 C 實現(xiàn)會在排序期間將列表顯示為空，如果發(fā)現(xiàn)列表在排序期間被改變將會引發(fā) ValueError。

元組是不可變序列，通常用于儲存異構(gòu)數(shù)據(jù)的多項集（例如由 enumerate() 內(nèi)置函數(shù)所產(chǎn)生的二元組）。 元組也被用于需要同構(gòu)數(shù)據(jù)的不可變序列的情況（例如允許存儲到 set 或 dict 的實例）。

可以用多種方式構(gòu)建元組：

使用一對圓括號來表示空元組: ()

使用一個后綴的逗號來表示單元組: a, 或 (a,)

使用以逗號分隔的多個項: a, b, c or (a, b, c)

使用內(nèi)置的 tuple(): tuple() 或 tuple(iterable)

構(gòu)造器將構(gòu)造一個元組，其中的項與 iterable 中的項具有相同的值與順序。 iterable 可以是序列、支持迭代的容器或其他可迭代對象。 如果 iterable 已經(jīng)是一個元組，會不加改變地將其返回。 例如，tuple("abc") 返回 ("a", "b", "c") 而 tuple( [1, 2, 3] ) 返回 (1, 2, 3)。 如果沒有給出參數(shù)，構(gòu)造器將創(chuàng)建一個空元組 ()。

請注意決定生成元組的其實是逗號而不是圓括號。 圓括號只是可選的，生成空元組或需要避免語法歧義的情況除外。 例如，f(a, b, c) 是在調(diào)用函數(shù)時附帶三個參數(shù)，而 f((a, b, c)) 則是在調(diào)用函數(shù)時附帶一個三元組。

元組實現(xiàn)了所有 一般 序列的操作。

對于通過名稱訪問相比通過索引訪問更清晰的異構(gòu)數(shù)據(jù)多項集，collections.namedtuple() 可能是比簡單元組對象更為合適的選擇。

range 類型表示不可變的數(shù)字序列，通常用于在 for 循環(huán)中循環(huán)指定的次數(shù)。

range 構(gòu)造器的參數(shù)必須為整數(shù)（可以是內(nèi)置的 int 或任何實現(xiàn)了 __index__ 特殊方法的對象）。 如果省略 step 參數(shù)，其默認(rèn)值為 1。 如果省略 start 參數(shù)，其默認(rèn)值為 0，如果 step 為零則會引發(fā) ValueError。

如果 step 為正值，確定 range r 內(nèi)容的公式為 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。

如果 step 為負(fù)值，確定 range 內(nèi)容的公式仍然為 r[i] = start + step*i，但限制條件改為 i >= 0 且 r[i] > stop.

如果 r[0] 不符合值的限制條件，則該 range 對象為空。 range 對象確實支持負(fù)索引，但是會將其解讀為從正索引所確定的序列的末尾開始索引。

元素絕對值大于 sys.maxsize 的 range 對象是被允許的，但某些特性 (例如 len()) 可能引發(fā) OverflowError。

一些 range 對象的例子:

    >>> list(range(10))
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> list(range(1, 11))
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    >>> list(range(0, 30, 5))
    [0, 5, 10, 15, 20, 25]
    >>> list(range(0, 10, 3))
    [0, 3, 6, 9]
    >>> list(range(0, -10, -1))
    [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
    >>> list(range(0))
    []
    >>> list(range(1, 0))
    []

range 對象實現(xiàn)了 一般 序列的所有操作，但拼接和重復(fù)除外（這是由于 range 對象只能表示符合嚴(yán)格模式的序列，而重復(fù)和拼接通常都會違反這樣的模式）。

start

    start 形參的值 (如果該形參未提供則為 0)

stop

    stop 形參的值

step

    step 形參的值 (如果該形參未提供則為 1)

range 類型相比常規(guī) list 或 tuple 的優(yōu)勢在于一個 range 對象總是占用固定數(shù)量的（較?。﹥?nèi)存，不論其所表示的范圍有多大（因為它只保存了 start, stop 和 step 值，并會根據(jù)需要計算具體單項或子范圍的值）。

range 對象實現(xiàn)了 collections.abc.Sequence ABC，提供如包含檢測、元素索引查找、切片等特性，并支持負(fù)索引 (參見 序列類型 --- list, tuple, range):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

使用 == 和 != 檢測 range 對象是否相等是將其作為序列來比較。 也就是說，如果兩個 range 對象表示相同的值序列就認(rèn)為它們是相等的。 （請注意比較結(jié)果相等的兩個 range 對象可能會具有不同的 start, stop 和 step 屬性，例如 range(0) == range(2, 1, 3) 而 range(0, 3, 2) == range(0, 4, 2)。）

在 3.2 版更改: 實現(xiàn) Sequence ABC。 支持切片和負(fù)數(shù)索引。 使用 int 對象在固定時間內(nèi)進(jìn)行成員檢測，而不是逐一迭代所有項。

在 3.3 版更改: 定義 "==" 和 "!=" 以根據(jù) range 對象所定義的值序列來進(jìn)行比較（而不是根據(jù)對象的標(biāo)識）。

3.3 新版功能: start, stop 和 step 屬性。

參見

linspace recipe 演示了如何實現(xiàn)一個延遲求值版本的適合浮點數(shù)應(yīng)用的 range 對象。

上一篇文章：Python標(biāo)準(zhǔn)庫---10、內(nèi)置類型:數(shù)字類型
下一篇文章：Python標(biāo)準(zhǔn)庫---12、內(nèi)置類型:文本序列類型（str）