if、elif、else：目錄

• 比較【使用 if、elif、else 】
  • Python 縮排
  • 檢查布林變數的值，並印出對應的文字【使用布林值(True/False)、條件比較（if/else）、print()】
  • 測試項中加入測試項，依照需求使用的階層數目【使用 if、else】
  • 三個以上的可能性測試【使用 if、elif（意思是else if）、else】
• 測試相等與否【使用比較運算子】
  • 測試「比較運算子」→ 回傳「布林值 True 或 False」
  • 同時做多個比較，先「計算」後「比較」【布林運算子、and、or、not】
  • 「多個比較式」及「and」→ 成為一個變數
• 什麼是True？
  • True 與否/ False 與否
  • 計算運算式（不是簡單的變數），回傳布林結果
• 重複執行【使用 while】
  • 迴圈
  • 取消【使用 break】
    • 範例：【無窮迴圈 + break 陳述式 + input()函式 + 首字母改成大寫】
  • 取消【使用 break】
  • 跳過【使用 continue】
    • 範例：【迴圈 + break 陳述式 + input()函式 + continue + print()】
  • 檢查中斷【使用 else】
    • 範例：【迴圈 + len() + print() + break 陳述式 + else】
• 迭代【使用 for】
  • 迭代串列（每次會產生一個項目 → 逐一查看序列）
    • 方法一：【使用串列、while、len()、print()】
    • 方法二：【使用串列、for、in、print()】
  • 迭代字串（一次產生一個字元）
  • 迭代字典（或它的 keys()函式）→ 回傳鍵
  • 迭代字典的值，而不是鍵【使用字典 value() 函式】→ 回傳值，而不是鍵
  • 迭代字典【使用 items() 函式】→ 用 tuple 回傳鍵與值
  • 一個步驟來對一個 tuple 賦值【使用 items() 函式】
    • 取消【使用 break】
    • 跳過【使用 continue】
    • 檢查中斷【使用 else】
  • 迭代多個序列【使用 zip()】
    • 「以並行的方式」來迭代多個序列
    • 兩個項目的序列(2 個 tuple) → 建立字典
  • 產生數字序列【使用 range()】
    • 【範例一】製作範圍 0、1、2
    • 【範例二】製作範圍 2 到 0 的方式
    • 【範例三】取得 0 到 10 間的偶數（使用 2 的 step 大小）
  • 其他的迭代器

比較【使用 if、elif、else 】

目前為止，以討論幾乎所有的資料結構。終於要來討論程式結構的最後一部分，準備將資料放入程式中。（本書 第三章 集合，已稍微看過）

Python 縮排

