跳轉到內容

Python 程式設計/迴圈

來自華夏公益教科書，開放書籍，構建開放世界
上一個: 條件語句 索引 下一個: 函式


While 迴圈

[編輯 | 編輯原始碼]

這是我們的第一個控制結構。使用的版本是 2.7。通常情況下，計算機從第一行開始，然後向下執行。控制結構改變語句執行的順序，或決定是否執行某個語句。順便說一下，決策語句（例如，if 語句）也會影響是否執行某個語句。下面是使用 while 控制結構的程式的原始碼

a = 0
while a < 5:
    a += 1 # Same as a = a + 1 
    print (a)

下面是輸出

1
2
3
4
5

那麼程式做了什麼？首先它看到這行a = 0並將變數 a 設定為零。然後它看到while a < 5因此計算機檢查是否a < 5。計算機第一次看到這個語句時，a 是零，而零小於 5。換句話說，只要 a 小於五，計算機就會執行縮排的語句。

下面是另一個使用while: 

a = 1
s = 0
print ('Enter Numbers to add to the sum.')
print ('Enter 0 to quit.')
while a != 0:
    print ('Current Sum: ', s)
    a = input('Number? ') #raw_input() only up to Python 2.x
    a = float(a)
    s += a
print ('Total Sum = ',s)

Enter Numbers to add to the sum.
Enter 0 to quit.
Current Sum: 0
Number? 200
Current Sum: 200
Number? -15.25
Current Sum: 184.75
Number? -151.85
Current Sum: 32.9
Number? 10.00
Current Sum: 42.9
Number? 0
Total Sum = 42.9

的例子注意print 'Total Sum =',swhile只在最後執行一次。該語句隻影響縮排的（也稱為縮排的）行。該 !=表示不等於，所以while a != 0 

表示直到 a 為零，執行後面的縮排語句。

while 1 == 1:
    print ("Help, I'm stuck in a loop.")

現在我們有了 while 迴圈，就可以編寫永遠執行的程式。一個簡單的方法是編寫類似這樣的程式這個程式會輸出救命，我卡在迴圈裡了。

直到宇宙熱寂或你停止它。停止它的方法是同時按下 Ctrl（或 Ctrl）鍵和 `c`（字母）。這將殺死程式。（注意：有時你需要在 Ctrl C 後按回車鍵。）

示例

[編輯 | 編輯原始碼]

#This program calculates the Fibonacci sequence
a = 0
b = 1
count = 0
max_count = 20
while count < max_count:
    count = count + 1
    #we need to keep track of a since we change it
    old_a = a
    old_b = b
    a = old_b
    b = old_a + old_b
    #Notice that the , at the end of a print statement keeps it
    # from switching to a new line
    print (old_a),

Fibonacci.py

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

輸出

# Waits until a password has been entered.  Use control-C to break out without
# the password.

# Note that this must not be the password so that the 
# while loop runs at least once.
password = "foobar"

#note that != means not equal
while password != "unicorn":
    password = input("Password: ")
print ("Welcome in")

Password.py

Password:auo
Password:y22
Password:password
Password:open sesame
Password:unicorn
Welcome in

示例執行

For 迴圈

[編輯 | 編輯原始碼]Python 中的下一種迴圈型別是forPython 中的下一種迴圈型別是迴圈。與大多數語言不同，需要一些__可迭代__物件，例如集合或列表

onetoten = range(1,11)
for count in onetoten:
    print (count)

才能工作。

1
2
3
4
5
6
7
8
9
10

輸出輸出看起來很熟悉，但程式程式碼看起來不同。第一行使用了range輸出看起來很熟悉，但程式程式碼看起來不同。第一行使用了函式。該函式使用兩個引數，如下所示. range(start,finish)start是產生的第一個數字。finish

for count in range(1,11):
    print (count)

比最後一個數字大 1。注意，這個程式可以用更短的方式實現輸出看起來很熟悉，但程式程式碼看起來不同。第一行使用了下面是一些例子，展示了該

>>> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(-32, -20)
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> range(5,21)
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> range(21,5)
[]

函式

的行為備註：對於當前版本的 Python，我們需要將 range 函式傳遞給 list() 才能實際列印一個列表。例如，我們需要使用 list(range(1,10)) 來獲得 [1, 2, 3, 4, 5, 6, 7, 8, 9]。在Python 中的下一種迴圈型別是迴圈中使用

for a in range(10):
    print (a)

range()

for a in range(0, 10):
    print (a)

