Python 的 while 迴圈提供了一種在特定條件下重複執行程式碼塊的機制。迴圈會持續執行，直到條件不再成立。For 迴圈則適用於迭代序列或其他可迭代物件，依序處理每個元素。Break 和 continue 陳述式可以更精細地控制迴圈流程，例如提前結束迴圈或跳過特定迭代。理解 Truthy 和 Falsey 值的概念，有助於更靈活地運用迴圈條件判斷。結合 range() 函式，可以更方便地控制迴圈迭代次數。這些迴圈控制結構是程式設計的基礎，掌握它們對於建構複雜的程式邏輯至關重要。
while 迴圈的運作原理
while 迴圈是一種控制結構，允許程式碼在某個條件成立的情況下重複執行。下面是一個簡單的 while 迴圈範例：
spam = 0
while spam < 5:
print('Hello, world.')
spam = spam + 1
這段程式碼會輸出 “Hello, world.” 五次。讓我們來分析一下這個過程：
- 初始化變數
spam為 0。 - 檢查條件
spam < 5，如果成立則進入迴圈。 - 執行迴圈內的程式碼，印出 “Hello, world."。
- 更新變數
spam的值，將其增加 1。 - 回到步驟 2，重新檢查條件
spam < 5。 - 如果條件仍然成立，則重複步驟 3-5。
- 如果條件不成立，則離開迴圈。
while 迴圈的流程圖
下面是 while 迴圈的流程圖：
@startuml
:初始化變數; --> :檢查條件;
:B; --> [True] :True;
:C; --> :更新變數;
:D; --> :B;
:B; --> [False] :False;
@enduml這個流程圖顯示了 while 迴圈的運作原理。當條件成立時，迴圈內的程式碼會被執行，然後更新變數的值。當條件不成立時，迴圈會離開。
一個煩人的 while 迴圈
下面是一個簡單的程式範例，示範了一個煩人的 while 迴圈：
name = ''
while name!= 'your name':
print('Please type your name.')
name = input('>')
print('Thank you!')
這段程式碼會不斷地要求使用者輸入名字，直到使用者輸入 “your name”。讓我們來分析一下這個過程：
- 初始化變數
name為空字串。 - 檢查條件
name!= 'your name'，如果成立則進入迴圈。 - 執行迴圈內的程式碼，印出 “Please type your name."。
- 讀取使用者的輸入，並將其指定給
name變數。 - 回到步驟 2，重新檢查條件
name!= 'your name'。 - 如果條件仍然成立，則重複步驟 3-5。
- 如果條件不成立，則離開迴圈，並印出 “Thank you!"。
圖表翻譯：
下面是這個程式的流程圖：
@startuml
:初始化變數; --> :檢查條件;
:B; --> [True] :True;
:C; --> :讀取使用者輸入;
:D; --> :B;
:B; --> [False] :False;
@enduml這個流程圖顯示了 while 迴圈的運作原理。當條件成立時，迴圈內的程式碼會被執行，然後讀取使用者的輸入。當條件不成立時，迴圈會離開，並印出感謝訊息。
使用 break 和 continue 陳述式控制 while 迴圈
在 Python 中，while 迴圈是一種用於重複執行程式碼的控制結構。然而，有時我們需要在迴圈中間終止或跳過某些程式碼的執行。這時，我們可以使用 break 和 continue 陳述式來控制 while 迴圈的流程。
break 陳述式
break 陳述式用於立即終止 while 迴圈的執行。當程式執行到 break 陳述式時，會立即跳出迴圈，繼續執行迴圈後面的程式碼。
以下是一個範例程式，示範如何使用 break 陳述式：
while True:
print('請輸入你的名字。')
name = input('> ')
if name == '你的名字':
break
print('謝謝！')
在這個範例中，while 迴圈的條件是 True，所以迴圈會一直執行，直到遇到 break 陳述式。如果使用者輸入的名字是 '你的名字'，則會執行 break 陳述式，立即終止迴圈，然後執行 print('謝謝！')。
continue 陳述式
continue 陳述式用於跳過當前迴圈的剩餘程式碼，直接跳到下一次迴圈的開始。當程式執行到 continue 陳述式時，會立即跳過當前迴圈的剩餘程式碼，繼續執行下一次迴圈。
以下是一個範例程式，示範如何使用 continue 陳述式：
while True:
print('請輸入你的名字和密碼。')
name = input('> ')
password = input('> ')
if name!= '你的名字' or password!= '你的密碼':
continue
print('登入成功！')
在這個範例中，如果使用者輸入的名字或密碼不正確，則會執行 continue 陳述式，跳過當前迴圈的剩餘程式碼，直接跳到下一次迴圈的開始。
內容解密：
break陳述式可以用於立即終止 while 迴圈。continue陳述式可以用於跳過當前迴圈的剩餘程式碼。- 這兩個陳述式可以幫助我們更好地控制程式的流程。
圖表翻譯：
@startuml
:開始; --> :輸入名字和密碼;
:B; --> :檢查名字和密碼;
:C; --> [正確] :正確;
:C; --> [不正確] :不正確;
:E; --> :B;
@enduml在這個圖表中，我們可以看到 while 迴圈的流程。如果使用者輸入的名字和密碼正確，則會登入成功。如果不正確，則會繼續迴圈，直到使用者輸入正確的名字和密碼。
使用 Continue 和 Break 陳述式控制迴圈
在 Python 中，continue 和 break 是兩個重要的陳述式，分別用於控制迴圈的執行。下面是一個範例程式，展示瞭如何使用這兩個陳述式：
print('誰是你？')
name = input('>')
if name!= 'Joe':
continue
print('Hello, Joe. 什麼是密碼？（它是一種魚。）')
password = input('>')
if password == 'swordfish':
break
print('存取授權。')
在這個範例中，如果使用者輸入的名字不是 Joe，程式會執行 continue 陳述式，跳回迴圈的開始處。當使用者輸入正確的密碼（swordfish）時，程式會執行 break 陳述式，跳出迴圈並印出「存取授權」。
Truthy 和 Falsey 值
在 Python 中，一些值可以被視為 True 或 False，即使它們不是布林值。例如，0、0.0 和空字串 ('') 被視為 False，而其他值被視為 True。下面是一個範例程式，展示瞭如何使用這些值：
name = ''
while not name:
print('請輸入你的名字：')
name = input('>')
num_of_guests = 5
if num_of_guests:
print('你有嘉賓！')
print(bool('')) # False
print(bool(0)) # False
print(bool(5)) # True
在這個範例中，如果 name 是空字串，迴圈會繼續執行，直到使用者輸入一個非空字串。如果 num_of_guests 不是 0，程式會印出「你有嘉賓！」。
使用 Bool() 函式
如果你想知道一個值是否為 Truthy 或 Falsey，可以使用 bool() 函式。下面是一個範例：
print(bool('')) # False
print(bool(0)) # False
print(bool(5)) # True
這個函式會將輸入的值轉換為布林值，True 或 False。
使用 for 迴圈和 range() 函式
當您想要執行一段程式碼的特定次數時，可以使用 for 迴圈和 range() 函式。for 迴圈的語法如下：
for 變數名稱 in range(次數):
# 要執行的程式碼
其中，變數名稱 是一個暫時的變數名稱，range(次數) 是一個函式，會產生一個從 0 到 次數-1 的整數序列。
range() 函式
range() 函式是一個內建函式，會產生一個整數序列。它的語法如下：
range(起始值, 結束值, 步長)
其中，起始值 是序列的起始值，結束值 是序列的結束值，步長 是每個整數之間的差值。
for 迴圈範例
以下是使用 for 迴圈和 range() 函式的範例：
for i in range(5):
print(i)
這個程式碼會輸出：
0
1
2
3
4
因為 range(5) 會產生一個從 0 到 4 的整數序列。
布林值
在 Python 中，布林值（Boolean）是一種特殊的資料型態，代表 true 或 false。布林值可以使用 bool() 函式來轉換。以下是幾個範例：
print(bool(0)) # False
print(bool(42)) # True
print(bool('Hello')) # True
print(bool('')) # False
布林值在條件判斷中非常重要，後面會再詳細介紹。
while 迴圈和 for 迴圈的比較
while 迴圈和 for 迴圈都是用來執行一段程式碼的，但它們的差異在於 while 迴圈是根據條件來決定是否繼續執行，而 for 迴圈是根據特定的次數來執行。以下是兩者的比較：
# while 迴圈
i = 0
while i < 5:
print(i)
i += 1
# for 迴圈
for i in range(5):
print(i)
兩個程式碼都會輸出相同的結果，但 while 迴圈需要手動更新變數 i，而 for 迴圈則不需要。
使用for迴圈進行迭代
for迴圈是一種用於迭代的控制結構，允許您重複執行一段程式碼。下面是for迴圈的基本結構：
for 變數 in 可迭代物件:
# 執行的程式碼
其中，變數是用於儲存每次迭代的值的變數，可迭代物件是可以被迭代的物件，例如列表、字串或範圍。
範圍（range）函式
範圍函式是一種用於生成一系列數字的函式。它的基本結構如下：
range(起始值, 結束值, 步長)
其中，起始值是範圍的起始值，結束值是範圍的結束值，步長是每次遞增的步長。
for迴圈範例
下面是一個使用for迴圈和範圍函式的範例：
for i in range(5):
print(f"On this iteration, i is set to {i}")
這個程式碼會輸出：
On this iteration, i is set to 0
On this iteration, i is set to 1
On this iteration, i is set to 2
On this iteration, i is set to 3
On this iteration, i is set to 4
break和continue陳述式
在for迴圈中，您可以使用break和continue陳述式來控制迭代的流程。break陳述式會終止迭代，而continue陳述式會跳過當前的迭代並繼續下一次迭代。
Carl Friedrich Gauss的故事
有一個故事關於數學家Carl Friedrich Gauss，他曾經被要求計算從0到100的所有數字的總和。他想出了一個巧妙的方法來計算這個總和，但您也可以使用Python程式來計算：
total = 0
for num in range(101):
total += num
print(total)
這個程式碼會輸出：5050
為什麼是“上到但不包含”？
在程式設計中，範圍通常使用“閉開”格式，即包括起始值但排除結束值。例如，範圍0到10包含數字0到9，而不是0到10。這種格式有很多優點，可以減少錯誤。計算範圍的大小隻需從結束值中減去起始值即可。例如，範圍0到10包含10個數字（0到9）。
圖表翻譯：
@startuml
:開始; --> :for迴圈;
:B; --> :執行程式碼;
:C; --> :是否完成;
:D; --> [是] :是;
:D; --> [否] :否;
@enduml這個圖表顯示了for迴圈的流程。首先，程式開始執行for迴圈，然後執行程式碼。如果迭代完成，則結束；否則，繼續下一次迭代。
使用range()函式進行迴圈
在Python中，range()函式是一個非常有用的工具，讓我們可以輕鬆地進行迴圈。它可以讓我們指定一個範圍，並且根據這個範圍進行迴圈。
基本使用
range()函式可以接受一個或多個引數。當只傳入一個引數時，它會從0開始，直到但不包括該引數為止。例如：
for i in range(5):
print(i)
這會輸出：
0
1
2
3
4
指定起始值
如果我們想要從一個特定的數字開始，可以傳入兩個引數。第一個引數是起始值，第二個引數是結束值（不包括）。例如：
for i in range(12, 16):
print(i)
這會輸出：
12
13
14
15
指定步長
如果我們想要指定步長，可以傳入三個引數。第一個引數是起始值，第二個引數是結束值（不包括），第三個引數是步長。例如：
for i in range(12, 16, 2):
print(i)
這會輸出：
12
14
使用while迴圈模擬for迴圈
雖然for迴圈更為方便，但我們也可以使用while迴圈來模擬for迴圈的行為。例如：
i = 0
while i < 5:
print(i)
i += 1
這會輸出：
0
1
2
3
4
內容解密：
在上面的例子中，我們使用while迴圈來模擬for迴圈的行為。變數i被初始化為0，並且在每次迴圈中增加1，直到i小於5為止。
使用 Python 的 range() 函式進行迴圈
Python 的 range() 函式是一個非常強大的工具，能夠幫助我們建立迴圈。下面是一個範例：
for i in range(0, 10, 2):
print(i)
這個迴圈會從 0 到 8，間隔 2，印出每個數字。
使用 range() 函式進行倒數
如果你想讓迴圈從大到小進行倒數，可以使用負數作為間隔。例如：
for i in range(5, -1, -1):
print(i)
這個迴圈會從 5 到 0，間隔 -1，印出每個數字。
匯入模組
Python 有一個豐富的標準函式庫，包含了許多有用的模組。你可以使用 import 陳述式匯入模組。例如：
import random
這樣你就可以使用 random 模組中的函式了。
使用 random 模組
random 模組中有一個很有用的函式叫做 randint()，可以生成一個隨機整數。例如：
import random
for i in range(5):
print(random.randint(1, 10))
這個迴圈會生成 5 個隨機整數，介於 1 到 10 之間。
結束程式
如果你想在程式執行過程中結束程式，可以使用 sys.exit() 函式。例如：
import sys
print("結束程式")
sys.exit()
這樣程式就會立即結束。
內容解密：
上述程式碼展示瞭如何使用 range() 函式進行迴圈、倒數和匯入模組等。同時，也介紹瞭如何使用 random 模組生成隨機整數和結束程式。
圖表翻譯：
@startuml
:開始; --> :匯入模組;
:B; --> :使用 range() 函式;
:C; --> :使用 random 模組;
:D; --> :結束程式;
:E; --> :結束;
@enduml這個流程圖展示了程式的執行流程，從匯入模組到結束程式。
猜數遊戲：基礎程式設計概念的實踐
在這個章節中，我們將探討一個簡單的猜數遊戲，該遊戲結合了前面所學的基本程式設計概念。當你執行這個程式時，輸出將類別似於以下內容：
我正在想一個1到20之間的數字。
猜一個數字。
>10
你的猜測太低了。
猜一個數字。
>15
你的猜測太低了。
猜一個數字。
>17
你的猜測太高了。
猜一個數字。
>16
做得好！你只用了4次猜測就猜對了！
現在，讓我們來看看實作這個遊戲的原始碼。請在檔案編輯器中輸入以下程式碼，並將檔案儲存為 guessTheNumber.py：
# 這是一個猜數遊戲。
import random
secret_number = random.randint(1, 20)
print('我正在想一個1到20之間的數字。')
# 問玩家猜6次。
for guesses_taken in range(1, 7):
print('猜一個數字。')
guess = int(input('>'))
if guess < secret_number:
print('你的猜測太低了。')
elif guess > secret_number:
print('你的猜測太高了。')
else:
print(f'做得好！你只用了{guesses_taken}次猜測就猜對了！')
break
else:
print('抱歉，你沒有猜對。正確答案是' + str(secret_number) + '。')
內容解密：
這個程式使用 random.randint(1, 20) 生成一個1到20之間的隨機數字，並將其儲存在 secret_number 變數中。然後，程式使用 for 迴圈讓玩家猜6次。
在每次迭代中，程式會要求玩家猜一個數字，並使用 input() 函式取得玩家的輸入。然後，程式會比較玩家的猜測與 secret_number，並根據比較結果列印預出相應的訊息。如果玩家的猜測與 secret_number 相等，程式會列印預出祝賀訊息並終止迴圈。
如果玩家沒有在6次猜測中猜對，程式會列印預出抱歉訊息，並顯示正確答案。
圖表翻譯：
@startuml
:開始; --> :生成隨機數字;
:B; --> :初始化迴圈;
:C; --> :要求玩家猜數字;
:D; --> :比較玩家猜測與秘密數字;
:E; --> [猜測太低] :猜測太低;
:E; --> [猜測太高] :猜測太高;
:E; --> [猜測正確] :猜測正確;
:F; --> :D;
:G; --> :D;
:H; --> :結束;
@enduml這個流程圖展示了程式的邏輯流程，從生成隨機數字到要求玩家猜數字，然後比較玩家猜測與秘密數字，最後列印預出相應的訊息或終止迴圈。
猜數遊戲程式剖析
首先，我們來看看這個猜數遊戲的程式碼。這個程式的目的是讓使用者猜一個由程式隨機產生的數字。
程式結構
程式一開始就有一行註解，解釋了這個程式的功能。接下來，程式匯入了 random 模組，以便使用 randint() 函式產生一個隨機數字。
import random
secret_number = random.randint(1, 20)
這裡，secret_number 是一個變數，儲存著由 randint(1, 20) 產生的隨機整數，範圍從 1 到 20。
使用者輸入與比較
使用者被提示輸入一個猜測的數字：
print('Take a guess.')
guess = int(input('>'))
input() 函式用於取得使用者的輸入，並將其轉換為整數儲存在 guess 變數中。
接下來，程式比較使用者的猜測與秘密數字：
if guess < secret_number:
print('Your guess is too low.')
elif guess > secret_number:
print('Your guess is too high.')
else:
# 當猜測正確時的處理
pass
如果使用者的猜測太低或太高，程式會分別提示「太低」或「太高」。如果猜測正確，則會執行 else 區塊中的程式碼。
迴圈與多次猜測
雖然原始碼中沒有明確展示出來，但這個遊戲其實允許使用者進行多次猜測。通常，這會透過一個 for 迴圈實作，讓使用者有六次機會來猜對秘密數字。
for _ in range(6):
# 猜測與比較的程式碼放在這裡
每次迴圈，使用者都會被提示輸入一個新的猜測，並且與秘密數字進行比較。如果使用者在六次機會內猜對了，程式會告知使用者並結束；否則，程式會揭露秘密數字。
if guess == secret_number:
print('Good job! You got it in ' + str(guesses) + ' guesses.')
else:
print('Nope. The number was ' + str(secret_number))
猜數字遊戲與剪刀石頭布
猜數字遊戲
在這個遊戲中，玩家需要猜一個介於1到20之間的秘密數字。系統會根據玩家的猜測給出提示，告訴玩家猜的數字是太高還是太低。
secret_number = 15 # 秘密數字
for guesses_taken in range(1, 7): # 玩家有6次猜的機會
print('Take a guess.') # 提示玩家猜數字
guess = int(input('>')) # 讀取玩家的猜測
if guess < secret_number: # 如果猜的數字太低
print('Your guess is too low.') # 給出提示
elif guess > secret_number: # 如果猜的數字太高
print('Your guess is too high.') # 給出提示
else: # 如果猜對了
print('Good job! You got it in ' + str(guesses_taken) + ' guesses.') # 恭喜玩家
break # 結束遊戲
else: # 如果玩家用完所有猜測機會還沒猜對
print('Nope. The number was ' + str(secret_number)) # 告訴玩家正確答案
剪刀石頭布遊戲
接下來，我們來實作一個簡單的剪刀石頭布遊戲。遊戲規則如下：剪刀剪勝布，布包勝石頭，石頭砸勝剪刀。
import random
while True: # 不斷遊戲直到玩家決定離開
print('Enter your choice (rock/paper/scissors):') # 提示玩家輸入選擇
user_choice = input('> ').lower() # 讀取玩家的選擇並轉換為小寫
while user_choice not in ['rock', 'paper', 'scissors']: # 如果玩家的選擇不正確
print('Invalid input. Please enter rock, paper or scissors.') # 提示玩家重新輸入
user_choice = input('> ').lower()
possible_choices = ['rock', 'paper', 'scissors'] # 可能的選擇
computer_choice = random.choice(possible_choices) # 電腦隨機選擇
print(f'\nYou chose {user_choice}, computer chose {computer_choice}.\n') # 顯示玩家和電腦的選擇
if user_choice == computer_choice: # 如果玩家和電腦選擇相同
print(f'Both players selected {user_choice}. It\'s a tie!') # 平局
elif user_choice == 'rock': # 如果玩家選擇石頭
if computer_choice == 'scissors': # 如果電腦選擇剪刀
print('Rock smashes scissors! You win!') # 玩家贏
else: # 如果電腦選擇布
print('Paper covers rock! You lose.') # 玩家輸
elif user_choice == 'paper': # 如果玩家選擇布
if computer_choice == 'rock': # 如果電腦選擇石頭
print('Paper covers rock! You win!') # 玩家贏
else: # 如果電腦選擇剪刀
print('Scissors cuts paper! You lose.') # 玩家輸
elif user_choice == 'scissors': # 如果玩家選擇剪刀
if computer_choice == 'paper': # 如果電腦選擇布
print('Scissors cuts paper! You win!') # 玩家贏
else: # 如果電腦選擇石頭
print('Rock smashes scissors! You lose.') # 玩家輸
play_again = input('Play again? (yes/no): ') # 問玩家是否要再玩一次
if play_again.lower()!= 'yes': # 如果玩家不想再玩
break # 結束遊戲
圖表翻譯：
@startuml
:開始; --> :猜數字;
:B; --> :檢查猜測;
:C; --> [正確] :正確;
:C; --> [錯誤] :錯誤;
:E; --> :結束遊戲;
:F; --> :再次開始;
:開始; --> :剪刀石頭布;
:I; --> :玩家選擇;
:J; --> :電腦選擇;
:K; --> :比較選擇;
:L; --> [平局] :平局;
:L; --> [玩家贏] :玩家贏;
:L; --> [電腦贏] :電腦贏;
@enduml這個圖表展示了猜數字遊戲和剪刀石頭布遊戲的流程。
剪刀石頭布遊戲實作
剪刀石頭布是一種經典的猜拳遊戲，兩位玩家同時出拳，根據出拳的規則決定勝負。下面是使用Python實作的剪刀石頭布遊戲程式碼。
遊戲規則
- 剪刀（scissors）贏布（paper）
- 布（paper）贏石頭（rock）
- 石頭（rock）贏剪刀（scissors）
程式碼實作
import random
print('ROCK, PAPER, SCISSORS')
# 初始化勝負記錄
wins = 0
losses = 0
ties = 0
while True: # 主遊戲迴圈
print('%s Wins, %s Losses, %s Ties' % (wins, losses, ties))
# 玩家輸入迴圈
while True:
print('Enter your move: (r)ock (p)aper (s)cissors or (q)uit')
player_move = input('> ').lower()
if player_move == 'q':
print('Thanks for playing!')
sys.exit()
if player_move not in ['r', 'p', 's']:
print('Invalid input. Please enter r, p, or s.')
continue
# 電腦隨機出拳
computer_move = random.choice(['r', 'p', 's'])
# 顯示出拳結果
print('You chose: ' + player_move)
print('Computer chose: ' + computer_move)
# 判斷勝負
if player_move == computer_move:
print('It is a tie!')
ties += 1
elif (player_move == 'r' and computer_move == 's') or \
(player_move == 's' and computer_move == 'p') or \
(player_move == 'p' and computer_move == 'r'):
print('You win!')
wins += 1
else:
print('You lose!')
losses += 1
break # 結束玩家輸入迴圈
內容解密：
上述程式碼使用Python語言實作了剪刀石頭布遊戲。遊戲中，玩家可以輸入自己的出拳選擇，電腦則會隨機出拳。根據出拳規則，判斷勝負並更新勝負記錄。玩家可以繼續遊戲直到選擇離開。
圖表翻譯：
@startuml
:開始; --> :玩家輸入;
:B; --> :電腦出拳;
:C; --> :判斷勝負;
:D; --> :更新記錄;
:E; --> :繼續遊戲;
:F; --> :B;
@enduml此圖表展示了遊戲的流程，從玩家輸入開始，到電腦出拳、判斷勝負、更新記錄，最後回到玩家輸入繼續遊戲。
建立一款根據Python的石頭剪刀布遊戲
遊戲邏輯概述
在這款遊戲中，玩家可以與電腦對戰。遊戲的核心邏輯是根據玩家和電腦的選擇（石頭、紙或剪刀）來決定勝負。
玩家輸入處理
player_move = input('> ')
這行程式碼用於接收玩家的輸入。玩家可以輸入 'r' 代表石頭， 'p' 代表紙， 's' 代表剪刀，或者 'q' 來離開遊戲。
離開遊戲邏輯
if player_move == 'q':
sys.exit() # 離開程式
如果玩家輸入 'q'，則立即離開遊戲。
玩家輸入驗證
if player_move not in ['r', 'p', 's']:
print('請輸入 r、p、s 或 q。')
這段程式碼用於驗證玩家的輸入。如果玩家輸入的內容不是 'r'、'p' 或 's'，則提示玩家輸入正確的選擇。
顯示玩家選擇
if player_move == 'r':
print('石頭 對戰...')
elif player_move == 'p':
print('紙 對戰...')
elif player_move == 's':
print('剪刀 對戰...')
根據玩家的選擇，顯示相應的選擇資訊。
電腦選擇邏輯
import random
move_number = random.randint(1, 3)
if move_number == 1:
computer_move = 'r'
print('石頭')
elif move_number == 2:
computer_move = 'p'
print('紙')
elif move_number == 3:
computer_move = 's'
print('剪刀')
電腦的選擇是透過生成一個隨機數字（1、2 或 3）來決定。如果是 1，則電腦選擇石頭；如果是 2，則選擇紙；如果是 3，則選擇剪刀。
圖表翻譯：
@startuml
:開始; --> :玩家輸入;
:B; --> :C;
:C; --> [r] :r;
:C; --> [p] :p;
:C; --> [s] :s;
:C; --> [其他] :其他;
:D; --> :電腦選擇;
:E; --> :H;
:F; --> :H;
:H; --> :I;
:H; --> :J;
:H; --> :K;
:I; --> :顯示結果;
:J; --> :L;
:K; --> :L;
@enduml這個流程圖描述了遊戲的主要邏輯流程，從玩家輸入到電腦選擇和顯示結果的整個過程。
完整遊戲程式碼
import sys
import random
while True:
player_move = input('> ')
if player_move == 'q':
sys.exit()
if player_move not in ['r', 'p', 's']:
print('請輸入 r、p、s 或 q。')
continue
if player_move == 'r':
print('石頭 對戰...')
elif player_move == 'p':
print('紙 對戰...')
elif player_move == 's':
print('剪刀 對戰...')
move_number = random.randint(1, 3)
if move_number == 1:
computer_move = 'r'
print('石頭')
elif move_number == 2:
computer_move = 'p'
print('紙')
elif move_number == 3:
computer_move = 's'
print('剪刀')
# 根據玩家和電腦的選擇決定勝負
if player_move == computer_move:
print('平局!')
elif (player_move == 'r' and computer_move == 's') or \
(player_move == 's' and computer_move == 'p') or \
(player_move == 'p' and computer_move == 'r'):
print('你贏了!')
else:
print('電腦贏了!')
這個完整的程式碼包含了所有必要的邏輯，包括玩家輸入處理、電腦選擇、勝負判斷等。
石頭剪刀布遊戲：勝負判斷與記錄
在石頭剪刀布遊戲中，根據玩家和電腦的出拳進行勝負判斷是關鍵的一步。以下是如何根據出拳結果進行判斷和記錄的示例：
判斷勝負
if player_move == computer_move:
print('It is a tie!')
ties = ties + 1
elif player_move == 'r' and computer_move == 's':
print('You win! Rock smashes scissors.')
wins = wins + 1
elif player_move == 'p' and computer_move == 'r':
print('You win! Paper covers rock.')
wins = wins + 1
elif player_move == 's' and computer_move == 'p':
print('You win! Scissors cuts paper.')
wins = wins + 1
else:
print('You lose!')
losses = losses + 1
內容解密：
if player_move == computer_move:這行檢查玩家和電腦的出拳是否相同，如果相同則為平局。elif條件用於檢查玩家勝的情況，例如player_move == 'r' and computer_move == 's'表示玩家出石頭而電腦出剪刀，根據遊戲規則，石頭可以壓碎剪刀，所以玩家贏。wins = wins + 1和ties = ties + 1分別用於記錄玩家的勝場和平局次數。else條件用於處理玩家敗的情況，印出 “You lose!” 並記錄敗場次數。
圖表翻譯：
@startuml
:開始; --> :B;
:B; --> :C;
:C; --> :D;
:D; --> :E;
:D; --> :F;
:D; --> :G;
:E; --> :記錄勝場;
:F; --> :記錄敗場;
:G; --> :記錄平局;
@enduml圖表翻譯：
- 圖表描述了從開始到記錄結果的流程。
B和C分別代表玩家和電腦的出拳。D是判斷勝負的關鍵步驟，根據出拳結果決定流程的下一步。E、F和G分別對應玩家勝、敗和平局的情況，並分別記錄結果。
程式碼分析：贏、輸與平局記錄
import random, sys
print('ROCK, PAPER, SCISSORS')
# 初始化記錄變數
wins = 0
losses = 0
ties = 0
在這段程式碼中，我們首先匯入了 random 和 sys 模組，分別用於生成隨機數字和終止程式。接下來，我們初始化了三個變數：wins、losses 和 ties，用於記錄玩家贏、輸和平局的次數。
玩家選擇與電腦選擇的比較
elif player_move == 's' and computer_move == 'p':
print('You win!')
wins = wins + 1
elif player_move == 'r' and computer_move == 's':
print('You lose!')
losses = losses + 1
elif player_move == 'p' and computer_move == 'r':
print('You lose!')
losses = losses + 1
在這段程式碼中，我們使用 elif 陳述式來比較玩家選擇 (player_move) 和電腦選擇 (computer_move)。根據遊戲規則，當玩家選擇「剪刀」 (s) 而電腦選擇「紙」 (p) 時，玩家贏；當玩家選擇「石頭」 (r) 而電腦選擇「剪刀」 (s) 時，玩家輸；當玩家選擇「紙」 (p) 而電腦選擇「石頭」 (r) 時，玩家也輸。在每種情況下，我們都會印出相應的結果，並更新 wins 或 losses 變數。
圖表翻譯：贏、輸與平局記錄流程
@startuml
:初始化記錄變數; --> :玩家選擇與電腦選擇的比較;
:B; --> :C;
:C; --> :印出贏的結果並更新 wins 變數;
:B; --> :E;
:E; --> :印出輸的結果並更新 losses 變數;
:B; --> :G;
:G; --> :印出平局的結果並更新 ties 變數;
@enduml這個流程圖展示了贏、輸與平局記錄的流程。首先，我們初始化記錄變數，然後比較玩家選擇和電腦選擇。如果玩家贏，我們印出贏的結果並更新 wins 變數。如果玩家輸，我們印出輸的結果並更新 losses 變數。如果是平局，我們印出平局的結果並更新 ties 變數。
建立一個根據Python的石頭、剪刀、布遊戲
遊戲邏輯概述
石頭、剪刀、布是一種簡單的猜拳遊戲，兩位玩家同時出招，根據出招的規則決定勝負。以下是基本規則：
- 石頭勝剪刀
- 剪刀勝布
- 布勝石頭
程式碼實作
import random
import sys
# 初始化勝負記錄
wins = 0
losses = 0
ties = 0
while True: # 主遊戲迴圈
print(f'{wins} 勝, {losses} 敗, {ties} 平')
while True: # 玩家輸入迴圈
print('請輸入您的選擇: (r)石頭 (p)布 (s)剪刀 (q)離開')
player_move = input('> ').lower()
if player_move == 'q':
sys.exit() # 離開程式
elif player_move not in ['r', 'p', 's']:
print('請輸入 r, p, s 或 q。')
continue
break # 跳出玩家輸入迴圈
# 顯示玩家選擇
if player_move == 'r':
print('石頭 對戰...')
elif player_move == 'p':
print('布 對戰...')
elif player_move == 's':
print('剪刀 對戰...')
# 電腦隨機選擇
choices = ['r', 'p', 's']
computer_move = random.choice(choices)
# 顯示電腦選擇
if computer_move == 'r':
print('石頭!')
elif computer_move == 'p':
print('布!')
elif computer_move == 's':
print('剪刀!')
# 判斷勝負
if player_move == computer_move:
print('平!')
ties += 1
elif (player_move == 'r' and computer_move == 's') or \
(player_move == 's' and computer_move == 'p') or \
(player_move == 'p' and computer_move == 'r'):
print('您贏了!')
wins += 1
else:
print('您輸了!')
losses += 1
內容解密：
此程式使用兩個迴圈：主遊戲迴圈和玩家輸入迴圈。主遊戲迴圈控制整個遊戲的流程，而玩家輸入迴圈確保玩家輸入有效的選擇。玩家的選擇和電腦的隨機選擇都會被顯示出來，然後根據規則判斷勝負，並更新勝負記錄。
圖表翻譯：
@startuml
:開始; --> :顯示勝負記錄;
:B; --> :玩家輸入選擇;
:C; --> :D;
:D; --> [是] :是;
:D; --> [否] :否;
:E; --> :電腦隨機選擇;
:F; --> :顯示電腦選擇;
:G; --> :判斷勝負;
:H; --> :更新勝負記錄;
:I; --> :A;
@enduml圖表說明：
此流程圖描述了石頭、剪刀、布遊戲的流程。從開始到顯示勝負記錄，然後進入玩家輸入選擇的迴圈，直到玩家輸入有效選擇。接下來，顯示玩家選擇，電腦隨機選擇，顯示電腦選擇，判斷勝負，更新勝負記錄，最後回到開始。
電腦選擇的顯示
電腦的選擇是透過 random.randint(1, 3) 這個函式來隨機產生的。這個函式會回傳一個 1 到 3 之間的隨機整數，並將其存入 move_number 這個變數中。接著，根據 move_number 的值，程式會將相應的字串 (‘r’、‘p’ 或 ’s’) 存入 computer_move 這個變數中，並且印出電腦的選擇。
import random
# 電腦的選擇
move_number = random.randint(1, 3)
if move_number == 1:
computer_move = 'r'
print('ROCK')
elif move_number == 2:
computer_move = 'p'
print('PAPER')
elif move_number == 3:
computer_move = 's'
print('SCISSORS')
顯示和記錄勝負結果
接下來，程式會根據玩家和電腦的選擇來判斷勝負結果。如果玩家和電腦的選擇相同，則印出 “It is a tie!"，並且將 ties 這個變數加 1，以記錄平局的次數。
# 顯示和記錄勝負結果
if player_move == computer_move:
print('It is a tie!')
ties = ties + 1
內容解密：
在這段程式碼中，我們使用 random.randint(1, 3) 來產生電腦的隨機選擇。然後，根據這個隨機數字，我們決定電腦的選擇是 ‘r’、‘p’ 還是 ’s’，並且印出相應的選擇。最後，如果玩家和電腦的選擇相同，我們就印出 “It is a tie!"，並且增加 ties 的值，以記錄平局的次數。
圖表翻譯：
@startuml
:開始; --> :產生電腦選擇;
:B; --> :判斷勝負;
:C; --> :D;
:D; --> [是] :是;
:D; --> [否] :否;
:E; --> :增加 ties 值;
:F; --> :印出勝負結果;
@enduml這個流程圖描述了程式的執行流程，從產生電腦選擇到判斷勝負和記錄平局的次數。
獨立程式碼區塊
# 玩家選擇與電腦選擇的比較
if player_move == 'r' and computer_move == 's':
print('You win!')
wins = wins + 1
elif player_move == 'p' and computer_move == 'r':
print('You win!')
wins = wins + 1
elif player_move == 's' and computer_move == 'p':
print('You win!')
wins = wins + 1
elif player_move == 'r' and computer_move == 'p':
print('You lose!')
losses = losses + 1
elif player_move == 'p' and computer_move == 's':
print('You lose!')
losses = losses + 1
elif player_move == 's' and computer_move == 'r':
print('You lose!')
losses = losses + 1
內容解密：
在這個程式碼區塊中，我們實作了玩家選擇與電腦選擇的比較。根據「石頭、紙、剪刀」的規則，當玩家選擇「石頭」（‘r’）而電腦選擇「剪刀」（’s’）時，玩家贏；當玩家選擇「紙」（‘p’）而電腦選擇「石頭」（‘r’）時，玩家贏；當玩家選擇「剪刀」（’s’）而電腦選擇「紙」（‘p’）時，玩家贏。相反，如果玩家選擇「石頭」（‘r’）而電腦選擇「紙」（‘p’）時，玩家輸；如果玩家選擇「紙」（‘p’）而電腦選擇「剪刀」（’s’）時，玩家輸；如果玩家選擇「剪刀」（’s’）而電腦選擇「石頭」（‘r’）時，玩家輸。根據比較結果，我們分別增加勝利（wins）或失敗（losses）的計數器。
流程圖
@startuml
:開始; --> :玩家選擇;
:B; --> :電腦選擇;
:C; --> :比較選擇;
:D; --> :玩家贏;
:D; --> :玩家輸;
:E; --> :增加勝利計數;
:F; --> :增加失敗計數;
:G; --> :結束;
:H; --> :I;
@enduml圖表翻譯：
這個流程圖描述了「石頭、紙、剪刀」遊戲的流程。遊戲從開始（A）開始，然後玩家進行選擇（B），接著電腦進行選擇（C）。然後，程式比較玩家和電腦的選擇（D），根據比較結果，決定玩家是否贏（E）或輸（F）。如果玩家贏，則增加勝利計數（G）；如果玩家輸，則增加失敗計數（H）。最終，遊戲結束（I）。
從技術架構視角來看，while 迴圈的本質是根據條件判斷的程式碼重複執行機制。本文深入剖析了 while 迴圈的運作原理、流程控制、以及與 for 迴圈的比較，並以猜數字和剪刀石頭布遊戲為例，展示了迴圈的實際應用。然而，while 迴圈的靈活性也伴隨著潛在風險，例如無限迴圈的產生。程式開發者需要仔細設計迴圈條件和終止條件，才能避免程式陷入死迴圈。對於初學者，建議先從簡單的迴圈開始練習，逐步掌握迴圈的精髓。展望未來，隨著程式語言的發展，迴圈結構可能會出現更簡潔、更安全的表達方式，但其核心思想——根據條件的重複執行——將始終保持不變。玄貓認為，熟練掌握 while 迴圈是程式設計的基礎，也是通往進階程式設計的必經之路。對於追求程式碼效率的開發者，更需要深入理解迴圈的底層機制，才能寫出效能更優的程式碼。