• 縮排注意：
  • 測試式底下的每一行 print() 都要縮排
  • 使用四個空格來縮排每一個小段落，稱為PEP-8(http://bit.ly/pep-8) → Python 預期「同一段落的程式」會使用「一致的格式」（每一行都必須縮進相同格數，對齊左邊）
  • 不要使用 tab，或混合使用 tab 與空格，它會攪亂縮排格數

• 在 Python 中，縮排會決定 if 與 else 段落的配對方式

檢查布林變數的值，並印出對應的文字【使用布林值(True/False)、條件比較（if/else）、print()】

• 如果曾經寫過其他的語言，注意：
  1. 不需要在使用 if 做測試時加上括號，必須在結尾使用冒號（:）
  2. 不要使用 if(disaster == True) 之類
  3. 忘記在結尾輸入冒號，Python 會顯示錯誤訊息

• 執行流程：
  • 將布林值 True 指派給變數 disaster
  • 執行條件比較使用 if 與 else，根據變數的值來執行不同的程式 → 檢查某個條件是否為True（這裡是 disaster 的值）
  • 呼叫 print() 函式來印出文字 → print() 是 Python 的內建函式

>>> 變數 = True
>>> if 變數：
        print("文字1!")
    else:
        print("文字2!")

文字1

>>> disaster = True
>>> if disaster:
    print("Woe!")
    else:
    print("Whee!")


Woe!

測試項中加入測試項，依照需求使用的階層數目【使用 if、else】

>>> 變數 1 = True
>>> 變數 2 = True
>>> if 變數1:
        if 變數2:
            print("文字1")
        else:
            print("文字2")
    else:
        if 變數2:
            print("文字3")
        else:
            print("文字4")

文字1

>>> furry = True
>>> small = True
>>> if furry:
    if small:
        print("It's a cat.")
    else:
        print("It's a bear!")
else:
    if small:
        print("it's a skink!")
    else:
        print("It's a human. Or a hairless bear.")


It's a cat.

• 在 Python 中，縮排會決定 if 與 else 段落的配對方式
  1. 第一個測試式：檢查 furry（因為 furry 是 True）→ 前往縮排的的 if small 測試式
  2. 將 small 設為 True（if small 為 True）→ 執行下一行
  3. 印出 It's a cat

三個以上的可能性測試【使用 if、elif（意思是else if）、else】

使用 == 運算子來測試相等與否

>>> 變數 = "值0"
>>> if 變數 == "值1":
        print("文字1")
    elif 變數 == "值2":
        print("文字2")
    elif 變數 == "值3":
        print("文字3")
    else:
        print("文字4")

文字4

>>> color = "puce"
>>> if color == "red":
    print("It's a tomato")
elif color == "green":
    print("It's a green pepper")
elif color == "bee purple":
    print("I don't know what it is, but only bees can see it")
else:
    print("I've never heard of the color", color)


I've never heard of the color puce

測試相等與否【使用比較運算子】

測試「比較運算子」→ 回傳「布林值 True 或 False」

兩個等號（==）的用途是測試相等於否，一個等號（=）是將值指派給變數

>>> 變數 = 數字1    # 賦值（將值指派）給變數

>>> 變數 == 數字2   # 測試相等與否，再回傳布林值
False
>>> 變數 == 數字3
True

>>> 數字4 < 變數
True
>>> 變數 < 數字5
True

>>> x = 7

>>> x == 5
False
>>> x == 7
True

>>> 5 < x
True
>>> x < 10
True

同時做多個比較，先「計算」後「比較」【布林運算子、and、or、not】

• 如果需要「同時做多個比較」，可使用布林運算子、and、or、not 來求出最後的布林結果
• 布林運算子的優先順序比要比較的「程式段落」還要低 → 程式段落會先被計算，再做比較
• 避免搞不清楚優先順序，最簡單的方式就是加上括號

>>> 數字4 < 變數
True
>>> 變數 < 數字5
True

>>> 數字4 < 變數 and 變數 < 數字5
True               #True and True（先計算 True，後比較 and）
>>> 數字4 < 變數 and 變數 > 數字5
False
>>> (數字4 < 變數) and (變數 < 數字5)
True

>>> 數字4 < 變數 or 變數 < 數字5
True
>>> 數字4 < 變數 and not 變數 > 數字5
True

>>> 5 < x
True
>>> x < 10
True

>>> 5 < x and x > 10
False
>>> 5 < x and x < 10
True
>>> (5 < x) and (x < 10)
True

>>> 5 < x or x < 10
True
>>> 5 < x and not x > 10
True

「多個比較式」及「and」→ 成為一個變數

• 將「多個比較式」及「and」→ 成為一個變數
• 也可以編寫較長的比較式

>>> 5 < x < 10          # 多個比較式 + and → 成為一個變數
True
>>> 5 < x < 10 < 999    # 較長的比較式
True
>>>

什麼是True？

False 值不一定非得是 False 不可。以下都會被視為 False：

True 與否/ False 與否

• 以上表格，所有其他的東西都會被視為 True
• Python 程式會使用這一種「True 與否」的定義
• 或在以下例子，「False 與否」來檢查空的資料結構及 False 條件

>>> 變數 = []
>>> if 變數:
        print("文字1")
    else:
        print("文字2")

文字2

>>> some_list = []
>>> if some_list:
    print("There's something in here")
else:
    print("Hey, it's empty!")


Hey, it's empty!

計算運算式（不是簡單的變數），回傳布林結果

• 測試的是一個運算式，而不是一個簡單的變數
• Python 會計算運算式，並回傳布林結果

>>> color = "puce"        # 指派字串 "puce" 給變數 color
>>> if color == "red":    # 計算 color == "red"，是 False → 前往下一個測試 → elif color == "green":
    print("It's a tomato")
elif color == "green":
    print("It's a green pepper")
elif color == "bee purple":
    print("I don't know what it is, but only bees can see it")
else:
    print("I've never heard of the color", color)


I've never heard of the color puce

重複執行【使用 while】

• 一次性：用 if、elif、else 來測試，程式會從上面執行到下面
• 非一次性：迴圈，Python 最簡單的迴圈機制就是 While

迴圈

>>> count = 1           # 將 1 指派給 count
>>> while count <= 5:   # while 迴圈會比較 count 的值是否為 5。如果 count 值小於或等於 5，就會繼續執行
    print(count)    # 在迴圈中，印出 count 值
    count += 1      # 使用陳述式 count += 1 將它的值加一
                        # Python 會回到迴圈的最上面，再次比較 count 的值是否為 5

1
2                       # 現在 count 值是 2，所以 while 迴圈的內容還是會被執行
3                       # 因此 count 值被遞增到 3，繼續下去，直到迴圈最下面將 count 由 5 遞增到 6
4
5                       # 在下一次回到最上面時，count <= 5 會是 False，所以 while 迴圈會結束。Python 會前往下一行
>>>

取消【使用 break】

希望迴圈在「發生某個情況時停止」，但「不確定」那件事會在什麼時候發生 → 使用無窮迴圈 + break 陳述式

範例：【無窮迴圈 + break 陳述式 + input()函式 + 首字母改成大寫】

1. 希望迴圈在「發生某個情況時停止」，但「不確定」那件事會在什麼時候發生 → 使用無窮迴圈 + break 陳述式
2. 讀取一行鍵盤輸入的文字 → input()函式
3. 首字母大寫，並印出它 → capitalize() 、print() 函式

>>> while True:
        變數 = input("文字1:")
        if 變數 == "文字2":
            break
        print(變數.capitalize())

文字1: 文字3
文字3

文字1: 文字4
文字4

文字1: 文字2
>>>

>>> while True:
    stuff = input("String to capitalize [type q to quit]: ")
    if stuff == "q":
        break
    print(stuff.capitalize())


String to capitalize [type q to quit]: test
Test
String to capitalize [type q to quit]: hey, it works
Hey, it works
String to capitalize [type q to quit]: q
>>>

跳過【使用 continue】

有時因為某些原因，不想要跳出迴圈，只想要跳過下一次的迭代

範例：【迴圈 + break 陳述式 + input()函式 + continue + print()】

1. 要讀取一個整數
2. 如果它是奇數，就印出它的平方
3. 如果它是偶數，就跳過
4. 使用 q 來停止迴圈

>>> while True:
        變數 = input("文字1:")
        if 變數 == "文字2":
            break
        number = int(變數）
        if number % 2 == 0:    # an even number 偶數
            continue
        print(number, "文字3", number*number)

文字1: number                  # 奇數
number 文字3 number*number     # 印出它的平方

文字1: number                  # 偶數，continue 跳過它

文字1: 文字2                    # break 取消
>>>

>>> while True:
    value = input("Integer, please [q to quit]: ")
    if value == 'q':      # quit
        break
    number = int(value)
    if number % 2 == 0:   # an even number
        continue
    print(number, "squared is", number*number)


Integer, please [q to quit]: 1
1 squared is 1
Integer, please [q to quit]: 2
Integer, please [q to quit]: 3
3 squared is 9
Integer, please [q to quit]: 4
Integer, please [q to quit]: 5
5 squared is 25
Integer, please [q to quit]: q
>>>

檢查中斷【使用 else】

• 如果迴圈正常結束（沒有呼叫 break ），控制權會被傳給一個選用的 else

範例：【迴圈 + len() + print() + break 陳述式 + else】

• 【方法一】編寫 while 迴圈來尋找某些東西 → 找到時馬上跳出來
• 【方法二】while 迴圈完成，但沒有找到該物件 → 執行 else
• else 用法：可以將它想成中斷檢查器（break checker）

>>> numbers = [數字1, 數字2, 數字3]
>>> 變數 = 0
>>> while 變數 < len(numbers):
        number = numbers[變數]
        if number % 2 == 0:
            print('文字1', number)
            break
        變數 += 1
    else:                     # break not called
            print('文字2')

>>> numbers = [1, 3, 5]
>>> position = 0
>>> while position < len(numbers):
    number = numbers[position]
    if number % 2 == 0:
        print('Found even number', number)
        break
    position += 1
else:                              # break not called
    print('No even number found')


No even number found

迭代【使用 for】

• 基於很好的理由，Python 經常會使用迭代器
• 迭代器：
  • 可在不知道資料結構有多大，及它們的實作方式下遍歷它們
  • 可以迭代動態建立的資料，處理不適合被全部放在電腦記憶體內的資料串流
• 可迭代 Python 物件：串列、字串、tuple、字典、集合
  • 迭代 tuple 或串列：每次會產生一個項目
  • 迭代字串：會一次產生個字元

迭代串列（每次會產生一個項目 → 逐一查看序列）

方法一：【使用串列、while、len()、print()】

>>> 串列名稱 = ['字串1', '字串2', '字串3', '字串4']
>>> 變數 = 0
>>> while 變數 < len(串列名稱):
        print(串列名稱[變數])
        變數 += 1

>>> rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']
>>> current = 0
>>> while current < len(rabbits):
    print(rabbits[current])
    current += 1


Flopsy
Mopsy
Cottontail
Peter

方法二：【使用串列、for、in、print()】

>>> 串列名稱 = ['字串1', '字串2', '字串3', '字串4']
>>> for 串列名稱 in 串列名稱s:
        print(串列名稱)

>>> rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']
>>> for rabbit in rabbits:
    print(rabbit)


Flopsy
Mopsy
Cottontail
Peter

迭代字串（一次產生一個字元）

>>> 變數 = '字串'
>>> for letter in 變數：
        print(letter)

字元
字元
字元

>>> word = 'cat'
>>> for letter in word:
    print(letter)


c
a
t

迭代字典（或它的 keys()函式）→ 回傳鍵

>>> 字典名稱 = {'鍵1': '值1', '鍵2': '值2', '鍵3': '值3'}
>>> for 變數 in 字典名稱:            # or, for 變數 in accusation.keys():
        print(變數)

鍵1
鍵2
鍵3

>>> accusation = {'room': 'ballroom', 'weapon': 'lead pipe', 'person': 'col. Mustard'}
>>> for card in accusation:        # or, for card in accusation.keys():
    print(card)


room
weapon
person

>>> accusation = {'room': 'ballroom', 'weapon': 'lead pipe', 'person': 'col. Mustard'}
>>> for card in accusation.keys():
    print(card)


room
weapon
person

迭代字典的值，而不是鍵【使用字典 value() 函式】→ 回傳值，而不是鍵

>>> 字典名稱 = {'鍵1': '值1', '鍵2': '值2', '鍵3': '值3'}
>>> for 變數 in 字典名稱.values():
        print(變數)

值1
值2
值3

>>> accusation = {'room': 'ballroom', 'weapon': 'lead pipe', 'person': 'col. Mustard'}
>>> for value in accusation.values():
    print(value)


ballroom
lead pipe
col. Mustard

迭代字典【使用 items() 函式】→ 用 tuple 回傳鍵與值

>>> 字典名稱 = {'鍵1': '值1', '鍵2': '值2', '鍵3': '值3'}
>>> for item in 字典名稱.items():
        print(item)

('鍵1', '值1')
('鍵2', '值2')
('鍵3', '值3')

>>> accusation = {'room': 'ballroom', 'weapon': 'lead pipe', 'person': 'col. Mustard'}
>>> for item in accusation.items():
    print(item)


('room', 'ballroom')
('weapon', 'lead pipe')
('person', 'col. Mustard')

一個步驟來對一個 tuple 賦值【使用 items() 函式】

• 請記得，可以用一個步驟來對一個 Tuple 賦值
• items()回傳的 → tuple 第一個值 → 鍵
• items()回傳的 → tuple 第二個值 → 值

>>> 字典名稱 = {'鍵1': '值1', '鍵2': '值2', '鍵3': '值3'}
>>> for 變數1, 變數2 in 字典名稱.items():
        print('文字1', 變數1, '文字2', 變數2)

文字1 鍵1 文字2 值1
文字1 鍵2 文字2 值2
文字1 鍵3 文字2 值3

>>> accusation = {'room': 'ballroom', 'weapon': 'lead pipe', 'person': 'col. Mustard'}
>>> accusation = {'room': 'ballroom', 'weapon': 'lead pipe', 'person': 'col. Mustard'}
>>> for card, contents in accusation.items():
    print("Card", card, 'has the contents', contents)


Card room has the contents ballroom
Card weapon has the contents lead pipe
Card person has the contents col. Mustard
>>>

取消【使用 break】

for 迴圈內的 break 會跳出迴圈（在 while 迴圈也是如此）

跳過【使用 continue】

for 迴圈中插入 continue 會跳到下次迭代（如同 while 迴圈內的動作）

檢查中斷【使用 else】

• for 有一個選用的 else，可檢查 for 是否正常結束（與 while 很像）
• 如果沒有執行 break，就會執行 else 陳述式

• 想要確認之前的 for 迴圈已完全執行，而不是被 break 提早停止時，可使用這個指令

• 與 while 一樣，同時使用 else 與 for 可能有點反直覺

  • 將 for 想成尋找某個東西，在沒找到它的時候，就會呼叫 else
  • 不使用 else 的情況下，取得相同的效果 → 可使用變數，提示是否在 for 迴圈中找到想要的東西

>>> 變數1 = []
>>> for 變數2 in 變數1:
        print('文字1', 變數2)
        break
    else:
        print('文字2')

文字2

>>> cheeses = []
>>> for cheese in cheeses:
    print('This shop has some lovely', cheese)
    break
else:
    print('This is not much of a cheeseshop, is it?')


This is not much of a cheeseshop, is it?

>>> 變數1 = []
>>> 變數2 = False
>>> for 變數3 in 變數1:
        變數2 = True
        print('文字1', 變數3)
        break

>>> if not 變數2:
        print('文字2')

文字2

>>> cheeses = []
>>> found_one = False
>>> for cheese in cheeses:
    found_one = True
    print('This shop has some lovely', cheese)
    break

>>> if not found_one:
    print('This is not much of a cheese shop, is it?')


This is not much of a cheese shop, is it?

迭代多個序列【使用 zip()】

「以並行的方式」來迭代多個序列

• zip() 會在最短的序列結束時停止
• 有一個串列比其他長，除非加長其他的串列，否則無法使用多出的字串

>>> 變數1s = ['值1', '值2', '值3']
>>> 變數2s = ['值4', '值5', '值6']
>>> 變數3s = ['值7', '值8', '值9']
>>> 變數4s = ['值10', '值11', '值12', '值13']     # 有一個串列比其他長，除非加長其他的串列，否則無法使用多出的字串（值13）
>>> for 變數1, 變數2, 變數3 in zip(變數1s, 變數2s, 變數3s, 變數4s):
        print(變數1, "文字1", 變數3, "文字2", 變數2, "文字3", 變數4)

值1 文字1 值7 文字2 值4 文字3 值10
值2 文字1 值8 文字2 值5 文字3 值11
值3 文字1 值9 文字2 值6 文字3 值12

>>> days = ['Monday', 'Tuesday', 'Wednesday']
>>> fruits = ['banana', 'orange', 'peach']
>>> drinks = ['coffee', 'tea', 'beer']
>>> desserts = ['tiramisu', 'ice cream', 'pie', 'pudding']
>>> for day, fruit, drink, dessert in zip(days, fruits, drinks, desserts):
    print(day, ": drink", drink, "- eat", fruit, "- enjoy", dessert)


Monday : drink coffee - eat banana - enjoy tiramisu
Tuesday : drink tea - eat orange - enjoy ice cream
Wednesday : drink beer - eat peach - enjoy pie
>>>

兩個項目的序列(2 個 tuple) → 建立字典

1. 製作「兩個項目的序列」→ 可使用 tuple、串列、字串
2. zip() 逐一查看多個序列，並且將同一個位移值的項目做成 tuple（配對這些 tuple）
3. zip() 回傳的值，本身並不是 tuple 或串列，而是一個可迭代的合併值
4. 直接將 zip() 的結果傳入 dict()（以兩個項目的序列來建立字典）(本書p58 "字典"，告訴你如何使用 dict()函式)

製作兩個英文與法文單字的 tuple → 一個小型的英法字典

>>> 變數1 = '值1', '值2', '值3'
>>> 變數2 = '值4', '值5', '值6'

>>> list( zip(變數1, 變數2) )
[('值1', '值4'), ('值2', '值5'), ('值3', '值6')]

>>> dict( zip(變數1, 變數2) )
{'值1': '值4', '值2': '值5', '值3': '值6'}

>>> english = 'Monday', 'Tuesday', 'Wednesday'
>>> french = 'Lundi', 'Mardi', 'Mercredi'

>>> list( zip(english, french) )
[('Monday', 'Lundi'), ('Tuesday', 'Mardi'), ('Wednesday', 'Mercredi')]

>>> dict( zip(english, french) )
{'Monday': 'Lundi', 'Tuesday': 'Mardi', 'Wednesday': 'Mercredi'}

產生數字序列【使用 range()】

• range() 函式會回傳「指定範圍內的一串數字」

  • 不需要先建立，並儲存一個串列或 tuple 等大型資料結構
  • 可以創建廣大的範圍，且不必用到電腦的任何記憶體，讓你的程式當機

• range() 的用法：

  • 用法很像 slice: range( start, stop, step )
  • start：忽略 start，範圍會從 0 開始
  • stop：是唯一必要的值。與 slice 一樣，最後一個產生的值是 stop 的前一個
  • step：預設值是 1，但可以使用 -1 往回走

• 與 zip() 相同

  • range() 會回傳一個可迭代的物件
  • 【方法一】用 for ... in 來逐一查看值
  • 【方法一】將物件轉換成像串列一樣的序列

【範例一】製作範圍 0、1、2

>>> for 變數 in range(start_數字0, stop_數字3):
        print(變數)

數字1
數字2
數字3

>>> list( range(start_數字0, stop_數字3) )
[數字0, 數字1, 數字2]

>>> for x in range(0, 3):
    print(x)

0
1
2
>>> list( range(0, 3) )
[0, 1, 2]

【範例二】製作範圍 2 到 0 的方式

>>> for 變數 in range(start_數字2, stop_數字-1, step_數字-1):
        print(變數)

數字2
數字1
數字0
>>> list( range(start_數字2, stop_數字-1, step_數字-1) )
[數字2, 數字1, 數字0]

>>> for x in range(2, -1, -1):
    print(x)

2
1
0
>>> list( range(2, -1, -1) )
[2, 1, 0]

【範例三】取得 0 到 10 間的偶數（使用 2 的 step 大小）

>>> list( range(start_數字0, stop_數字11, step_數字2))
[數字0, 數字2, 數字4, 數字6, 數字8, 數字10]

>>> list( range(0, 11, 2) )
[0, 2, 4, 6, 8, 10]

其他的迭代器

第八章：介紹迭代檔案的方式 第六章：如何迭代自己定義的物件