函式的另一種方法是隻提供一個引數

0 1 2 3 4 5 6 7 8 9

上面的程式碼與Python 中的下一種迴圈型別是完全相同，隱式地將 0 作為起點。輸出為

程式碼將按預期迴圈 10 次，但從 0 開始而不是 1。下一行for count in onetotenPython 中的下一種迴圈型別是使用Python 中的下一種迴圈型別是控制結構。一個控制結構看起來像. for variable in listlistPython 中的下一種迴圈型別是從列表的第一個元素開始，一直到最後一個元素。當遍歷列表中的每個元素時，它會將每個元素放入variable遍歷列表中的每個元素時，它會將每個元素放入中。這允許

demolist = ['life',42, 'the universe', 6,'and',7,'everything']
for item in demolist:
    print ("The Current item is: %s" % item)

在每次執行 for 迴圈時使用。下面是另一個演示

The Current item is: life
The Current item is: 42
The Current item is: the universe
The Current item is: 6
The Current item is: and
The Current item is: 7
The Current item is: everything

的例子輸出為注意 for 迴圈是如何遍歷列表併為 item 設定每個元素的。（注意，如果你不想Python 中的下一種迴圈型別是print

list = [2,4,6,8]
sum = 0
for num in list:
    sum = sum + num
print ("The sum is: %d" % sum)

轉到下一行，在語句末尾新增逗號（即，如果你想在該行上列印其他內容）。）那麼，

The sum is:  20

有什麼用？第一個用途是遍歷列表的所有元素，並對每個元素執行操作。這裡有一個快速的方法，可以將所有元素加起來

list = [4, 5, 7, 8, 9, 1,0,7,10]
list.sort()
prev = list[0]
del list[0]
for item in list:
    if prev == item:
        print ("Duplicate of ",prev," Found")
    prev = item

輸出只是

Duplicate of  7  Found

或者你可以編寫一個程式，找出列表中是否存在任何重複項，就像這個程式所做的那樣

l = [4, 5, 7, 8, 9, 1,0,7,10]
print ("l = [4, 5, 7, 8, 9, 1,0,7,10]","\tl:",l)
l.sort()
print ("l.sort()","\tl:",l)
prev = l[0]
print ("prev = l[0]","\tprev:",prev)
del l[0]
print ("del l[0]","\tl:",l)
for item in l:
    if prev == item:
        print ("Duplicate of ",prev," Found")
    print ("if prev == item:","\tprev:",prev,"\titem:",item)
    prev = item
    print ("prev = item","\t\tprev:",prev,"\titem:",item)

為了確保萬無一失，

l = [4, 5, 7, 8, 9, 1,0,7,10]   l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort()        l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
prev = l[0]     prev: 0
del l[0]        l: [1, 4, 5, 7, 7, 8, 9, 10]
if prev == item:        prev: 0         item: 1
prev = item             prev: 1         item: 1
if prev == item:        prev: 1         item: 4
prev = item             prev: 4         item: 4
if prev == item:        prev: 4         item: 5
prev = item             prev: 5         item: 5
if prev == item:        prev: 5         item: 7
prev = item             prev: 7         item: 7
if prev == item:        prev: 7         item: 7
Duplicate of  7  Found
prev = item             prev: 7         item: 7
if prev == item:        prev: 7         item: 8
prev = item             prev: 8         item: 8
if prev == item:        prev: 8         item: 9
prev = item             prev: 9         item: 9
if prev == item:        prev: 9         item: 10
prev = item             prev: 10        item: 10

它是如何工作的？這裡有一個特殊的除錯版本輸出為輸出為

注意：之所以有這麼多

a = 1
b = 1
for c in range(1,10):
    print (a)
    n = a + b
    a = b
    b = n
print ("")

語句，是因為 print 語句可以在不同的時間顯示每個變數的值，並幫助除錯程式。首先，程式從一箇舊列表開始。接下來，程式對列表進行排序。這樣，任何重複項都會放在一起。程式然後初始化一個 prev(ious) 變數。接下來，列表的第一個元素被刪除，這樣第一個專案就不會被錯誤地認為是重複項。接下來進入 for 迴圈。列表中的每個專案都會被檢查，看它是否與之前的專案相同。如果相同，則表示找到了重複項。然後 prev 的值就會改變，這樣下次執行 for 迴圈時，prev 就是當前專案的前面那個專案。果然，7 被發現是一個重複項。

1
1
2
3
5
8
13
21
34

