Python 程式語言基本運算實務：從入門到進階

🐍Python程式語言撰寫實務：基本運算~邱允文

12月 07, 2025

🐍 Python 基本運算實務解說

Python 的基本運算子是執行數學運算、比較值或處理邏輯關係的符號。主要分為以下幾類：

1. 算術運算子 (Arithmetic Operators)

用於執行常見的數學運算，如加、減、乘、除等。

運算子

名稱

說明

+

加法 (Addition)

計算兩個數的總和。

-

減法 (Subtraction)

計算兩個數的差。

*

乘法 (Multiplication)

計算兩個數的乘積。

/

除法 (Division)

計算兩個數的商，結果會是浮點數 (float)。

//

整數除法 (Floor Division)

計算兩個數的商並向下取整到最接近的整數。

%

取餘數 (Modulo)

計算兩個數相除後的餘數。

**

冪次 (Exponentiation)

計算指數 (Power)，即 $a^b$。

案例與步驟解說：

💡 實例一：計算 整數除法 (//) 與 取餘數 (%)

目的： 將一個總秒數轉換為分鐘和剩餘秒數。

步驟分解：

1. 定義變數： 設定總秒數變數 total_seconds。
2. 計算分鐘： 使用 整數除法 (//) 將總秒數除以 60，得到完整的分鐘數。
3. 計算剩餘秒數： 使用 取餘數 (%) 將總秒數除以 60，得到未滿一分鐘的剩餘秒數。
4. 輸出結果： 顯示計算出的分鐘和剩餘秒數。

案例：

1. 案例 A： total_seconds = 185
2. • 計算分鐘：$185 // 60 = **3**$
   • 計算剩餘秒數：$185 \% 60 = **5**$
   • 結果：3 分鐘 5 秒。
2. 案例 B： total_seconds = 60
3. • 計算分鐘：$60 // 60 = **1**$
   • 計算剩餘秒數：$60 \% 60 = **0**$
   • 結果：1 分鐘 0 秒。
3. 案例 C： total_seconds = 45
4. • 計算分鐘：$45 // 60 = **0**$
   • 計算剩餘秒數：$45 \% 60 = **45**$
   • 結果：0 分鐘 45 秒。

提示詞範例 (Prompt)：

"使用 Python 整數除法 (//) 和 取餘數 (%)，將總秒數 210 轉換為分鐘和剩餘秒數，並印出結果。"

💡 實例二：結合 乘法 (*) 與 加法 (+)

目的： 計算購買多項物品的總金額 (含稅)。

步驟分解：

1. 定義變數： 設定單價 price、數量 quantity 和稅率 tax_rate。
2. 計算未稅總價： 使用 乘法 (*) 計算單價乘以數量，得到未稅金額。
3. 計算稅金： 使用 乘法 (*) 計算未稅金額乘以稅率，得到稅金。
4. 計算含稅總價： 使用 加法 (+) 將未稅金額加上稅金。
5. 輸出結果： 顯示含稅總金額。

案例：

1. 案例 A： price = 100, quantity = 3, tax_rate = 0.05
2. • 未稅總價：$100 * 3 = 300$
   • 稅金：$300 * 0.05 = 15$
   • 含稅總價：$300 + 15 = **315**$
2. 案例 B： price = 50, quantity = 10, tax_rate = 0.07
3. • 未稅總價：$50 * 10 = 500$
   • 稅金：$500 * 0.07 = 35$
   • 含稅總價：$500 + 35 = **535**$
3. 案例 C： price = 150.5, quantity = 2, tax_rate = 0.0 (免稅)
4. • 未稅總價：$150.5 * 2 = 301.0$
   • 稅金：$301.0 * 0.0 = 0$
   • 含稅總價：$301.0 + 0 = **301.0**$

提示詞範例 (Prompt)：

"一件商品單價 250 元，購買 4 件，稅率為 0.08。請使用 Python 乘法 和 加法 計算含稅總金額。"

💡 實例三：冪次 (**) 運算

目的： 計算 複利 的未來值 (Future Value, FV)。

公式： $FV = P \times (1 + r)^n$

步驟分解：

1. 定義變數： 設定本金 P、年利率 r 和期數 n。
2. 計算成長因子： 計算 $(1 + r)$。
3. 計算冪次： 使用 冪次 (**) 計算 $(1 + r)^n$。
4. 計算未來值： 使用 乘法 (*) 將本金 P 乘以冪次結果。
5. 輸出結果： 顯示未來值。

案例：

1. 案例 A： P = 1000, r = 0.02 (2%), n = 5 (5 年)
2. • 成長因子：$1 + 0.02 = 1.02$
   • 冪次：$1.02^5 \approx 1.10408$
   • 未來值：$1000 * 1.10408 = **1104.08**$
2. 案例 B： P = 5000, r = 0.05 (5%), n = 10 (10 年)
3. • 成長因子：$1 + 0.05 = 1.05$
   • 冪次：$1.05^{10} \approx 1.62889$
   • 未來值：$5000 * 1.62889 = **8144.45**$
3. 案例 C： P = 100, r = 0.1 (10%), n = 1 (1 年)
4. • 成長因子：$1 + 0.1 = 1.1$
   • 冪次：$1.1^1 = 1.1$
   • 未來值：$100 * 1.1 = **110.0**$

提示詞範例 (Prompt)：

"本金為 2000 元，年利率為 3% (0.03)，投資期為 4 年。請使用 Python 冪次 (**) 運算計算期末的未來價值 (複利，不考慮期數為分數的情況)。"

2. 比較運算子 (Comparison Operators)

用於比較兩個值，運算結果為布林值 (True 或 False)。

運算子

名稱

說明

==

等於 (Equal to)

檢查兩個值是否相等。

!=

不等於 (Not equal to)

檢查兩個值是否不相等。

> 

大於 (Greater than)

檢查左邊的值是否大於右邊的值。

< 

小於 (Less than)

檢查左邊的值是否小於右邊的值。

>=

大於或等於 (Greater than or equal to)

檢查左邊的值是否大於或等於右邊的值。

<=

小於或等於 (Less than or equal to)

檢查左邊的值是否小於或等於右邊的值。

案例與步驟解說：

💡 實例四：檢查 學生成績是否及格

目的： 判斷一個學生的分數是否達到 60 分及格標準。

步驟分解：

1. 定義變數： 設定學生分數 score 和及格標準 passing_score。
2. 進行比較： 使用 大於或等於 (>=) 運算子比較 score 是否大於或等於 passing_score。
3. 輸出結果： 結果為 True 表示及格，False 表示不及格。

案例：

1. 案例 A： score = 75
2. • 比較：$75 >= 60$
   • 結果：True (及格)
2. 案例 B： score = 59.9
3. • 比較：$59.9 >= 60$
   • 結果：False (不及格)
3. 案例 C： score = 60
4. • 比較：$60 >= 60$
   • 結果：True (及格)

提示詞範例 (Prompt)：

"學生 小明 考了 85 分，請使用 Python 比較運算子 判斷他的成績是否大於或等於 60 分。"

3. 邏輯運算子 (Logical Operators)

用於組合多個布林表達式，決定最終的布林值。

運算子

名稱

說明

and

且 (AND)

兩個條件都為 True 時，結果才為 True。

or

或 (OR)

只要其中一個條件為 True 時，結果就為 True。

not

非 (NOT)

反轉布林值，將 True 變為 False，False 變為 True。

案例與步驟解說：

💡 實例五：判斷 是否符合打折資格

目的： 客戶必須同時滿足 VIP 會員 且 消費金額超過 500 才能享有額外折扣。

步驟分解：

1. 定義變數： 設定 is_vip (布林值) 和 total_purchase (消費金額)。
2. 設定條件： 條件一是 is_vip == True；條件二是 total_purchase > 500。
3. 進行邏輯運算： 使用 and 運算子連接兩個條件。
4. 輸出結果： 顯示客戶是否符合折扣資格 (True 或 False)。

案例：

1. 案例 A： is_vip = True, total_purchase = 600
2. • 條件一：True；條件二：$600 > 500$ ($True$)
   • 邏輯運算：True and True = True (符合資格)
2. 案例 B： is_vip = False, total_purchase = 800
3. • 條件一：False；條件二：$800 > 500$ ($True$)
   • 邏輯運算：False and True = False (不符合資格，因為非 VIP)
3. 案例 C： is_vip = True, total_purchase = 400
4. • 條件一：True；條件二：$400 > 500$ ($False$)
   • 邏輯運算：True and False = False (不符合資格，因為消費不足)

提示詞範例 (Prompt)：

"客戶 A 是 VIP 且消費金額為 850。請使用 Python and 邏輯運算子判斷他是否同時滿足 is_vip == True 且 total_purchase > 500 這兩個條件。"

💡 實例六：判斷 是否需要進行維護

目的： 判斷系統是否需要維護，條件是 CPU 負載超過 90% 或 記憶體使用量超過 85%。

步驟分解：

1. 定義變數： 設定 cpu_load 和 memory_usage。
2. 設定條件： 條件一是 cpu_load > 0.9；條件二是 memory_usage > 0.85。
3. 進行邏輯運算： 使用 or 運算子連接兩個條件。
4. 輸出結果： 顯示是否需要維護 (True 或 False)。

案例：

1. 案例 A： cpu_load = 0.95, memory_usage = 0.80
2. • 條件一：$0.95 > 0.9$ ($True$)；條件二：$0.80 > 0.85$ ($False$)
   • 邏輯運算：True or False = True (需要維護，因為 CPU 過高)
2. 案例 B： cpu_load = 0.88, memory_usage = 0.92
3. • 條件一：$0.88 > 0.9$ ($False$)；條件二：$0.92 > 0.85$ ($True$)
   • 邏輯運算：False or True = True (需要維護，因為記憶體過高)
3. 案例 C： cpu_load = 0.80, memory_usage = 0.75
4. • 條件一：$0.80 > 0.9$ ($False$)；條件二：$0.75 > 0.85$ ($False$)
   • 邏輯運算：False or False = False (不需要維護)

提示詞範例 (Prompt)：

"系統 CPU 負載為 0.93，記憶體使用量為 0.82。請使用 Python or 邏輯運算子判斷是否需要維護 (條件為 CPU 大於 0.9 或 記憶體 大於 0.85)。"

位元運算子 (Bitwise Operators) 以及 其他常見的運算子 (如賦值運算子、身分運算子和成員運算子) 在 Python 中的應用。

🧠 位元運算子 (Bitwise Operators)

位元運算子直接操作整數的二進位表示（位元，bit）。在執行底層操作、優化某些計算或處理旗標 (flags) 時非常有用。

運算子

名稱

說明

&

位元 AND

兩個位元都為 1 時，結果位元才為 1。

|

位元 OR

兩個位元中只要有一個為 1，結果位元就為 1。

^

位元 XOR (互斥或)

兩個位元不同時 (一個 0, 一個 1)，結果位元才為 1。

~

位元 NOT (反相)

反轉所有位元 (0 變 1，1 變 0)。

<< 

左移 (Left Shift)

將位元向左移動指定次數，右邊用 0 補足。相當於乘以 。

>> 

右移 (Right Shift)

將位元向右移動指定次數。相當於整數除以 。

匯出到試算表

💡 實例一：使用 位元 AND (&) 進行遮罩 (Masking)

目的： 檢查一個數是否為偶數（利用二進位最低位是否為 0），或只提取特定的位元。

步驟分解：

1. 定義變數： 設定目標整數 number 和遮罩 mask (通常為 1，二進位為 ...0001)。
2. 轉換二進位： 將 number 和 mask 轉換為二進位 (例如，5 是 0101，1 是 0001)。
3. 執行 AND 運算： 逐位相乘，結果只有在兩個位元都是 1 時才為 1。
4. 檢查結果： 若結果為 0，表示最低位是 0 (偶數)；若結果為 1，表示最低位是 1 (奇數)。

案例：

1. 案例 A： number = 5 (0101), mask = 1 (0001)
2. • 運算：0101 & 0001
   • 結果：0001 (十進位 1)。最低位為 1，所以是奇數。
2. 案例 B： number = 8 (1000), mask = 1 (0001)
3. • 運算：1000 & 0001
   • 結果：0000 (十進位 0)。最低位為 0，所以是偶數。
3. 案例 C： number = 14 (1110), mask = 2 (0010)
4. • 運算：1110 & 0010
   • 結果：0010 (十進位 2)。這可以檢查倒數第二位是否設置。

提示詞範例 (Prompt)：

"使用 Python 位元 AND (&) 運算子，計算 12 和 5 的位元 AND 結果。請說明它們的二進位形式和運算過程。"

💡 實例二：使用 左移 (<<) 進行快速乘法

目的： 將一個數快速乘以 。左移  位相當於乘以 。

步驟分解：

1. 定義變數： 設定基礎數 base_number 和左移的位數 shift_count。
2. 轉換二進位： 將 base_number 轉換為二進位 (例如，3 是 0011)。
3. 執行左移： 將所有位元向左移動 shift_count 次，並在右側補零。
4. 轉換回十進位： 將新的二進位數轉換回十進位。結果應為 。

案例：

1. 案例 A： base_number = 3 (0011), shift_count = 2
2. • 運算：0011 << 2
   • 結果：1100 (十進位 12)。相當於 。
2. 案例 B： base_number = 7 (0111), shift_count = 1
3. • 運算：0111 << 1
   • 結果：1110 (十進位 14)。相當於 。
3. 案例 C： base_number = 10 (1010), shift_count = 3
4. • 運算：1010 << 3
   • 結果：1010000 (十進位 80)。相當於 。

提示詞範例 (Prompt)：

"請使用 Python 左移 (<<) 運算子，計算 5 左移 4 位的結果。這個操作在數學上代表什麼意思？"

✨ 其他常見運算子

除了算術、比較和邏輯運算子外，Python 還有一些關鍵的運算子類別。

1. 賦值運算子 (Assignment Operators)

用於將值分配給變數。複合賦值運算子結合了算術和賦值。

運算子

範例

等效於

說明

=

a = 5

-

基本賦值。

+=

a += 3

a = a + 3

將右邊的值加到左邊變數上。

-=

b -= 2

b = b - 2

將右邊的值從左邊變數上減去。

*=

c *= 4

c = c * 4

將左邊變數乘以右邊的值。

匯出到試算表

💡 實例三：使用 複合賦值運算子 (+=) 累積總和

目的： 在迴圈或多個步驟中，累加一個變數的值。

步驟分解：

1. 初始化變數： 設定起始值 total = 0。
2. 第一次累加： 使用 += 將第一個值加到 total 上。
3. 第二次累加： 再次使用 += 將第二個值加到 total 上。
4. 輸出結果： 顯示最終的 total 值。

案例：

1. 案例 A： 初始 total = 10
2. • 步驟一：total += 5，結果 total = 15
   • 步驟二：total += 8，結果 total = **23**
2. 案例 B： 初始 count = 1
3. • 步驟一：count += 10，結果 count = 11
   • 步驟二：count += 0.5，結果 count = **11.5**
3. 案例 C： 初始 points = 50
4. • 步驟一：points *= 2 (複合乘法賦值)，結果 points = 100
   • 步驟二：points -= 10 (複合減法賦值)，結果 points = **90**

提示詞範例 (Prompt)：

"請使用 Python 複合賦值運算子 (+=)，將變數 money 的初始值設為 100，然後分別加上 50 和 25，並印出最終的 money 值。"

2. 成員運算子 (Membership Operators)

用於測試序列 (如列表、元組、字串) 中是否包含某個值。

運算子

說明

in

如果在指定的序列中找到該值，則傳回 True。

not in

如果在指定的序列中找不到該值，則傳回 True。

匯出到試算表

💡 實例四：使用 成員運算子 (in) 檢查清單項目

目的： 確認購物清單上是否包含特定商品。

步驟分解：

1. 定義序列： 設定一個清單 shopping_list。
2. 定義目標： 設定要尋找的項目 item_to_find。
3. 執行 in 運算： 使用 in 運算子檢查目標項目是否存在於清單中。
4. 輸出結果： 結果為 True 表示已在清單中，False 表示不在。

案例：

1. 案例 A： shopping_list = ['牛奶', '麵包', '雞蛋'], item_to_find = '麵包'
2. • 運算：'麵包' in shopping_list
   • 結果：True (在清單中)
2. 案例 B： shopping_list = ['牛奶', '麵包', '雞蛋'], item_to_find = '起司'
3. • 運算：'起司' in shopping_list
   • 結果：False (不在清單中)
3. 案例 C： shopping_list = 'Hello World', char_to_find = 'W' (字串也是序列)
4. • 運算：'W' in shopping_list
   • 結果：True (字串中包含 'W')

提示詞範例 (Prompt)：

"清單 fruit_list 包含 ['蘋果', '香蕉', '橘子']。請使用 Python 成員運算子 (in) 檢查 '西瓜' 是否在這個清單中，並印出布林結果。"

3. 身分運算子 (Identity Operators)

用於比較兩個變數是否指向 同一個記憶體位址 (即是否為同一個物件)。這與比較運算子的 == (比較值是否相等) 不同。

運算子

說明

is

如果兩個變數指向同一個物件，則傳回 True。

is not

如果兩個變數不指向同一個物件，則傳回 True。

匯出到試算表

💡 實例五：使用 身分運算子 (is) 區分值相等與物件相等

目的： 示範兩個變數值可能相等，但它們可能不是同一個物件。

步驟分解：

1. 定義變數： 設定兩個變數 a 和 b。
2. 比較值： 使用 == 檢查它們的值是否相等。
3. 比較身分： 使用 is 檢查它們是否指向同一塊記憶體 (即同一個物件)。
4. 輸出結果： 比較 == 和 is 的結果。

案例：

1. 案例 A： a = 5, b = 5 (對於小整數，Python 會進行優化，通常會指向同一個物件)
2. • 值比較：a == b -> True
   • 身分比較：a is b -> True (同一個物件)
2. 案例 B： list1 = [1, 2], list2 = [1, 2] (清單是可變物件，即使內容相同，也通常是不同的物件)
3. • 值比較：list1 == list2 -> True
   • 身分比較：list1 is list2 -> False (不同的物件)
3. 案例 C： list_a = [3, 4], list_b = list_a (將 list_a 的參考賦值給 list_b)
4. • 值比較：list_a == list_b -> True
   • 身分比較：list_a is list_b -> True (兩個變數指向記憶體中的同一個清單物件)

提示詞範例 (Prompt)：

"定義兩個清單 L1 = [10, 20] 和 L2 = [10, 20]。請使用 Python 身分運算子 (is) 比較 L1 和 L2 是否是同一個物件，並說明為什麼它與 == 運算子的結果可能不同。"

邱允文 ，人工智慧，圖靈測試， AI，深度學習 ，生成式AI，Python