用 Python 編程 for 迴圈

本文講述了 Python for 迴圈。for 迴圈用於迭代 Python 集合中的項目，集合包括前面的 “探索 Python” 文章中討論的 Python tuple、string 和 list 容器類型。通過使用 range（或 xrange）方法，for 迴圈還可用於訪問某個container 類型中的元素。另外，還可以使用 range 方法在 for 迴圈內對一組語句執行特定次數。

　　for 迴圈

　 　本系列前面 “探索 Python，第 5 部分：用 Python 編程” 一文討論了 if 語句和 while 迴圈，討論了複合陳述式以及適當縮排 Python 語句來指示相關 Python 代碼塊。該文的結尾介紹了 Python for 迴圈。但就其使用和功能來說，for 迴圈更值得關注，所以本文單獨講述該迴圈。

　　for 迴圈有一個簡單的文法，使您可以從容器物件中提取單個項目並對其進行某些操作。簡單地說，使用 for 迴圈，可以迭代中對象集合的項目。對象集合可以是任何 Python 容器類型，包括前面文章中討論的 tuple、string 和 list 類型。但是容器 metaphor 的功能比這三種類型更強大。metaphor 包括其他序列類型，如 dictionary 和 set，將來的文章中將對它們進行討論。

　　但是請稍等！還有更多資訊：for 迴圈可以用於迭代支援迭代 metaphor 的任何對象，這使 for 迴圈非常有用。

　　清單 1 中顯示了 for 迴圈的基本文法，還示範了如何在 for 迴圈中使用 continue 和 break 語句。

　　清單 1. for 迴圈的虛擬碼

for item in container:
　　if conditionA:　　　　# Skip this item
　　　　continue
　
　　elif conditionB:　　　# Done with loop
　　　　break
　
　　# action to repeat for each item in the container
　
else:
　
　　# action to take once we have finished the loop.

　本系列中的第二篇文章 “探索 Python，第 2 部分：探索 Python 類型的階層” 介紹了 Python tuple。如文中所述，tuple 類型是不可變的異構容器。這主要是說 tuple 可以存放不同類型的對象，但是它一旦建立，就無法更改。清單 2 示範了如何使用 for 迴圈迭代 tuple 的元素。

　　清單 2. for 迴圈和 tuple

>>> t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> count = 0
>>> for num in t:
...　　 count += num
... else:
...　　 print count
...
45
>>> count = 0
>>> for num in t:
...　　 if num % 2:
...　　　　 continue
...　　 count += num
... else:
...　　 print count
...
20

　 　本例首先建立了名為 t 的 tuple，存放整數 0 至 9（包含 9）。第一個 for 迴圈迭代此 tuple，在 count 變數中累計 tuple 中數值的和。一旦代碼已經迭代了 tuple 中的所有元素，它將進入 for 迴圈的 else 子句，列印 count 變數的值。

　 　清單 2 中顯示的第二個 for 迴圈也迭代 tuple 中的所有元素。但是，它僅累計容器中能夠被 2 整除的那些項的值（請記住如果運算式為非零，if 語句將確定為真，num 不能被 2 整除時使用 % 運算子會返回非零值）。此限制通過使用適當的 if 語句和 continue 語句來完成。如前面的文章中所述，continue 語句使包含它的迴圈開始下一次迭代。實現相同結果的另一種方法是測試 tuple 中的當前項是否是偶數（使用 if not num % 2:），如果為真，那麼將當前項添加到運行總和中。一旦程式碼完成 tuple 中的迭代，將調用 else 子句，列印總和。

本系列中的第三篇文章 “探索 Python：第 3 部分：探索 Python 類型的階層” 討論了 Python string。string 是不可變的同構容器，這意味著它僅能存放字元且一旦建立將無法修改。清單 3 示範了如何使用 Python string 作為 for 迴圈的容器。

　　清單 3. for 迴圈和 string

>>> st = "Python Is A Great Programming Language!"
>>> for c in st:
...　　 print c,
...
P y t h o n　 I s　 A　 G r e a t　 P r o g r a m m i n g　 L a n g u a g e !
>>> count = 0
>>> for c in st:
...　　 if c in "aeiou":
...　　　　 count += 1
... else:
...　　 print count
...
10
>>> count = 0
>>> for c in st.lower():
...　　 if c in "aeiou":
...　　　　 count += 1
... else:
...　　 print count
...
12

