Basic Materials of Python
TNFSH Python教材 / 顏永進

• The Martian: 一個男人在火星上種菜的故事
  

  
  

• Python: 一個宅男工程師為了打發聖誕假期打造了一種新的程式語言¹。
  Guido van Rossum
  

  
  

• 30 年後，每天都有數百萬人使用他創立的這一新語言。
  

  • 依據 TIOBE 的調查，目前 Python 在TIOBE最受歡迎語言的排名第一²
    

    
    

    Figure 1: 2026 年 8 月 TIOBE 語言排行榜

  • 幾種不同語言受歡迎程度的變化:TIOBE 2001-2025
    

    
    

    Figure 2: 2002-2026 TIOBE 語言排行變化

• 研究人員於 2019 年首次將 5500 萬光年之外黑洞的照片拼湊出來，使用的程式語言也是 Python。
  

  
  

1989 年 12 月，我正在尋找一個「興趣使然」的程式設計專案，好讓我在聖誕節前後那一週能有事可做。
我的辦公室（位於阿姆斯特丹的一間政府研究實驗室）那段期間會關門，
不過我在家裡有一台電腦，手頭上也沒什麼其他事情。

於是我決定動手寫一個我最近一直在構想的新 Script 語言的直譯器：
一個 ABC 語言的後裔，能夠吸引 Unix/C 駭客的注意。

我為這個專案取了個工作名稱叫 *Python*，
當時的我心情略帶戲謔，也因為我是《Monty Python’s Flying Circus》的超級粉絲。

原文：

…in December 1989, I was looking for a "hobby" programming project that would keep me occupied during the week around Christmas.³

My office (a government-run research lab in Amsterdam) would be closed, but I had a home computer, and not much else on my hands. I decided to write an interpreter for the new Script language I had been thinking about lately: a descendant of ABC that would appeal to Unix/C hackers.

I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of Monty Python's Flying Circus). ⁴

1. 容易學習
   
2. 高階語言
   
3. 使用者友善的資料結構
   
4. 動態型別語言（根據指派的數值自動判定資料型別，無需明確指定）
   
5. 物件導向語言
   
6. 開源且由社群共同開發
   
7. 有許多第三方模組
   
8. 豐富的支援函式庫（如 NumPy 用於數值運算，Pandas 用於資料分析等）
   
9. 可攜性與互動性強
   
10. 跨作業系統皆可執行
    

1. 基於圖形介面的桌面應用程式（例如遊戲、科學應用程式）
   
2. 網頁框架與應用程式
   
3. 企業級與商業應用程式
   

1. Google（部分搜尋引擎與網路爬蟲元件）
   
2. YouTube
   
3. Instagram
   
4. Netflix
   
5. Dropbox
   
6. Reddit
   
7. Uber
   
8. Pinterest
   

雖然我們可以用一般的文字編輯器來寫程式，但正所謂「工欲善其事、必先利其器」，有更好的工具可用，我們為什麼要將就用一些勉強堪用的工具呢？

程式設計師是一群非常 懶惰 重視工作效率的人類，他們可以用五年來開發一個工具，只是為了將來的工作能節省五分鐘，於是這世界就存在了一些專門用來輔助程式設計師寫程式的應用程式。

但是如果只是把它叫做「寫程式的程式」，一來整個格調就沒了，二來還要先解釋哪個是名詞哪個是動詞。

於是，聰明的程式設計師給它取了一個聽起來比較厲害的名字: 整合式開發環境(Integrated Development Environment, IDE)。

市面上常見的、可以拿來寫 python 的 IDE 有以下幾種:

這是一個線上 Python 編輯器和執行環境，提供了簡單易用的介面，可以直接在瀏覽器中撰寫和執行 Python 程式碼。它支援多種 Python 版本，並且可以儲存程式碼到雲端。官網: https://www.online-python.com/

Google Colab 是 Google 提供的一個線上 Jupyter Notebook 環境，可以用來撰寫和執行 Python 程式碼。它支援多種 Python 版本，並且可以使用 Google Drive 儲存程式碼和資料。Colab 還提供了 GPU 和 TPU 支援，可以用來加速深度學習模型的訓練。如果你是 AI 的初學者，Colab 絕對是你的首選，因為它提供了許多現成的範例和教學資源，可以幫助你快速入門。Colab 還支援與其他 Google 服務的整合，如 Google Sheets、Google Drive 等，可以方便地存取和處理資料。官網: https://colab.research.google.com/。

1: #include <iostream>
2: using namespace std;
3: int main() {
4:   cout << "Hello world!";
5: }

Hello world!

• print( 項目 1, [ 項目 2, … , sep = 分隔字元 , end = 結束字元 ] )
  
• sep (分隔字元) 預設為空白字元
  
• end (結束字元) 預設為換行字元 \n
  

 1: a, b, c = 5, 10, 20
 2: print(a, b, c)
 3: print('完全不呈現預設的空白: ',a, b, c, sep ='')
 4: print('以逗號來當分隔符號: ',a, b, c, sep =',')
 5: print('==測試end的用法1==')
 6: print(a, end='\n') #end預設值為跳行，這和 print(a)是一樣的
 7: print(b, end='\n')
 8: print(c, end='\n')
 9: print('==測試end的用法2==')
10: print('不進行跳行: ', a, end=' ')
11: print(b, end=' ')
12: print(c, end=' ')

5 10 20
完全不呈現預設的空白: 51020
以逗號來當分隔符號: ,5,10,20
==測試end的用法1==
5
10
20
==測試end的用法2==
不進行跳行:  5 10 20

留意上面第二行的輸出：當 sep='' 時，print() 會把 所有 參數之間的分隔都拿掉，所以字串 '完全不呈現預設的空白: ' 和後面的 5、10、20 全部黏在一起變成了 完全不呈現預設的空白: 51020 。而第三行 sep=',' 時，逗號也會插在字串參數和數字參數之間，所以才會出現 以逗號來當分隔符號: ,5,10,20 （注意冒號後面緊接著一個逗號）。