使用 for 迴圈的另一種方法是執行某些操作一定次數。下面是一些程式碼，用於打印出斐波那契數列的前 9 個數字Python 中的下一種迴圈型別是輸出令人驚訝while所有可以用Python 中的下一種迴圈型別是迴圈完成的事情，也可以用


迴圈完成，但是

迴圈提供了一種簡單的方法，可以遍歷列表中的所有元素或執行某些操作一定次數。

range 與 xrange

[編輯 | 編輯原始碼]

Python 3 注意：在 Python 3.x 中，沒有名為 xrange 的函式。相反，range 函式具有下面為 xrange 描述的行為。以下是適用於舊版 Python 2 的內容。

在上面，你被介紹了 range 函式，它返回指定範圍內所有整數的列表。假設你要編寫類似 range(0, 1000000) 的表示式：這將建立一個包含一百萬個整數的列表！這會佔用大量記憶體。

for i in xrange(0, 1000000):
    print(i)

通常，你確實需要處理非常廣泛範圍內的所有數字。但是你可能只需要一次處理一個數字；在處理完每個數字後，可以在獲取下一個數字之前從記憶體中將其丟棄。

為此，你可以使用 xrange 函式而不是 range。例如，以下簡單的迴圈

將列印從 0 到 999999 的一百萬個整數，但它將從 xrange 呼叫中一次獲取一個整數，而不是一次獲取所有整數作為單個列表，然後遍歷該列表。

這是一個迭代器的例子，它在需要時一次生成一個值，而不是一次生成所有值。當你學習更多關於 Python 的知識時，你會看到很多使用迭代器的例子，並且你會學會如何編寫自己的迭代器。

break 語句

[編輯 | 編輯原始碼]

一個 while 迴圈在每次進入迴圈體之前檢查其終止條件，如果條件變為 False，則終止。因此，迴圈體通常會迭代零次、一次或多次完整的迭代。

  1. 一個 for 迴圈對迭代器表示式返回的每個值迭代其主體一次。同樣，每次迭代通常都是對完整迴圈體的迭代。
  2. 有時你想在迴圈體的中間有條件地停止迴圈。一個示例情況可能如下所示
  3. 獲取要檢查的下一個值
  4. 實際上還有另一個值要檢查嗎？如果沒有，則退出迴圈並失敗。

該值是我要找的嗎？如果是，則退出迴圈併成功。

found = False # initial assumption
for value in values_to_check():
    if is_what_im_looking_for(value):
        found = True
        break
# ... found is True on success, False on failure

否則，返回步驟 1。

如你所見，從這個迴圈中有兩種可能的退出方式。你可以使用 break 語句從 Python while 或 for 迴圈的中間退出。下面是編寫此類迴圈的一種方法

這樣做的問題在於兩種退出迴圈的方式之間的不對稱性：一種是透過正常的 for 迴圈終止，另一種是透過 break。作為一種風格上的問題，更一致的做法是遵循以下原則

如果一個迴圈的退出是由 break 表示的，那麼所有迴圈的退出都應該由 break 表示。

values = iter(values_to_check())
while True:
    value = next(values, None)
    if value is None:
        found = False
        break
    if is_what_im_looking_for(value):
        found = True
        break
# ... found is True on success, False on failure

特別地，這意味著迴圈結構本身成為一個“永遠迴圈”；唯一的退出方式是透過 break 語句。

我們可以透過顯式地處理生成要檢查的值的迭代器來做到這一點。也許上面的 values_to_check() 呼叫已經生成了一個迭代器；如果沒有，可以透過將其包裝在對 iter() 內建函式的呼叫中，然後使用 next() 內建函式從該迭代器中獲取連續的值，將其轉換為迭代器。然後迴圈變為

這使用特殊的 Python 值 None 來指示迭代器已到達其末尾。這是一個常見的 Python 慣例。但如果你需要將 None 作為你的值序列中的有效專案，那麼很容易定義一些其他唯一的值（例如自定義的虛擬類）來表示列表的末尾。
  1. 編寫一個程式，以素數計數。請使用者輸入一個數字，然後打印出該數字之前的每個素數。
  2. 指示使用者從 1 到 100 中選擇一個任意數字，並在七次嘗試內猜出正確答案。在每次猜測之後，使用者必須告知他們的數字是否高於、低於或等於您的猜測。

解決方案

上一個: 條件語句 索引 下一個: 函式
檢索自 "https://wikibook.tw/w/index.php?title=Python_Programming/Loops&oldid=4352125"
華夏公益教科書