　 　本例提供了三個不同的 for 迴圈，它們都迭代同一 string。第一個 for 迴圈迭代 string “Python Is A Great Programming Language!” 並一次列印 string 中的一個字元。在此例中，print 語句變數 c 後加了一個逗號。這使 print 語句列印字元值時後面跟著空白字元，而不是換行字元。如果沒有後面的逗號，字元將全部列印在單獨的行中，會很難讀。

　 　下兩個 for 迴圈迭代該字串並計算其包含多少個母音字母（“a”、“e”、“i”、“o” 或 “u”）。第二個 for 迴圈在迭代原始 string 時僅尋找小寫母音字母。第三個 for 迴圈迭代通過調用 string 對象的 lower 方法返回的臨時 string。lower 方法將 string 中的所有字元轉換為小寫。因此，第三個 for 迴圈可找到另外兩個母音字母。

本系列中的第四篇文章 “探索 Python，第 4 部分：探索 Python 類型的階層” 介紹了 Python list。list 是異構可變容器，這意味著它可以存放不同類型的對象且建立後可以修改。清單 4 示範了如何使用 list 和 for 迴圈。

　　清單 4. for 迴圈和 list

>>> mylist = [1, 1.0, 1.0j, '1', (1,), [1]]
>>> for item in mylist:
...　　 print item, "　　", type(item))
...
1　　　 <type 'int'>
1.0　　 <type 'float'>
1j　　　<type 'complex'>
1　　　 <type 'str'>
(1,)　　<type 'tuple'>
[1]　　 <type 'list'>

　 　既然 list 是很靈活的 Python 容器類型（您將在本系列其餘的文章中多次看到它），本例看起來可能過於簡單了。但是，這是一部分要點：使用 for 迴圈使處理容器中的每個項目非常簡單，甚至處理包含各種不同對象的 list 也是如此。本例迭代 Python list 中的所有項目，並在單獨的行中列印每一項及其相對應的 Python 類型。

　　迭代和可變容器

　　Python list 是一個可變序列，提供了一種令人好奇的可能性：for 迴圈主體可以修改其正在迭代的 list。正如您可能認為的，這樣並不好，如果進行此操作，Python 解譯器將無法很好地工作，如清單 5 所示。