所謂跳脫字元(escape character)，就是在字串中使用特殊符號來表示一些特殊的字元，例如換行符號( \n )、tab 符號( \t )、單引號(\')、雙引號(\")等。這些特殊符號可以讓我們在字串中包含一些無法直接輸入的字元。
在 Python 中，跳脫字元通常以反斜線(\)開頭，後面跟著一個或多個字元。
如果要輸出單引號(')或雙引號(")，除了使用跳脫字元(\)，也可以利用單引號、雙引號互換的作法，如下例：

1: #使用跳脫字元\
2: print("他說：\"好，我試試!!\"，然後他就逝世了。")
3: #外層使用單引號
4: print('他說："好，我試試!!"，然後他就逝世了。')
5: #單引號、雙引號互換的作法
6: print("他說：'好，我試試!!'，然後他就逝世了。")

他說："好，我試試!!"，然後他就逝世了。
他說："好，我試試!!"，然後他就逝世了。
他說：'好，我試試!!'，然後他就逝世了。

• 進階閱讀: CRLF、CR、LF詳解
  

請以 print()輸出以下文字

Your brain has two parts: the left and the right.
Your left brain has nothing "right", and your right brain has nothing "left".

1: score = 83
2: print(score)
3: print(f'{score}')

83
83

1: height = 168.3
2: 
3: print(f'{height:.2f}')
4: # 加入文字
5: print(f'身高為:{height:.2f}')

168.30
身高為:168.30

1: weight = 65.33
2: height = 168.33
3: # 不跳行,加逗號
4: print(f'{height:.2f}, {weight:.3f}')
5: # 跳行
6: print(f'{height:.2f}\n{weight:.3f}')
7: # 跳行並加入說明文字
8: print(f'身高:{height:.2f}\n體重:{weight:.3f}')

168.33, 65.330
168.33
65.330
身高:168.33
體重:65.330

1: name = 'Vanessa'
2: height = 165
3: weight = 52.3
4: print(f'{name}的身高是{height}公分、體重是{weight:.2f}公斤')

Vanessa的身高是165公分、體重是52.30公斤

和數字輸出一樣，我們可以預留一些空間給文字輸出，並控制文字的靠齊方向，例如

• {:>}: 向右靠
  
• {:<}: 向左靠
  
• {:^}: 置中對齊
  

下例中我們預留了 8 個空格來顯示姓名(name) ,並要求向右對齊

1: name1 = 'James'
2: name2 = 'Vanessa'
3: height1 = 165
4: weight1 = 52.3
5: height2 = 175
6: weight2 = 72.3
7: print(f'{name1:>8}的身高是{height1:>6}公分、體重是{weight1:10.2f}公斤')
8: print(f'{name2:>8}的身高是{height2:>6}公分、體重是{weight2:10.2f}公斤')

  James的身高是   165公分、體重是     52.30公斤
Vanessa的身高是   175公分、體重是     72.30公斤

以下整理幾個最常用的格式規格，方便查閱：

format() 是 Python 2.6/3.0 以後新增的字串格式化方法，它可以讓我們在字串中使用大括號({})來包裹變數，並且可以控制輸出的格式。format() 的語法是字串.format(變數 1, 變數 2, …)，其中變數可以是任何類型的資料，包括數字、字串、列表、字典等。

• 語法
  
  • format 格式化輸出語法：print(字串.format(變數))

    
  • 字串裡以{0}、{1}、… 來對應參數列裡的變數
    
  • 格式控制：print('{0:控制字串}'.format(參數))
    

Template 是 Python 2.4 以後新增的字串格式化方法，它可以讓我們在字串中使用 $ 符號來標示變數。用法分兩步：先以 Template('含 $變數 的字串') 建立樣板，再呼叫 substitute(變數=值) 把值帶入，如下例：

1: from string import Template
2: 
3: name = 'TNFSH'
4: tmp = Template('Hello, $who')
5: print(tmp.substitute(who = name))
6: 

Hello, TNFSH

% 是 Python 2.x 版本的字串格式化方法，它可以讓我們在字串中使用百分號(%)來包裹變數，並且可以控制輸出的格式。% 的語法是字串 % (變數 1, 變數 2, …)，其中變數可以是任何類型的資料，包括數字、字串、列表、字典等。

• 語法
  
  • 格式化輸出語法：print( 字串 %(參數) )

    
  • 字串裡 %s 代表字串、%d 代表整數、%f 代表浮點數
    

• 範例
  

  1: name = '台北101'
  2: height = 508
  3: fee = 18.24
  4: print('%s的高度為%d公尺，參觀門票為%8.2f美金.' %(name, height, fee))
  5: print('%s的高度為%d公尺，參觀門票為%0.2f美金.' %(name, height, fee))
  

  台北 101 的高度為 508 公尺，參觀門票為   18.24 美金.
  台北 101 的高度為 508 公尺，參觀門票為 18.24 美金.
  

既然是動態的，那麼我們如何知道變數的型態呢？Python 提供了 type() 函式來判斷變數的型態。

1: print(type(2020))
2: print(type(3.1416))
3: print(type('Hello world'))

<class 'int'>
<class 'float'>
<class 'str'>

可以看到，type() 會告訴你這個值是什麼型態：int 代表整數、float 代表浮點數（小數）、str 代表字串。

常用的資料型態有:

• 整數: int
  
• 浮點數: float
  
• 布林值(True / False): bool, T 與 F 要大寫。布林值只有兩個： True 和 False ，通常用在條件判斷中（例如 if 的條件式結果就是一個布林值）。注意：Python 的 True/False 首字母大寫，和 C/C++ 的 true/false 不同。
  
• 字串: str, 以'或"含括,若輸出字串要包含引號，則以另一種引號含括該字串，或是在前面加上跳脫字元（\)。
  

1: age = 18
2: weight = 67.87
3: good_words = " 請常說'請'、'謝謝'、'對不起' "
4: other_words = "請常說\"請\"、\"謝謝\"、\"對不起\""
5: print(type(age))
6: print(type(weight))
7: print(type(good_words))
8: print(other_words)

<class 'int'>
<class 'float'>
<class 'str'>
請常說"請"、"謝謝"、"對不起"

• 序列型態: list, tuple
  
• 集合型態: set
  
• 對映型態: dict
  

在 Python 中，變數的型態可以隨時轉換，這稱為型態轉換(type conversion)。Python 提供了幾個內建函式來進行型態轉換，例如 int()、float()、str() 等。

• 自動轉換
  

1: score = 60
2: print(type(score))
3: score = score + 3.5       # 自動轉換為浮點數，結果為63.5
4: print(type(score))

<class 'int'>
<class 'float'>

• 強制轉換
  

1: score = int(30.22)        # 將括弧內的資料轉換為整數
2: score = float(score)      # 將括弧內的資料轉換為浮點數
3: test = str(score)# 將括弧內的資料轉換為字串

1: input().split(separator, maxsplit)

• separator（可選）：分隔符號，字串會在指定的分隔符號處被切割。如果沒有指定，預設以任何空白字元（空格、換行等）作為分隔符號。
  
• maxsplit（可選）：最多切割幾次。預設值為 -1，表示不限制切割次數。
  
• 回傳值：split() 會回傳一個由切割後的子字串所組成的 list。
  

假設我們面對兩種不同的資料輸入方式：

• 狀況一：輸入的資料為三個成績同時寫在一行(以空白分隔)
  

  1: 23 45 66
  

• 狀況二：三個成績分為三列(每次都按 enter)
  

  1: 23
  2: 45
  3: 66
  

對 C/C++來說，這並不是什麼特別的問題，上述兩種狀況都可以用三個 cin 將成績讀進程式：

1: #include <iostream>
2: using namespace std;
3: int main() {
4:     int a, b, c;
5:     cin >> a >> b >> c;
6: }

但是對 python 來說，如果針對狀況一的資料以下列方式讀入

1: scoreX = input() #一次把整列資料讀完
2: scoreY = input() #沒資料可以讀
3: scoreZ = input()

則 scoreX 的值會變成字串'23 45 66'，而 scoreY, scoreZ 會沒有值，因為這行裡的所有資料全部被讀入 scoreX 中。

回顧一下一年級學 C/C++時，有提及 if 的巢狀寫法，例如

 1: #include <iostream>
 2: using namespace std;
 3: int main() {
 4:     int a, b;
 5:     cin >> a >> b;
 6:     if (a>=60) {
 7:         if (b>=60) {
 8:             cout << "all pass";
 9:         } else {
10:             cout << "第2科掛了";
11:         }
12:     } else {
13:         cout << "第1科掛了";
14:     }
15: }

你可以想一下能不能把 這種寫法套用在 try…except 上。

1: # python code for arithematic opearation
2: print(5+3)
3: print(5-3)
4: print(5*3)
5: print(5/3)
6: print(5%3)
7: print(5//3)
8: print(5**3)

8
2
15
1.6666666666666667
2
1
125

1: print("Python"+"基礎")
2: print(3*"Python基礎")

Python基礎
Python基礎Python基礎Python基礎

傳回某字元的 ASCII code /Unicode

1: print(ord('A'))
2: print(ord('©'))
3: print(ord('南'))
4: print(ord('一'))

65
169
21335
19968

傳回某 ASCII/Unicode 所代表的字元

1: print(chr(97))
2: print(chr(169))

a
©

傳回字串長度

1: print(len('Python基礎'))

8

傳回字串 Unicode 最大/最小字元

1: print(max('Python基礎LALALA'))
2: print(min('Python基礎LALALA'))
3: print(len('Hello'))

礎
A
5

將數值參數轉為字串

1: print(str(3.1416) + str(2020))

3.14162020

既然start和end都可以省略，那麼，如果兩個一起省略呢？像 =[:] =

我們可以做個實驗：

1: sch = 'Tainan First Senior High School'
2: print(sch[:])

Tainan First Senior High School

欸….這個結果和 sch 本身一樣耶，這是因為 [:] 會取得「從頭到尾」的整個切片，結果當然就是整個字串。

那麼….這和直接 print(sch) 不是一樣嗎？對字串來說，的確完全一樣：字串是不可變的資料（下一節會介紹），Python 沒有必要再複製一份，所以 sch[:] 拿回來的就是 同一個 字串物件，你可以用 print(sch[:] is sch) 驗證，結果會是 True。

那 [:] 有什麼用？它真正派上用場的地方是後面會介紹的 List：List 是可變的資料，=a[:]= 會複製出一份 全新的 List，改新的不會動到舊的。這個差異我們在討論到 List 時會更清楚地看到。現在，我們先來看看切片的另一個應用。

除了start、end，可再加入另一個 increment，每隔數個字元取一個，語法為:

1: 字串變數[start:end:increment]: 截取部份字串

例如

1: sch = 'Tainan First Senior High School'
2: print(sch[1:10:2])

annFr

切片的完整語法是 seq[start:stop:step] ，三個參數都可以省略：

• start 預設為 0（step 為負時預設為 -1，即最後一個元素）
  
• stop 預設為序列長度（step 為負時預設為序列開頭之前）
  
• step 預設為 1，可為負數
  

負數索引代表從尾端算起： seq[-1] 是最後一個元素， seq[-2] 是倒數第二個，依此類推。

常見技巧：

1: s = 'ABCDE'
2: print(s[::-1])   # 反轉字串
3: print(s[-1])     # 最後一個字元
4: print(s[-3:])    # 最後三個字元
5: print(s[::2])    # 每隔一個取一個

EDCBA
E
CDE
ACE

這個切片語法適用於所有序列型別（字串、List、Tuple），用法完全一樣。

前面提及 字串 與 字元組成的 List 有點類似，但是還是有幾個地方不同:

• 條件式可不用括號( )含括，條件式後需搭配冒號：
  
• 程式區塊以縮排方式處理，同一層縮排視為同一程式區塊
  
• *特別注意*：Python 不像 C/C++ 用大括號 {} 來界定程式區塊，而是靠 *縮排*（通常是 4 個空格）。縮排不正確會直接導致程式出錯（IndentationError），這是 Python 初學者最常踩到的坑。
  

1: if condition:
2:     statement 1
3:     ...

1: num = 31
2: if num % 2 == 0:
3:     print(f'{num} is even')
4: if num % 2 == 1:
5:     print(f'{num} is odd')

31 is odd

請先觀察以下程式碼，試著猜測輸出結果後再執行驗證：

1: import math
2: magicNum = 37
3: 
4: if math.sqrt(magicNum)*10 < 60:
5:     print('NO', sep='', end='')
6: print('YES', sep='', end='')

YES

想一下：為什麼輸出只有 YES 而不是 NOYES？注意第二個 print() 並不在 if 的縮排區塊內，所以不管 if 的條件是否成立，它都會被執行。而 \(\sqrt{37} \times 10 \approx 60.83\) ，不小於 60，所以 if 區塊中的 print('NO') 不會執行。

1: num = 32
2: if num % 2 == 0:
3:     print(f'{num} is even')
4: else:
5:     print(f'{num} is odd')

32 is even

 1: score = 87
 2: if score >= 90:
 3:     print('A')
 4: elif score >= 80:
 5:     print('B')
 6: elif score >= 70:
 7:     print('C')
 8: elif score >= 60:
 9:     print('D')
10: else:
11:     print('F')

B

請撰寫一個程式，根據使用者輸入的年齡來判斷該使用者的票價。票價標準如下：

1. 年齡 0 到 5 歲：免費
   
2. 年齡 6 到 12 歲：票價 100 元
   
3. 年齡 13 到 64 歲：票價 200 元
   
4. 年齡 65 歲以上：票價 50 元
   
5. 若輸入年齡不合法（負數），輸出「年齡不合法」。
   

1. System module
   

1: import sys
2: print(sys.version)

3.13.11 (main, Dec  5 2025, 16:06:33)
[Clang 17.0.0 (clang-1700.4.4.1)]

1. platform module
   

1: import platform
2: print(platform.python_version())

3.13.11

1: python --version

Python 3.13.11

1: for variable in sequence:
2:     statement 1
3:     ...

• for 迴圈的變數會依序走訪 sequence 中的元素
  
• 這裡的 sequence 可以放 字串(string)、range 函式、表列(list)、元組(tuple)、字典(dict)、集合(set)
  

在之前的章節中，我們提及了字串(string)是由一個一個字元所組成的，所以，字串本質上也是一種序列(sequence)，可以使用 for 迴圈來遍歷字串中的每個字元。這使得 Python 的字串處理非常方便。

1: school = 'TNFSH'
2: for x in school:
3:     print(x, end=' ')
4: print('\n=========')
5: for x in school:
6:     print(chr(ord(x)+1), end=' ')

T N F S H
=========
U O G T I

• ord( ) -> 將字元轉為 Unicode 編碼(整數)；英文字母與數字的部分和 ASCII 相同，中文字也可以
  
• chr( ) -> 將 ASCII 編碼(整數)轉為字元
  

1: school = '高雄市'
2: for x in school:
3:     print(x, end=' ')
4: print('\n=========')
5: for x in school:
6:     print(chr(ord(x)+1), end=' ')
7: 

高 雄 市
=========
髙 雅 布

但是，如果我們需要像在 C++那樣生成一個整數序列來控制迴圈呢？例如：

1: #include <iostream>
2: using namespace std;
3: for(int i=0; i<10; i++){
4:     cout << i << " ";
5: }

在 Python 裡，我們可使用 range() 函式，這個函式會 產生 一個 整數 序列，通常用於迴圈中。

雖然上面提到以 for 迴圈直接走訪字串的每個字元，但有時我們也會需要用 index 來走訪字串，這時就可以把 range() 與 len() 函式搭配使用。

1: school = 'TNFSH'
2: for i in range(len(school)):
3:     print(school[i], end=' ')

以 FOR 輸出以下字串(提示:字串有兩個常用 function: ord()/chr())

abcdefghijklmnopqrstuvwxyz
zyxwvutsrqponmlkjihgfedcba

和字串十分類似，Python 的列表（List）也是一種序列，因此可以使用 for 迴圈來遍歷列表中的每個元素。這使得 Python 的列表處理非常方便。

1: nums = [60, 70, 30, 110, 90]
2: for i in nums:
3:     print(i)

想像一下我們要讀入並處理底下這一行的 5 個數字(也許是把它們加總起來):

55 34 12 93 78

以前使用 C/C++時，我們可以直接用 cin >> 來讀入每個數字，然後再將它們加總起來。

1: #include <iostream>
2: using namespace std;
3: int main() {
4:     int a, b, c, d, e;
5:     cin >> a >> b >> c >> d >> e;
6:     cout << a + b + c + d + e << endl;
7:     return 0;
8: }

但是在 Python 中，如果我們使用 input() 函式來讀取資料，結果就是這一行資料都會被一口氣讀進來，我們得到就一串以空白間隔的字串：

1: numStr = input()
2: print(numStr)

結果會是這樣：

55 34 12 93 78

如何把這個字串裡的數字分割開來，並轉換成整數呢?

1. 我們可以先利用 split() 方法將字串分割成一個列表，這樣每個數字就會成為列表中的一個元素。
   
2. 接著，我們可以使用 map() 函式將列表中的每個元素轉換為整數。
   
3. map()函式傳回的是一個迭代器，因此我們可以使用 list() 函式將其轉換為列表。
   

以下是上述步驟的實作：

1: numList = list(map(int, input().split()))
2: tot = 0
3: for i in numList:
4:     tot += i
5: print(tot)

272

在迴圈中，只要碰到 break 就會跳出迴圈，無論是 while 或 for 迴圈都會馬上跳出。使用 break 陳述句，你只需要打上 break，不須加其他東西。

這是 Python 的一個獨特語法，在 C/C++ 裡是不存在的：你可以在 for 迴圈後面接一個 else。

直覺上你可能會覺得「迴圈為什麼要配 else？」，其實這裡的 else 可以理解為「如果迴圈 *沒有被 break 中斷*，就執行 else 裡的程式碼」。換個角度想：

• 迴圈跑到尾巴自然結束（正常結束）→ 執行 else
  
• 迴圈中途被 break 打斷（不正常結束）→ 不執行 else
  

跳出單次 loop、繼續下一個迴圈。和 break 不同，continue 只會跳過其中的一次迴圈，但是仍會繼續往下把整個迴圈跑完。

什麼事都不幹…..

• pass 是 Python 中的一個空語句，當你需要一個語句但又不想執行任何操作時，可以使用 pass。它通常用於佔位符，表示這裡將來會有程式碼，但目前還沒有實作。
  

基本用法與 C/C++相同：

1: while condition:
2:     statement 1
3:     ...

只要 condition 成立，就一直重複執行縮排的區塊；condition 不成立時結束迴圈。

那什麼時候用 for、什麼時候用 while？一個簡單的判斷方式：

• 知道要跑幾次 （例如走訪一個 List、從 1 數到 100）：用 for
  
• 不知道要跑幾次，只知道什麼時候該停 （例如使用者輸入正確密碼為止、讀到沒資料為止）：用 while
  

先從最簡單的開始：印出 1 到 5。用 for 一行 range 就解決了，用 while 的話，計數這件事要自己來：

1: i = 1            # 1. 設定起始值
2: while i <= 5:    # 2. 設定結束條件
3:     print(i)
4:     i += 1       # 3. 每一圈更新計數變數

1
2
3
4
5

這三件事缺一不可。特別是第 3 步，如果忘了寫 i += 1 ，i 永遠是 1、條件永遠成立，程式就會 無限迴圈 停不下來（這時可以按 Ctrl-C 強制中斷）。這是初學 while 最常犯的錯，之後每寫一個 while 都先問自己：「迴圈裡有沒有讓條件最終會變成 False 的那一行？」

while 真正的強項是「不知道要跑幾次」的狀況，最典型的就是讀取使用者輸入。例如登入系統：使用者輸對密碼之前，就一直要他重新輸入：

1: password = 'tnfsh403'
2: guess = input('Enter password ')
3: while guess != password:
4:     guess = input('Try again ')
5: print('Welcome to MacLab 403...')

注意這個結構：進迴圈 之前 先讀一次，迴圈裡面讀錯了就 再讀一次 ，這樣 while 的條件才有東西可以判斷。

同樣的結構也可以用來連續讀入資料：老師要輸入全班成績算總分，但不知道有幾個人。約定輸入 -1 代表「沒有了」（成績不可能是負的，所以 -1 不會和真實資料混淆）：

1: total = 0
2: score = int(input('請輸入成績（-1 結束）：'))
3: while score != -1:
4:     total += score
5:     score = int(input('請輸入成績（-1 結束）：'))
6: print(f'總分：{total}')

執行結果：

請輸入成績（-1 結束）：80
請輸入成績（-1 結束）：95
請輸入成績（-1 結束）：70
請輸入成績（-1 結束）：-1
總分：245

上面兩個例子都要在迴圈前後各寫一次 input()，有點囉嗦。另一種寫法是讓條件永遠成立（=while True=），然後在迴圈 裡面 用 break 決定什麼時候跳出：

1: total = 0
2: while True:
3:     score = int(input('請輸入成績（-1 結束）：'))
4:     if score == -1:
5:         break
6:     total += score
7: print(f'總分：{total}')

break 會立刻跳出迴圈，規則和前面 for 迴圈學到的一樣。這種寫法是「先做再判斷」，和前一節「先判斷再做」剛好相反，input() 只要寫一次。在需要持續讀取使用者輸入的程式裡很常見：

1: while True:
2:     print('How is your day?')
3:     your_reply = input()
4:     if your_reply == 'quit':
5:         break
6: print('good bye')

while 迴圈也支援 else，規則和 for 一樣：else 只在迴圈「沒有被 break 中斷」、自然結束時才會執行。

把前面的密碼檢查升級一下：最多只能猜三次。猜對就 break 跳出；如果三次都猜錯，迴圈是因為 tries < 3 不成立而自然結束的，這時就由 else 來處理鎖定帳號的工作：

 1: password = 'tnfsh403'
 2: tries = 0
 3: while tries < 3:
 4:     guess = input('請輸入密碼：')
 5:     if guess == password:
 6:         print('登入成功')
 7:         break
 8:     tries += 1
 9:     print(f'密碼錯誤，還有 {3 - tries} 次機會')
10: else:
11:     print('錯誤次數過多，帳號已鎖定')

執行結果（連續輸錯三次）：

請輸入密碼：1234
密碼錯誤，還有 2 次機會
請輸入密碼：abcd
密碼錯誤，還有 1 次機會
請輸入密碼：0000
密碼錯誤，還有 0 次機會
錯誤次數過多，帳號已鎖定

判斷一個數 n 是質數還是合數：從 2 開始一路試除到 n-1，只要有任何一個數整除 n，n 就是合數；全部試完都沒有人整除，n 才是質數。這正是「迴圈是不是從頭到尾都沒找到」的問題。

在還沒有 else 可用之前，通常要自己準備一個旗標變數（flag），找到因數就把它翻成 True，迴圈結束後再檢查它。用 while 迴圈時，除了要維護 flag，還要自己控制除數 i 的遞增，程式就更囉嗦了：

把 (m, n) 換成 (n, m 除以 n 的餘數)，直到餘數為 0，此時 m 就是最大公因數：

1: m, n = 42, 75
2: while n > 0:
3:     m, n = n, m % n
4: print(m)

3

當 input() 讀到檔案結尾時，它 根本不會傳回任何東西 ，而是直接丟出一個 EOFError 例外（注意：錯誤是 input() 發出的，還沒輪到 int() 出手）。所以我們可以用 try…except 把這個例外抓下來，當成「資料讀完了」的訊號來結束迴圈：

1: t = []
2: while True:
3:     try:
4:         n = int(input())  # 讀取輸入並轉換為整數
5:         t.append(n)
6:     except EOFError:      # input() 讀到檔案結尾
7:         break             # 結束迴圈
8: 
9: print(t) #檢查一下讀到的資料

• EOF 是從檔案讀取資料時讀到檔案結尾的訊號，但是一般我們在寫程式都是從鍵盤輸入資料來進行測試，那怎麼送出一個 EOF 給程式呢？答案是在新的一列按 Ctrl-D(MacOS、Linux) 或 Ctrl-Z 再按 Enter(Windows)。
  

有些評分系統（moodle教學網就是其中之一）準備的測資檔最後會多一個空列，這時 input() 不會丟出 EOFError，而是傳回空字串 '' ，接著 int('') 就會丟出 ValueError 。如果只寫 except EOFError: ，程式就會在這裡當掉。比較保險的寫法是兩種例外一起攔：

1: t = []
2: while True:
3:     try:
4:         n = int(input())
5:         t.append(n)
6:     except (EOFError, ValueError):  # 讀到檔案結尾，或讀到空列
7:         break
8: 
9: print(t)

• 如果你讀進來的是字串、沒有經過 int() 轉換，那麼多出來的那個空列就會以 '' 的型式混進 list 裡，記得在讀入後先 print 出來檢查，必要時用 if s = '': break= 把它擋掉。
  

都能讓迴圈停下來，但不是等價的，差別在「攔到什麼」：

• except EOFError: 只攔「資料真的讀完」這一種情況。遇到測資檔尾端多一個空列的評分系統，input() 會先傳回 '' ，=int('')= 丟出的是 ValueError 而不是 EOFError，程式就會在那裡當掉。
  
• except: 什麼例外都攔，EOFError 和 ValueError 都會被當成「讀完了」，所以看起來「能跑」。但它也會攔到你自己的 bug：變數名打錯的 NameError、型別用錯的 TypeError，甚至按 Ctrl-C 的 KeyboardInterrupt。程式會安靜地跳出迴圈、印出不完整的結果，你完全不知道中間出了錯，debug 時會很痛苦。
  
• 所以正確的寫法是做法 2：把要攔的例外 點名 寫出來，=except (EOFError, ValueError):= 。既能應付真正的 EOF，也能應付尾端空列，而其他錯誤仍會正常報出來。
  
• 一句話記住： except: 能跑，但它等於把所有警報器都拆掉；點名要攔的例外才是正確習慣。
  

1: for i in range(1, 10):
2:     for j in range(1, 10):
3:         print(f'{i}*{j}={i*j:2d}', end=' ')
4:     print()
5: 

1*1= 1 1*2= 2 1*3= 3 1*4= 4 1*5= 5 1*6= 6 1*7= 7 1*8= 8 1*9= 9
2*1= 2 2*2= 4 2*3= 6 2*4= 8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18
3*1= 3 3*2= 6 3*3= 9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27
4*1= 4 4*2= 8 4*3=12 4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36
5*1= 5 5*2=10 5*3=15 5*4=20 5*5=25 5*6=30 5*7=35 5*8=40 5*9=45
6*1= 6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 6*7=42 6*8=48 6*9=54
7*1= 7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 7*8=56 7*9=63
8*1= 8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 8*9=72
9*1= 9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

1: a = [1, 2, 3, 4]
2: b = [5, 6, 7, 8]
3: c = []
4: c.append(a)
5: c.append(b)
6: print(c)

[[1, 2, 3, 4], [5, 6, 7, 8]]

輸入一個整數，輸出該整數所有位數平方和
Example

Input: 12345
Output: 55

• 求 1+2+3+…+n<=m，已知 m 時之最大的 n 值。
  
• 輸入 m，輸出 n。
  

輸出如下的結果

1*1= 1   1*2= 2   1*3= 3   1*4= 4   1*5= 5   1*6= 6   1*7= 7   1*8= 8   1*9= 9
2*1= 2   2*2= 4   2*3= 6   2*4= 8   2*5=10   2*6=12   2*7=14   2*8=16   2*9=18
3*1= 3   3*2= 6   3*3= 9   3*4=12   3*5=15   3*6=18   3*7=21   3*8=24   3*9=27
4*1= 4   4*2= 8   4*3=12   4*4=16   4*5=20   4*6=24   4*7=28   4*8=32   4*9=36
5*1= 5   5*2=10   5*3=15   5*4=20   5*5=25   5*6=30   5*7=35   5*8=40   5*9=45
6*1= 6   6*2=12   6*3=18   6*4=24   6*5=30   6*6=36   6*7=42   6*8=48   6*9=54
7*1= 7   7*2=14   7*3=21   7*4=28   7*5=35   7*6=42   7*7=49   7*8=56   7*9=63
8*1= 8   8*2=16   8*3=24   8*4=32   8*5=40   8*6=48   8*7=56   8*8=64   8*9=72
9*1= 9   9*2=18   9*3=27   9*4=36   9*5=45   9*6=54   9*7=63   9*8=72   9*9=81

• 輸入 n，輸出 n 除了 1 和自己以外的所有因數和
  
• 若該數為質數（沒有這樣的因數），則輸出 XD
  

輸入一整數，輸出該整數的所有位數和

• 已知: \(S_n = 1 + \frac{1}{2}+\frac{1}{3}+\dots+\frac{1}{n}\) 。顯然對於任意一個整數 K，當 n 足夠大時，S_n 就會大於 K。
  現在給出一個整數 K(\(1 \leq K \leq 15\))，求一個最小的 n，使\(S_n>K\) 。
  
• 輸入: K
  
• 輸出: n
  

• 輸入： 讀入一整數 n、接下來讀入 n 個整數，最後輸入一個整數 m。
  
• 輸出：將所有 n 個數相乘、再將所得乘積除以 m、輸出餘數
  
• 提示：( a * b) % c = ( ( a % c ) * ( b % c ) ) % c
  

• 一次考試中,於所有及格學生中獲取最低分數者最為幸運,反之,於所有不及格同學中,獲取最高分數者,可以說是最為不幸,而此二種分數,可以視為成績指標。
  請你設計一支程式,讀入全班成績(人數不固定),請對所有分數進行排序,並分別找出不及格中最高分數,以及及格中最低分數。
  當找不到最低及格分數,表示對於本次考試而言,這是一個不幸之班級,此時請你印出:「worst case」;反之,當找不到最高不及格分數時,請你印出「best case」。
  註:假設及格分數為 60,每筆測資皆為 0~100 間整數,且筆數未定。
  
• 輸入：第一行為各學生分數(0~100 間),分數與分數之間以一個空白間格。每一筆測資的學生人數為 1~20 的整數。
  
• 輸出：每筆測資輸出三行。
  第一行由大而小印出所有成績,兩數字之間以一個空白間格,最後一個數字後無空白;
  第二行印出最高不及格分數,如果全數及格時,於此行印出 best case;
  第三行印出最低及格分數,當全數不及格時,於此行印出 worst case。
  

• 任何文字與數字在電腦中儲存時都是使用二元編碼，而所謂二元編碼也就是一段由 0 與 1 構成的序列。在本題中，A~F 這六個字元由一種特殊方式來編碼，在這種編碼方式中，這六個字元的編碼都是一個長度為 4 的二元序列，對照表如下:
  

  字元	A	B	C	D	E	F
  編碼	0101	0111	0010	1101	1000	1100

• 輸入：第一行是一個正整數 N，1 ≤ N ≤ 4，以下有 N 行，每行有 4 個 0 或 1 的數字，數字間彼此以空白隔開，每一行必定是上述六個字元其中之一的編碼。
  
• 輸出：輸出編碼所代表的 N 個字元，字元之間不需要空白或換行間格。
  

• 將一個十進位正整數的奇數位數的和稱為 A,偶數位數的和稱為 B,則 A 與 B 的絕對差值|A-B|稱為這個正整數的奇偶差。
  例如:263541 的奇數位數的和 A = 6+5+1 = 12,偶數位數的和 B = 2+3+4 = 9,所以 263541 的奇偶差是|12-9|= 3。
  給定一個十進位正整數 X,請找出 X 的奇偶差。
  
• 輸入：輸入為一行含有一個十進位表示法的正整數 X,之後是一個換行字元。
  
• 輸出：請輸出 X 的奇偶差 Y(以十進位表示法輸出),以換行字元結尾。
  

• 應俱備能力
  
  • for
    
  • if
    
• 瑪莉歐(Mario)在最後的城堡。他現在需要跳過一些牆壁，然後進入庫巴(Koopa)的房間，他要打敗怪物，以拯救公主。
  對於這個問題，我們只關注“翻過牆”的一部分。
  你將被給予 N 個牆壁(由左至右)的高度。
  瑪莉歐(Mario)目前站在第一個牆壁。他必須跳到相鄰的牆壁直到最後一個。
  這意味著，他將跳躍 N - 1 次。a high jump 代表瑪莉歐(Mario)跳到一個較高的牆，同樣，a low jump 代表瑪莉歐(Mario)跳到一個較矮的牆。
  你能找出 a high jump 和 a low jump 的總數嗎?
  
• 輸入：測資有兩列，第一列為一個正整數 N（N < 50），表示牆壁的數目。下一行依序為 N 個牆壁的高度(由左至右)。每一個高度是不超過 10 的非負整數。
  
• 輸出：兩列，每列一個數字，第一列數字代表 high jumps 總數；第二列數字代表 low jumps 的總數。
  

以下是 List 的基本概念:

• List 以[ ]將不同型態的資料含括起來，以 , 分隔,
  
• List 中的資料是有序排列，從 0 開始編號
  
• 指定語法: List 變數 = [ 元素 1, 元素 2, 元素 3, 元素 4, … ]
  
• 範例: data = [33, 95, 41, 45, 66, 88]
  

例如，我們在以下的程式中建立了一個 List 變數 data，並將 6 個整數放入其中:

1: data = [33, 95, 41, 45, 66, 88]

這樣一來，變數 data 就是一個 List，裡面有 6 個元素，分別是 33、95、41、45、66、88。

然後，我們可以用這樣的方式來取得List中的各項元素：

1: data = [33, 95, 41, 45, 66, 88]
2: print(f'data的第一個元素為 {data[0]}')
3: print(f'data的最後一個元素為 {data[-1]}')

第一個元素為 33
最後一個元素為 88

將資料放入 List 後，可以透過索引值來修改 List 中的元素。例如：

1: test = [12, 13, 14]
2: test[1] = 999
3: print(test)

[12, 999, 14]

List 中的元素可以透過索引值來存取，索引值從 0 開始。例如，要存取 data 中的第一個元素，可以使用 data[0]、要存取第二個元素，可以使用 data[1]，以此類推。

是不是有點熟悉的感覺？沒錯，我們之前在介紹字串(String)時，也有提到過類似的概念，字串中的每個字元也是有序排列的，可以透過索引值來存取。

例如：

1: data = [33, 95, 41, 45, 66, 88]
2: print(data[0]) #輸出第一個元素
3: print(data[3]) #輸出第四個元素

33
45

這麼看來，List 和字串有很多相似的地方，不過 List 更加靈活，因為它可以儲存不同類型的資料。
看到這裡，你應該可以想像 List+for 迴圈的組合，可以解決很多需要處理大量資料的問題了吧！例如：

1: data = [33, 95, 41, 45, 66, 88]
2: for i in range(len(data)):
3:     print(f'data[{i}] = {data[i]}')

data[0] = 33
data[1] = 95
data[2] = 41
data[3] = 45
data[4] = 66
data[5] = 88

這種行為我們就稱為「遍歷 List」，也有人叫做「走訪 List」，就是用迴圈一個一個地存取 List 中的每個元素。每當你學到一個新的資料型別時，都可以試著想想看，這個資料型別能不能跟 for 迴圈搭配起來使用，這樣你就能解決更多的問題了！

這種使用 range()和 len()來遍歷 List 的方式，在 Python 中非常常見，幾乎可以說是每個 Python 程式都會用到的技巧。另一種走訪 List 的方式是直接用 for element in list 的語法，這種方式更簡潔，也更符合 Python 的風格。例如：

1: data = [33, 95, 41, 45, 66, 88]
2: for element in data:
3:     print(element)

33
95
41
45
66
88

除了走訪 List 之外，我們也可以對 list 中的元素進行加總，例如：

1: data = [33, 95, 41, 45, 66, 88]
2: tot = 0
3: for element in data:
4:     tot += element
5: print(f'總和為 {tot}')

總和為 368

List 另一個強大之處在於可以和很多不同的函式搭配使用，例如 sum() 函式可以用來計算 List 中所有元素的總和，max() 函式可以用來找出 List 中的最大值，min() 函式可以用來找出 List 中的最小值。例如：

1: data = [33, 95, 41, 45, 66, 88]
2: print(f'總和為 {sum(data)}')
3: print(f'最大值為 {max(data)}')
4: print(f'最小值為 {min(data)}')

總和為 368
最大值為 95
最小值為 33

除了上述的函式之外，List 本身也有很多專用的函式，可以用來操作 List，例如 append() 函式可以用來在 List 的尾端新增一個元素，remove() 函式可以用來移除 List 中的某個元素，sort() 函式可以用來將 List 中的元素排序。

但是這些專用函式並不是像 len()、max() 那樣直接呼叫的內建函式，而是 List 物件自帶的方法(method)，所以在使用時必須用 List變數.方法名稱() 的方式來呼叫（注意中間有個點號 . ）。你可以這樣理解差異：

• 內建函式：=len(x)= → 把 x 丟進 len() 裡面
  
• List 方法：=x.append('F')= → 對 x 這個 List 呼叫它的 append 方法
  

例如：

在 Python 中，很多不同的資料型別都可以互換，例如我們之前最常用的：

1: a = int(input())

就是將輸入的字串轉換成整數(int)型別，這樣我們就可以對變數 a 進行數學運算了。

同樣地，我們也可以將字串型別的資料轉為List

1: s = '339541456688'
2: data = list(s)
3: print(data)

['3', '3', '9', '5', '4', '1', '4', '5', '6', '6', '8', '8']

當字串被強制轉換成 List 時，List 中的每個元素就是字串中的每個字元。學會這個技巧後，你在面對需要處理字串的問題時，就可以更靈活地運用 List 來解決問題了！

Python 的 List 雖然在概念上與 C++的陣列頗為相似，但在應用上則擁有更大的彈性，除了可以儲存不同類型的資料，最大的特色就是 Python 的 List 提供很強大的切片功能。

以下的範例是一些 List 切片的應用範例，不過如果你已經有了字串切片的概念，那麼你會發現 List 切片的用法幾乎是一模一樣的。這部份就可以參考前面介紹字串切片的內容，不用太認真看。

List 雖然很好用，但也有一些需要注意的地方，否則很容易掉入陷阱。其中一個常見的陷阱就是 List 的賦值(assign)。

在 Python 中，當你寫 b = a 時，b 並不是 a 的「副本」，而是和 a 指向 同一份資料 。你可以把它想像成：a 和 b 是同一間房間的兩把鑰匙，不管你用哪把鑰匙進去改了房間裡的東西，另一把鑰匙打開看到的都是改過的結果。

1: a = [1, 2, 3]
2: b = a          # b 和 a 指向同一個 List
3: a[2] = 100     # 透過 a 改了第三個元素
4: print(a)       # a 變了
5: print(b)       # b 也跟著變了！因為它們是同一個 List

[1, 2, 100]
[1, 2, 100]

這和整數、字串的行為不同（因為整數和字串是不可變的），是 Python 初學者最容易踩到的坑之一。

若真要複製一份獨立的 List，有兩種做法（兩者都是淺拷貝 shallow copy，只複製第一層元素；如果 List 裡面還有 List，內層仍然是共用的）:

1: a = [1, 2, 3]
2: b = a.copy()
3: c = a[:]
4: a[2] = 100
5: print(a)
6: print(b)
7: print(c)

[1, 2, 100]
[1, 2, 3]
[1, 2, 3]

介紹完 List 的基本概念與操作後，接下來要介紹如何建立一個 List 以及如何將資料讀入 List 中。作業裡很多題目都需要用到 List 來儲存大量的資料，所以這部份的內容非常重要，請務必仔細閱讀並理解。

可以用 in 或 not in 來判斷，例如:

1: x = ['A', 'B', 'C', 'D', 'E']
2: if 'B' in x:
3:     print('list裡有B')
4: if 'Q' not in x:
5:     print('list裡沒有Q')

list裡有B
list裡沒有Q

有時候我們會需要在走訪 List 時，同時修改 List 中的元素（尤其是刪除元素），這時候就要特別小心，否則很容易出錯。 例如，下面的程式碼試圖把不及格的分數從 List 中刪除:

1: a = [75, 49, 33, 82, 90]
2: for x in a:
3:     if x < 60:
4:         a.remove(x)
5: print(a)

[75, 33, 82, 90]

咦？33 明明不及格，卻沒有被刪掉！

這是因為在走訪 List 時，同時修改 List 中的元素，會導致迴圈的行為變得不可預期。for 迴圈其實是靠一個「目前走到第幾個」的索引在依序取出元素：第 0 圈取 index 0、第 1 圈取 index 1……。當我們在第 1 圈刪掉 49 之後，後面的元素全部往前補位，33 跑到了 index 1，但迴圈接著要取的是 index 2（已經變成 82），於是 33 就被跳過了。只要有 相鄰 的兩個元素都該刪，就一定會漏掉一個。

以 for 來走訪 list 時，list 中的元素是 for 迴圈重複的重要依據，一邊依賴 list 來執行迴圈，一邊又在執行時去刪除 list 中的元素，就像一邊過橋一邊拆橋，行為的結果自然難以預期。

為了避免這種情況，我們可以採用以下幾種方法來解決這個問題(這部份內容請自行閱讀):

join() 可以把一個 List 裡的字串元素全部「黏」成一個字串，中間用你指定的分隔符隔開。

注意它的語法可能和你預期的不一樣：不是 List.join(分隔符) ，而是 分隔符.join(List) 。也就是說，join() 是 字串 的方法，不是 List 的方法。你可以這樣記：「用什麼分隔符來 join 這個 List」。

另外要注意：List 裡的元素必須 全部都是字串 ，如果有數字就會出錯。

1: words = ['Hello', 'world', 'Python']
2: result = ' '.join(words)
3: print(result)
4: # 用不同的分隔符
5: print(', '.join(words))
6: print('-'.join(words))
7: # 不用分隔符（直接串接）
8: print(''.join(words))

Hello world Python
Hello, world, Python
Hello-world-Python
HelloworldPython

join() 可以想成是 split() 的反操作：split() 把字串拆成 List，join() 把 List 合成字串。

將以下 List 複製貼上至程式碼中

scores = [78, 12, 97, 45, 12, 45, 98, 100, 9, 23]

輸出以下資訊

• 全班平均：至小數點第 2 位
  
• 全班最高分分數
  
• 全班最低分分數
  

• 連續輸入成績(輸入-1 結束)，將成績由高至低排序輸出，並輸出總分、平均
  

 1: score = []
 2: while(True):
 3:     sc = int(input())
 4:     if (sc != -1):
 5:         score.append(sc)
 6:     else:
 7:         break
 8: score.sort(reverse=True)
 9: print(score)
10: sos = sum(score)
11: print(f'全班總分：{sos},全班平均：{sos/len(score):.2f}')

• 連續輸入成績(加入提示字元)
  

1: total = 0
2: grades = []
3: for i in range(0, 5):
4:     x = int(input("請輸入第" + str(i + 1) + "個成績: "))
5:     grades.append(x)
6:     total += x
7: print(total/5)
8: print(grades)

• 給定兩個 List，同時走訪兩個 List，List1 以正向順序顯示，List2 以反向順序顯示
  
• 範例：
  

Input: [可以將輸入直接複製貼上到 code 中]
List1 = [10, 20, 30, 40]
List2 = [100, 200, 300, 400]
Output:
10 400
20 300
30 200
40 100

以描述 List 內容的方式來建構一個 list，即，把 for 內含在 list 建構中
\[S = \{x \mid 0\leq x < 10, x \in \mathbb{Z}\}\]

1: a = [x for x in range(10)]
2: print(a)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

上面的 code 可以取代以下的寫法

1: a = []
2: for i in range(10):
3:     a.append(i)

另外較複雜的例子

1: a = [x for x in range(10)]
2: c = [x**3 for x in a]
3: print(c)
4: d = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y ]
5: print(d)

[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

字串內容無法改變，例

1: s = 'abc'
2: s[1] = 'q'

結果

TypeError: 'str' object does not support item assignment
則可以改為

1: s = 'abc'
2: t = s[:1]+'q'+s[2:]
3: print(t)

aqc

也可以將字串改成 list，直接改 list

1: s = 'abc'
2: t = [x for x in s]
3: print(t)
4: t[1] = 'q'
5: for x in t:
6:     print(x, end='')

['a', 'b', 'c']
aqc

這兩個都可以用來排序，但有一個重要差異：

• sort() 是 List 的方法(method)，會 直接修改 原本的 List，沒有回傳值（回傳 None）。
  
• sorted() 是 Python 的內建函式，會回傳一個 新的排序後 List ，原本的 List 不會被改變。
  

簡單來說：如果你想保留原本的順序，就用 sorted()；如果不需要保留，就用 sort()。

1: a = [3, -4, 100, 20, 999]
2: b = sorted(a) #不會改變a原本的內容
3: print('a:', a)
4: print('b:', b)
5: a.sort() #a原本的內容被改了
6: print('a:', a)

a: [3, -4, 100, 20, 999]
b: [-4, 3, 20, 100, 999]
a: [-4, 3, 20, 100, 999]

如果要對二維 List 排序，Python 預設會先用每個子 List 的第一個元素來比，第一個元素相同時再比第二個，依此類推。但如果你想指定用第幾個元素來排序呢？這時可以用 key 參數搭配 lambda 。

lambda 是一種「匿名函式」的寫法，語法是 lambda 參數: 運算式 ，它會回傳運算式的結果。例如 lambda x: x[0] 的意思是「給我一個東西 x，我回傳 x[0]」。所以 key = lambda x: x[0] 就是告訴 sort()：「排序時，請用每個元素的第 0 個值來比大小」。

lambda 小檔案

• 語法： lambda args: expression
  
• 就是一個沒有名字的小函式，只能寫一行運算式
  
• 常搭配 sort(key…)= 、 map() 、 filter() 使用
  
• 例如 lambda x, y: x + y 等同於寫一個兩數相加的函式
  

lambda 的詳細用法會在進階教材中介紹。

1: a = [[1, 3], [2, 1], [2, 4], [-3, 6]]
2: a.sort(key = lambda x: x[0]) #取出x[0]做為比較對象
3: print(a)
4: a.sort(key = lambda x: x[1])
5: print(a)

[[-3, 6], [1, 3], [2, 1], [2, 4]]
[[2, 1], [1, 3], [2, 4], [-3, 6]]

1: demoList = [[1, 2, 3], [4, 5, 6]]
2: print(demoList)
3: print(demoList[0]) #取出第一個子List
4: print(demoList[0][1]) #取出第一個子List中的第二個element

[[1, 2, 3], [4, 5, 6]]
[1, 2, 3]
2

1: #全班三科成績列表，求每個人平均
2: demoList = [['James', 90, 77, 55],
3:             ['Vanessa', 96, 78, 88],
4:             ['Ruby', 88, 77, 66]]
5: for user in demoList:
6:     print(f'{user[0]:7s}: {sum(user[1:])/3:.4f}')
7:     #print(user[0], sum(user[1:])/3))

James  : 74.0000
Vanessa: 87.3333
Ruby   : 77.0000

複製下列程式碼

1: demoList = [['James', 90, 77, 55],
2:             ['Vanessa', 96, 78, 88],
3:             ['Ruby', 88, 77, 66]]

以如下格式(文字要向右對齊)輸出前例中全班三科平均成績

  James: 74.00
Vanessa: 87.33
   Ruby: 77.00

1. 先建立一個空的 List
   
2. 不斷 append 子 List
   

 1: my2DList = []
 2: 
 3: # 建一子List
 4: x = []
 5: x.append(12)
 6: x.append(24)
 7: x.append(88)
 8: #將子List加入my2dList
 9: my2DList.append(x)
10: 
11: # 再建一子List
12: x = []
13: x.append(33)
14: x.append(99)
15: x.append(12)
16: #再將子List加入my2dList
17: my2DList.append(x)
18: 
19: print(my2DList)
20: 

[[12, 24, 88], [33, 99, 12]]

上述動作可以用 for 來完成:

1: my2DList = []
2: # 依序輸入12, 24, 88, 33, 99, 12
3: for i in range(2):
4:     x = []
5:     for j in range(3):
6:         x.append(int(input()))
7:     my2DList.append(x)

有發現一件事嗎？在上面的程式碼中，變數 i,j 其實用處不太大，在生成兩個數列(range(2)、range(3))後就沒什麼作用了，所以這兩個變數給什麼名字都無所謂，如果你懶的替這種沒什麼重要性的變數取名字，也可以用_來取代，將上述程式改為:

1: for _ in range(2):
2:     x = []
3:     for _ in range(3):
4:         x.append(int(input()))
5:     my2DList.append(x)

要創建一個 3 列、每列 4 個 0 的二維 list 有很多種方式..

以 for 迴圈生成一個如下的二維 List(append)

[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]]

• 資料格式：以( )將不同型態的資料含括起來，以 , 分隔
  
• 元組中的資料是有序排列，從 0 開始編號
  
• 語法: tuple 變數 = ( 元素 1, 元素 2, 元素 3, 元素 4, … )
  

• 範例: data = (33, 95, 41, 'TEST', 99, [123, 456])
  

  data[0]	data[1]	data[2]	data[3]	data[4]	data[5]
  33	95	41	TEST	99	[123, 456]

• tuple 與 List 類似，但 tuple 內的元素不能修改
  

建立 Tuple 的方式是把所有元素放在小括號 () 裡面，以逗號分隔。小括號其實可以省略，但建議還是加上去比較清楚。

 1: # Different types of tuples
 2: 
 3: # Empty tuple
 4: my_tuple = ()
 5: print(my_tuple)
 6: 
 7: # Tuple having integers
 8: my_tuple = (1, 2, 3)
 9: print(my_tuple)
10: 
11: # tuple with mixed datatypes
12: my_tuple = (1, "Hello", 3.4)
13: print(my_tuple)
14: 
15: # nested tuple
16: my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
17: print(my_tuple)
18: 
19: tup1 = (53, )    #只有一個元素時，其後要加逗號
20: print(tup1)
21: 

()
(1, 2, 3)
(1, 'Hello', 3.4)
('mouse', [8, 4, 6], (1, 2, 3))
(53,)

• 使用 Tuple 而非 List，等於告訴讀程式的人（和 Python 直譯器）：「這組資料不應該被修改」。這在程式中是一個很有用的暗示，可以避免不小心改到不該改的資料。
  

• 當 Tuple 放在 List 裡面時，閱讀起來比巢狀 List 更容易辨識。例如：
  

  1: [(2,4), (5,7), (3,8), (5,9)]
  

  比起下面這種寫法更容易一眼看出每組資料的邊界：
  

  1: [[2,4], [5,7], [3,8], [5,9]]
  

• Tuple 常被當作「沒有 key 的字典」來存資料，例如用 Tuple 來存電影的（片名, 導演, 年份）：
  

  1: [('Swordfish', 'Dominic Sena', 2001), ('Snowden', ' Oliver Stone', 2016), ('Taxi Driver', 'Martin Scorsese', 1976)]
  

• 上面的範例是一個 List，裡面裝了多個 Tuple，每個 Tuple 代表一部電影的資訊。
  
• 另外，Tuple 因為不可變，所以可以當作字典的 key 來使用；但 List 是可變的，不能當 key。
  

1: key_val= {('alpha','bravo'):123} #Valid
2: #key_val = {['alpha','bravo']:123} #Invalid
3: print(key_val)
4: print(key_val.keys())
5: print(key_val.values())

{('alpha', 'bravo'): 123}
dict_keys([('alpha', 'bravo')])
dict_values([123])