　　清單 5. 在 for 迴圈中修改容器>>> mylist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for item in mylist:
...　　 if item % 2:
...　　　　 mylist.insert(0, 100)
...
^CTraceback (most recent call last):
　File "<stdin>", line 3, in ?
KeyboardInterrupt
>>> print mylist
[100, ...., 100, 100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]　# Many lines deleted for clarity
>>> mylist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for item in mylist[:]:
...　　 if item % 2:
...　　　　 mylist.insert(0, 100)
...
>>> print mylist
[100, 100, 100, 100, 100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

本例中的第一個 for 迴圈只要在原始 list 中發現奇數，它就在 list 的開始插入數值 100。當然，這是一種示範此問題的不同尋常的方式，但卻非常好。一旦在三個點的 Python 提示後按 Enter 鍵，Python 解譯器就處於無限迴圈的混亂中。要停止這種混亂，必須通過按 Ctrl-C（其在 Python 輸出中顯示為 ^C）來中斷進程，然後會出現 KeyboardInterrupt 異常。如果列印出修改的 list，將看到 mylist 現在包含大量的值為 100 的元素（新元素的準確數量取決於您中斷迴圈的速度）。

　　本例中的第二個 for 迴圈示範了如何避免此問題。使用切片運算子建立原始 list 的副本。現在 for 迴圈將迭代該副本，而對原始 list 進行修改。最終的結果是修改後的原始 list，它現在以五個值為 100 的新元素開始。

　　for 迴圈和序列索引

　 　如果您用過其他程式設計語言，Python for 迴圈可能看起來有點兒古怪。您可能認為它更像 foreach 迴圈。基於 C 的程式設計語言具有 for 迴圈，但它的設計目的是對一系列操作執行特定次數。Python for 迴圈可以通過使用內建的 range 和 xrange 方法來類比該行為。清單 6 中示範了這兩種方法。

　　清單 6. range 和 xrange 方法

>>> r = range(10)
>>> print r
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> type(r)
<type 'list'>
>>> xr = xrange(10)
>>> print xr
xrange(10)
>>> type(xr)
<type 'xrange'>

　 　本例首先示範了 range 方法，它建立一個包含一系列整數的新 list。調用 range 方法的一般形式是提供單個值，用作整數 list 的上限。零為起始值。因此，調用 range(10) 將建立包含整數 0 至 9（包含 9）的 list。range 方法接受起始索引以及步長。所以，調用 range(11,20) 將建立從 11 至 19（包含 19）的整數 list，而調用 range(12, 89, 2) 將建立從 12 至 88 的偶數 list。

由於 xrange 方法也建立整數 list（其使用相同參數），所以它與 range 方法非常相似。但是，xrange 方法僅在需要時才在 list 中建立整數。例如，在清單 6 中，嘗試列印出新建立的 xrange 時除了 xrange 的名稱，不會顯示任何資料。當需要迭代大量整數時，xrange 方法更適用，因為它不會建立極大的 list，那樣會消耗大量電腦記憶體。

　　清單 7 示範了如何在 for 迴圈內使用 range 方法來建立整數 1 至 10（包含 10）的乘法表。

　　清單 7. 建立乘法表>>> for row in range(1, 11):
...　　 for col in range(1, 11):
...　　　　 print "%3d " % (row * col),
...　　 print
...
　1　　2　　3　　4　　5　　6　　7　　8　　9　 10
　2　　4　　6　　8　 10　 12　 14　 16　 18　 20
　3　　6　　9　 12　 15　 18　 21　 24　 27　 30
　4　　8　 12　 16　 20　 24　 28　 32　 36　 40
　5　 10　 15　 20　 25　 30　 35　 40　 45　 50
　6　 12　 18　 24　 30　 36　 42　 48　 54　 60
　7　 14　 21　 28　 35　 42　 49　 56　 63　 70
　8　 16　 24　 32　 40　 48　 56　 64　 72　 80
　9　 18　 27　 36　 45　 54　 63　 72　 81　 90
10　 20　 30　 40　 50　 60　 70　 80　 90　100

　 　本例使用兩個 for 迴圈，外面的 for 迴圈關注乘法表中的每一行，嵌套的 for 迴圈關注每行內的列。每個迴圈都迭代包含整數 1 至 10（包含 10）的 list。最裡面的 print 語句使用了一個名為 字串格式化 的新概念來建立格式設定精美的表。字串格式化是一種非常有用的技術，用於以格式設定精美的布局建立由不同資料類型組成的 string。現在詳細資料並不重要，將來的文章中將講述這些內容（瞭解 C 程式設計語言的 printf 方法的任何人都會很熟悉這些內容）。在本例中，字串格式化指定將從整數建立新 string 且需要保留三個字元來存放該整數（如果該整數小於三個字元，將在左邊用空格填補，從而使資料排列整齊）。第二個 print 語句用於列印新行，從而使乘法表中的下一行被列印在新的行中。

　　range 方法還可用於迭代容器，通過使用適當的索引訪問序列中的每一項。要進行此操作，需要包含容器的允許範圍索引值的整數 list，這可以通過使用 range 方法和 len 方法來輕鬆實現，如清單 8 所示。

　　清單 8. 在 for 迴圈內索引容器>>> st = "Python Is A Great Programming Language!"
>>> for index in range(len(st)):
...　　 print st[index],
...
P y t h o n　 I s　 A　 G r e a t　 P r o g r a m m i n g　 L a n g u a g e !
>>> for item in st.split(' '):
...　　 print item, len(item)
...
Python 6
Is 2
A 1
Great 5
Programming 11
Language! 9

　 　這個最後的樣本示範了如何使用 len 方法作為 range 方法的參數，建立可用於單獨訪問 string 中每個字元的整數 list。第二個 for 迴圈還顯示了如何將 string 分割為子字串的 list（使用空白字元來指示子字串的邊界）。for 迴圈迭代子字串 list，列印每個子字串及其長度。

　　結束語

　　本文討論了 Python for 迴圈並示範了它的一些使用方式。可以將 for 迴圈與提供迭代器的任何 Python 對象結合使用，這些對象包括 tuple、string 和 list 等內建序列類型。for 迴圈和 list 序列一起使用時具有強大的功能，您會發現自己在許多情況中都要使用它們。Python 提供了用於組合這兩個概念的簡單機制，稱為列表理解，將來的文章中將講述該內容。