---
# System prepended metadata

title: python教學舊版

---

# python
## 簡介
1. Python 語言特性：
    1. Python 是一種簡單易學、功能強大的程式語言，具備高效的資料結構、物件導向設計方式、簡潔的語法和動態型別。
    2. 其特性包括易於學習、強大的標準庫、開放原始碼、易安裝且具有良好的相容性。

2. Python 的特色：
    1. 自然性：語法接近自然語言，易於理解。
    2. 易讀性：使用縮排來區分程式區塊。
    3. 完整性：內建強大的標準庫與第三方庫。
    4. 開放性：開放原始碼，促進快速發展。
    5. 易安裝性：大部分作業系統內建 Python 直譯器，Windows 安裝也非常簡單。
    6. 相容與嵌入性：與其他語言（如 C/C++）互通，且可嵌入其他程式。

# 環境建置
1. 安裝Visual Studio Code
https://code.visualstudio.com/

    1. 在裡面安裝python
    ![image](https://hackmd.io/_uploads/BJnkzP1yge.png)
    2. 在vscode裡面執行
    ![image](https://hackmd.io/_uploads/rk5WDAbkgg.png)
# 基礎
## 1. 資料型態（Data Types）
1. 數值型別（Numerical Types）
    int: 整數型態，例如 123
    float: 浮點數型態，例如 123.45
    bool: 布林型態，值為 True 或 False
    
範例:
```
age = 25           # int 整數
score = 92.5       # float 浮點數
is_pass = True     # bool 布林值（True / False）
```
    
2. 字串型別（String Type）
    str: 使用單引號 ' ', 雙引號 " ", 或三重引號 ''' ''' 包裹文字。
    字串具索引順序（從 0 開始），例如：
```python=
x = "Hello, World"
print(x[7])  # 輸出 'W' 空格也是一個字符
```
3. 容器型別（Container Types）
    tuple: 序對，有順序但不可變，使用 ( )。
    list: 清單，有順序且可變，使用 [ ]。
    set: 集合，無順序且不可重複，使用 { }。
    dict: 字典，鍵值對形式，使用 {key: value}。
## 2. 檢查資料型態
使用 type() 函數來檢查變數的型態：
```python=python=
x = 123
print(type(x))  # <class 'int'>
```
## 3. print() 函數
1. 基本格式：
```python=
print(value1, value2, ..., sep=' ', end='\n')
```
2. 參數說明：
    sep：指定多個值之間的分隔符，預設為空格。
    end：輸出結尾，預設為換行符號 \n。
3. 範例:
```python=
print("Hello", "World", sep="@")  # 輸出：Hello@World
print("Python", end="!")         # 輸出：Python!
```
## 4. 跳脫字元
1. 常見的跳脫字元：
    \n：換行
    \t：水平定位
    \\：印出反斜線
    \' 或 \"：印出單引號或雙引號
2. 範例:
```python
print("姓名\t年齡\n王小明\t20")  # 格式化輸出
```
3. 結果:
![image](https://hackmd.io/_uploads/rJKe0zTo1x.png)

## 5. 使用者輸入
1. input() 函數：
    1. 用於接收使用者輸入，預設為字串型別。
    2. 可以用 int() 或 float() 將輸入轉為數值型態。
2. 範例:
```python=
num1 = int(input("請輸入數字1: "))
num2 = int(input("請輸入數字2: "))
print("兩數相加結果:", num1 + num2)
```

## 6. eval() 函數
1. 將輸入轉為 Python 表達式進行運算，但要小心安全性問題。
2. 範例：
```python=
expr = eval(input("請輸入一個運算式: "))  # 讓使用者輸入運算式，並使用 eval() 計算結果
print("結果是:", expr)  # 顯示計算結果

```
## ７.字元與 Unicode 轉換
１.　字元轉成 Unicode 數值的函數:ord()
如:ord('1')、ord('A')、ord('a')
問題:哪個 Unicode 較大?

２.　Unicode 數值轉成字元的函數:chr()
如:chr(57)、chr(90)、chr(122)


## 8. 變數與常數
1. 變數:程式中用於暫存資料如數值、字串等,方便隨 時可讀取與變更資料,命名習慣以小寫字母開頭
2. 常數:程式中用於儲存資料,方便隨時讀取使用,但 不會變更其內容,命名習慣都是大寫字母
### 變數與常數:命名規則
1. 第一個字元可以是英文、底線(__)、或中文,其它字元 可以是英文、底線、數字、或中文,英文字母有大小 寫之分
2. 不可是關鍵字,以及內建常數、函數、類別等名稱
3. 建議使用有意義的英文單字,組合字採用駝峰式命名
### 變數與常數:命名規則範例
不合法變數名稱:
1. class
    1. 原因: 不能使用關鍵字，class 是 Python的保留關鍵字，用於定義類別。
    3. 推薦的變數名稱寫法:
        1. className
        2. _class
2. my@ID
    1. 原因: 不能使用特殊符號 @，變數名稱只能包含字母、數字和底線 _。
    2. 推薦的變數名稱寫法:
        1. myID
        2. _myID
3. 7eleven
    1. 原因: 不能以數字開頭，變數名稱必須以字母或底線 _ 開頭。
    2. 推薦的變數名稱寫法:
        1. sevenEleven
        2. _7eleven
4. !myName
    1. 原因: 不能使用特殊符號 !，變數名稱只能由字母、數字和底線 _ 組成。
    2. 推薦的變數名稱寫法:
        1. myName
        2. _myName
5. my name
    1. 原因: 不能包含空白，變數名稱中不能有空格。
    2. 推薦的變數名稱寫法:
        1. myName
        2. my_name

推薦變數命名規則:
1. 駝峰式命名法（Camel Case）:
    1. 例: studentID, myHomeAddress
    2. 第一個單字以小寫開始，其後的單字首字母大寫。
2. 底線命名法（Snake Case）:
    1. 例: student_id, my_home_address
    2. 單字之間使用底線 _ 連接，全部小寫。
3. 命名應簡潔明瞭:
保持易讀性，避免使用過於簡單或無意義的名稱，如 a, b, temp 等。
## 9. 指定敘述
1. 等號 (=) 稱為指定運算子將等號右邊運算後的結果,存到等號左邊的變數中
2. 等號右邊可放變數,屬於讀取變數內容
3. 等號左邊不可以是運算式,只能單純變數
4. 可連續賦值,如:x=y=z=3
5. 可多重賦值,如:x, y, z=1, 3.5, "hello"
## 10. 標準輸入與輸出
1. 輸入
    1. 標準輸入函數:input(),括弧裡面可放字串,用以提示之用, 如 score = input("請輸入成績: '")
    2. 讀取進來的值預設為字串,可透過函數:
        1. int()轉為整數、
        2. float()轉為浮點數、
        3. eval()轉為數值
2. 輸出
標準輸出函數:print(),將結果輸出在螢幕上,語法:
print( value, ..., sep=' ', end='\n', file=sys.stdout)
    1. value:要印出的值或變數或運算式,若有多個值,中間用逗號分隔
    2. sep:選擇性參數,隔開各值間的字串,預設為一個空格
    3. end:選擇性參數,印完後要印出的字串,預設為換行
    4. file:選擇性參數,設定輸出的裝置,預設為螢幕
# 變數宣告
變數宣告
    1. 在 Python 中，第一次使用變數即為其宣告，並自動分配記憶體。
    2. 必須先賦值才能使用變數，否則會導致 NameError。
## 垃圾回收機制
1. Python 自動回收不再被使用的物件，以釋放記憶體空間。
2. 當變數指向新的值時，舊的物件會被回收。
# 運算子
1. 算術運算子
    加法 +、減法 -、乘法 *、指數運算 **、整數除法 //、模數運算 %。
    例如：7 // 2 結果為 3，120 % 7 結果為 1。
2. 比較運算子
    等於 ==、不等於 !=、大於 >、小於 <、大於等於 >=、小於等於 <=。
    可以鏈式比較，例如：5 < x <= 10。
3. 指定運算子
    賦值用 =，例如 x = 10。
    支援複合運算子，如 x += 5（等同於 x = x + 5）。
4. 其他運算子
    點號 .：存取模組屬性或方法。
    小括弧 ()：提升優先權、函式呼叫。
    中括弧 []：用於 list 或索引操作。
## 數值交換
Python 支援簡單的變數值交換，例如：
```python=
x, y = 10, 20
x, y = y, x
print(x, y)  # 結果為 20, 10
```

## 數學相關模組
### 常見可直接使用的數學函數:
1. abs(x) :回傳x的絕對值
2. divmod(x, y) :回傳x除以y的商與餘
3. max(x1, x2, ...) :回傳 x1, x2, ... 中的最大值
4. min(x1, x2, ...) :回傳 x1, x2, ... 中的最小值
5. pow(x, y): 回傳x的y次方,同 x**y
6. round(x [,n]) :將x四捨五入到小數點第n位,預設n=0
### 匯入 math 模組
import math:
1. ceil(x) :無條件進入
2. floor(x) :無條件捨去
3. log(x [,n]) :以n為基底的x對數
4. log10(x) :以10 為基底的x對數
5. exp(x) :回傳e的x次方
6. fabs(x) :回傳x的絕對值
7. gcd(x, y) :回傳x,y 的最大公因數
8. sqrt(x) :回傳x的平方根

數學常數:
1. math.pi: 3.141592653589793
2. math.e: 2.718281828459045

三角函數:
sin()、cos()、tan()、asin()、acos()、atan()...
#  Python 字串格式化教學：f-string vs format()
## 方法一：str.format()（Python 2.6+）
✅ 語法：`"文字{}文字{}".format(變數1, 變數2)`
✅ 範例：
```python=
name = "小明"
place = "台中"
print("{}今天去了{}".format(name, place))
```
🔄 輸出：
`小明今天去了台中`
🔧 特色與功能：
1. 可指定位置：`"{1}在{0}工作".format("台北", "小王")  # 小王在台北工作`
2. 可指定變數名稱：`"{name}來自{name_place}".format(name="小艾", name_place="高雄")`
## 方法二：f-string（Python 3.6+ 推出）
✅ 語法：`f"文字{變數}文字{表達式}"`
✅ 範例：
```python=
name = "小明"
place = "台中"
print(f"{name}今天去了{place}")
```
🔄 輸出：
`小明今天去了台中`

💡 f-string 也支援表達式與函式！
```
x = 10
y = 5
print(f"總和是：{x + y}")  # 總和是：15
print(f"名稱大寫：{name.upper()}")  # 名稱大寫：小明 → 小明
```
## 📊 比較總表
![螢幕擷取畫面 2025-04-21 221105](https://hackmd.io/_uploads/HkLmG0mJle.png)
# 格式化字符
## 數字對齊與寬度控制
語法： {格式}
![image](https://hackmd.io/_uploads/SJzAYSQDye.png)


範例:
```python=
num = 123
print("{:10d}".format(num))   # 預設右對齊
print("{:>10d}".format(num))  # 強制右對齊
print("{:<10d}".format(num))  # 強制左對齊
print("{:^10d}".format(num))  # 強制置中對齊
```
輸出:
```
       123
       123
123       
   123    
```

## 小數精度與符號控制
語法： {格式}
![image](https://hackmd.io/_uploads/Bkgz9B7Dke.png)


```python=
num = 3.14159
print("{:.3f}".format(num))   # 保留 3 位小數
print("{:+.3f}".format(num))  # 保留 3 位小數，帶符號
print("{:.0f}".format(num))   # 不帶小數，四捨五入
```
輸出:
```
3.142
+3.142
3
```

## 補充：更多數值格式選項
1. 格式化的常用符號
![image](https://hackmd.io/_uploads/Hke1jSQwyg.png)
2. 對齊方式
![image](https://hackmd.io/_uploads/ryvlormDyg.png)



```python=
num = 123
print("{:0>10d}".format(num))  # 使用 0 填充，右對齊
print("{:*<10d}".format(num))  # 使用 * 填充，左對齊
print("{:~^10d}".format(num))  # 使用 ~ 填充，置中對齊
```

輸出:
```
0000000123
123*******
~~~123~~~~
```
2. 千分位分隔符
    1. 語法：{:,.格式}
    2. 在數字中插入千分位逗號。
```python=
num = 1234567.89
print("{:,.2f}".format(num))  # 保留兩位小數，千分位逗號分隔
```
輸出:1,234,567.89
# 判斷式
## if
1. 單向判斷 (if...)
適用於條件成立時執行某段程式碼。
```python=
if a > b:
    print("a比較大")
```

2. 雙向判斷 (if...else)
條件成立執行第一段程式碼，否則執行第二段。
```python=
if a > b:
    print("a比較大")
else:
    print("b等於a或比較大")
```

3. 多向判斷 (if...elif...else)
適用於多條件分支情境。
```python=
if a > b and a > c:
    print("a最大")
elif b > a and b > c:
    print("b最大")
else:
    print("c最大")
```

4. 巢狀判斷
判斷式內部包含另一個判斷式，用於處理複雜條件。
```python=
if a > 0:
    if a % 2 == 0:
        print("a是正偶數")
    else:
        print("a是正奇數")
else:
    print("a不是正數")
```

### if練習題
1：算術運算
題目：
請撰寫一程式，讓使用者輸入兩個整數 a 和 b，然後輸入一個運算子 (+, -, *, /, //, %, **)，最後輸出兩個整數運算的結果。

延伸題：
針對使用者輸入 /, //, % 三個運算子時，若 b 值為 0，則顯示「除數不可為 0」，其他情況正常顯示運算結果。

範例程式碼：
```python=
while True:
    # 輸入兩個整數和運算符
    a = int(input("輸入第一個整數 a："))
    b = int(input("輸入第二個整數 b："))
    operator = input("輸入運算子（+、-、*、/、//、% 或 **）：")

    # 判斷運算子並進行運算
    if operator == '+':
        result = a + b
    elif operator == '-':
        result = a - b
    elif operator == '*':
        result = a * b
    elif operator == '/':
        if b == 0:
            result = "除數不可為 0"
        else:
            result = a / b
    elif operator == '//':
        if b == 0:
            result = "除數不可為 0"
        else:
            result = a // b
    elif operator == '%':
        if b == 0:
            result = "除數不可為 0"
        else:
            result = a % b
    elif operator == '**':
        result = a ** b
    else:
        result = "無效的運算子"

    # 輸出結果
    if isinstance(result, str):  # 如果結果是錯誤訊息
        print(result)
    else:
        print(f"{a} {operator} {b} = {result}")

    # 提示使用者是否要繼續計算
    choice = input("是否要繼續計算？(按任意鍵繼續，輸入 'q' 離開)：")
    if choice.lower() == 'q':
        print("程式結束，感謝使用！")
        break  # 跳出迴圈，結束程式

```
範例輸入與輸出：
輸入範例 1：
```
輸入第一個整數a：3
輸入第二個整數b：8
輸入運算子：*
```
輸出範例 1
```
3 * 8 = 24
```
輸入範例 2：
```
輸入第一個整數a：4
輸入第二個整數b：0
輸入運算子：/
```
輸出範例 2：
```
除數不可為0
```

2. 閏年判斷
題目：請撰寫一程式，讓使用者輸入一個西元年份，然後程式輸出顯示該年份是否為閏年。

閏年的規則：
    每4年一閏年
    每100年不是閏年
    每400年又是閏年
範例程式碼：
```python=
# 輸入年份
year = int(input("請輸入一個西元年年份："))

# 判斷是否為閏年
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year} 年是閏年")
else:
    print(f"{year} 年不是閏年")
```
範例輸入與輸出：
輸入範例 1：
```
請輸入一個西元年年份：2000
```
輸出範例 1：
```
2000 年是閏年
```
輸入範例 2：
```
請輸入一個西元年年份：2100
```
輸出範例 2：
```
2100 年不是閏年
```
## 迴圈 (Loop)
1. for...in 迴圈
適用於遍歷序列（如清單、字串）。
```python=
for i in range(5):
    print(i)
```

2. while 迴圈
當條件成立時重複執行。
```python=
count = 0
while count < 5:
    print(count)
    count += 1
```

3. 巢狀迴圈
迴圈內部包含另一個迴圈。
```python=
for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")
```

4. 控制迴圈流程
    1. break：強制結束迴圈。
    2. continue：跳過本次迴圈，進入下一次迴圈。
```python=
for i in range(5):
    if i == 3:
        break
    elif i == 2:
        continue
    print(i)
```

## range() 函式的使用
在 Python 中，range() 函式可以用來生成一個範圍內的數字序列，常用於迴圈結構中（如 for 迴圈）。range() 函式可以接受 1 到 3 個參數，具體取決於使用者的需求。

範例與說明：
range(次數)： 當只傳入一個參數時，range() 會從 0 開始，並生成從 0 到該參數減 1 的數字序列。

範例：
```python=
for i in range(5):
    print(i)
```
輸出：:
```
0
1
2
3
4
```
這代表 range(5) 會生成從 0 到 4 的數字序列。


2. range(起始值, 結束值)： 當傳入兩個參數時，range() 會從起始值開始，並生成到結束值減 1 的數字序列。這樣可以指定一個範圍。

範例：
```python=
for i in range(5, 10):
    print(i)
```
輸出:
```
5
6
7
8
9
```
這代表 range(5, 10) 會生成從 5 到 9 的數字序列。

3.range(起始值, 結束值, 步長)： 當有三個參數時，range() 會按照指定的步長生成數字序列。

範例：
```python=
for i in range(0, 10, 2):
    print(i)
```
輸出:
```
0
2
4
6
8
```
在這個例子中，range(0, 10, 2) 會從 0 開始，到 10 減 1，並以 2 為步長生成數字。

### for練習題
1：列印直角三角形
設計說明： 讓使用者輸入一個數字 n，然後列印出 n 層的直角三角形，使用 @ 字元。

範例程式碼：
```python=
# 讓使用者輸入數字 n
n = int(input("請輸入數字："))

# 列印直角三角形
for i in range(1, n + 1):
    print('@' * i)
```
範例輸入：`7`
範例輸出：
```
@
@@
@@@
@@@@
@@@@@
@@@@@@
@@@@@@@
```

2. 列印反直角三角形
設計說明： 讓使用者輸入一個數字 n，然後列印出 n 層的反直角三角形，使用 @ 字元。

範例程式碼：
```python=
# 讓使用者輸入數字 n
n = int(input("請輸入數字："))

# 列印反直角三角形
for i in range(n, 0, -1):
    print('@' * i)
```
範例輸入：`請輸入數字：7`

範例輸出：
```
@@@@@@@
@@@@@@
@@@@@
@@@@
@@@
@@
@
```
列印等腰三角形
設計說明： 讓使用者輸入一個數字 n，然後列印出 n 層的等腰三角形，使用 @ 字元。

範例程式碼：
```python=
# 讓使用者輸入數字 n
n = int(input("請輸入數字："))

# 列印等腰三角形
for i in range(1, n + 1):
    print(' ' * (n - i) + '@' * (2 * i - 1))
```

範例輸入：`請輸入數字：6`
範例輸出：
```
     @
    @@@
   @@@@@
  @@@@@@@
 @@@@@@@@@
@@@@@@@@@@@
```

4. 列印九九乘法表
設計說明： 讓使用者輸入一個數字 n，然後印出該數字的九九乘法表。

範例程式碼：
```python=
# 讓使用者輸入數字 n
n = int(input("請輸入數字："))

# 列印九九乘法表
for i in range(1, 10):
    print(f"{n} * {i} = {n * i}")
```

範例輸入：`請輸入數字：6`

範例輸出：
```
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
```

5. 列印兩位數的八進位數字
設計說明： 列印兩位數的八進位數字，每行列印八組數字，中間一個空白。

範例程式碼：
```python=
# 列印兩位數的八進位數字
for i in range(0, 8):  # 外層迴圈
    for j in range(0, 8):  # 內層迴圈
        print(f"{i * 8 + j:02d}", end=" ")  # 輸出格式化的八進位數字
    print()  # 換行
```
範例輸出：
```
00 01 02 03 04 05 06 07
10 11 12 13 14 15 16 17
20 21 22 23 24 25 26 27
30 31 32 33 34 35 36 37
40 41 42 43 44 45 46 47
50 51 52 53 54 55 56 57
60 61 62 63 64 65 66 67
70 71 72 73 74 75 76 77
```

6. 列印數字三角形（1~9，間隔一空白）
設計說明： 列印數字三角形，從 1 到 9 開始，並逐行減少一個數字。

範例程式碼：
```python=
# 列印數字三角形
for i in range(1, 10):  # 外層迴圈
    for j in range(1, 10 - i):  # 內層迴圈
        print(j, end=" ")
    print()  # 換行
```
範例輸出：
```
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7
1 2 3 4 5 6
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
```

7. 列印數字三角形（每行從 1 開始）
設計說明： 每行印出從 1 到數字 n（逐行增加），並且每行減少一個數字。

範例程式碼：
```python=
# 列印數字三角形
for i in range(1, 10):  # 外層迴圈
    for j in range(1, i + 1):  # 內層迴圈
        print(j, end=" ")
    print()  # 換行
```

範例輸出：
```
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
```

8. 列印數字三角形（每行從數字開始）
設計說明： 每行從數字 n 開始，並且逐行減少一個數字，直到 1。

範例程式碼：
```python=
# 列印數字三角形
for i in range(1, 10):  # 外層迴圈
    for j in range(i, 10):  # 內層迴圈
        print(j, end=" ")
    print()  # 換行
```
範例輸出：
```
1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9
3 4 5 6 7 8 9
4 5 6 7 8 9
5 6 7 8 9
6 7 8 9
7 8 9
8 9
9
```

9. 列印九九乘法表（整齊排列）
設計說明： 列印九九乘法表，並保持排列整齊，輸出每一個乘法式。

範例程式碼：
```python=
# 列印九九乘法表
for i in range(2, 10):  # 外層迴圈
    for j in range(1, 10):  # 內層迴圈
        print(f"{i}*{j}={i*j:2}", end=" ")  # 格式化輸出
    print()  # 換行
```
範例輸出：
```
2*1= 2 3*1= 3 4*1= 4 5*1= 5 6*1= 6 7*1= 7 8*1= 8 9*1= 9 
2*2= 4 3*2= 6 4*2= 8 5*2=10 6*2=12 7*2=14 8*2=16 9*2=18 
2*3= 6 3*3= 9 4*3=12 5*3=15 6*3=18 7*3=21 8*3=24 9*3=27 
2*4= 8 3*4=12 4*4=16 5*4=20 6*4=24 7*4=28 8*4=32 9*4=36 
2*5=10 3*5=15 4*5=20 5*5=25 6*5=30 7*5=35 8*5=40 9*5=45 
2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 7*6=42 8*6=48 9*6=54 
2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 8*7=56 9*7=63 
2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 9*8=72 
2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 
```

10. 盲猜密碼
1. 設計說明：
請撰寫一程式，讓程式產生0~9之間的一個密碼，然後讓使用者不斷猜測，直到猜對為止
2. 範例輸入/輸出：
(左側綠色粗體字代表使用者輸入)
請猜測數字(0~9)：7
猜錯，再猜(0~9)：5
猜錯，再猜(0~9)：2
猜錯，再猜(0~9)：8
猜對了，密碼就是8
```python=
import random

# 產生一個隨機密碼（0~9）
password = random.randint(0, 9)

# 開始猜測
while True:
    # 提示使用者輸入猜測數字
    guess = int(input("請猜測數字(0~9)："))

    # 判斷猜測是否正確
    if guess == password:
        print(f"猜對了，密碼就是{password}")
        break  # 結束迴圈
    else:
        print("猜錯，再猜(0~9)：")
```
解釋:程式說明
1. 密碼產生：使用 random.randint(0, 9) 隨機生成 0 到 9 的整數作為密碼。

2. 猜測迴圈：
    1. 使用 while True 讓程式不斷進行猜測。
    2. 每次猜測後，程式會檢查猜測數字是否等於密碼。
    3. 若猜對，輸出提示並結束程式；若猜錯，提示重新猜測。

3. 輸入驗證：
    1. 使用 int(input(...)) 確保輸入為整數。
    2. 沒有特別處理非整數的輸入，如果需要增加容錯，可以加入例外處理。

11. 找出輸入值中的最小值
```python=
print("請輸入數字，直到9999結束")

min_value = float('inf')  # 初始設定為無窮大
i = 1

while True:
    num = int(input(f"請輸入第{i}個數字："))
    if num == 9999:
        break
    if num < min_value:
        min_value = num
    i += 1

print(f"輸入的最小值為{min_value}")
```

12. 找出輸入值中的最大值
```python=
print("請輸入數字，直到9999結束")

max_value = float('-inf')  # 初始設定為無窮小
i = 1

while True:
    num = int(input(f"請輸入第{i}個數字："))
    if num == 9999:
        break
    if num > max_value:
        max_value = num
    i += 1

print(f"輸入的最大值為{max_value}")
```

13. 數字反轉
```python=
print("請輸入數字，直到9999結束")

i = 1
while True:
    num = input(f"請輸入第{i}個數字：")
    if num == "9999":
        break
    reversed_num = num[::-1]
    print(f"反轉的數字為：{reversed_num}")
    i += 1
```

14. 數字加總
```python=
print("請輸入數字，直到9999結束")

i = 1
while True:
    num = input(f"請輸入第{i}個數字：")
    if num == "9999":
        break
    total = sum(int(digit) for digit in num)
    print(f"數字加總為：{total}")
    i += 1
```

15. 倍數的個數與總和
```python=
# 輸入起始與結束值
start = int(input("請輸入起始值："))
end = int(input("請輸入結束值："))

multiples = []  # 儲存 7 或 11 的倍數
total_sum = 0   # 儲存總和

# 搜尋範圍內的所有數字
for num in range(start, end + 1):
    if num % 7 == 0 or num % 11 == 0:
        multiples.append(num)
        total_sum += num

# 輸出倍數清單
for i in range(len(multiples)):
    print(f"{multiples[i]:<4}", end="")
    if (i + 1) % 10 == 0:  # 每列印 10 個數字
        print()

if len(multiples) % 10 != 0:
    print()

# 輸出結果
print(f"總數共有 {len(multiples)} 個")
print(f"數字總和為 {total_sum}")
```

### Python執行邏輯
程式碼會按順序執行，除非遇到以下特殊情況：
1. 判斷式
2. 迴圈
3. 函數
4. 例外處理

## 範例應用
1. 成績判斷
```python=
score = int(input("請輸入分數: "))
if score >= 95:
    print("獎金2000元")
elif 90 <= score < 95:
    print("獎金1000元")
elif 80 <= score < 90:
    print("獎金500元")
else:
    print("無獎金")
```

2. BMI計算
```python=
height = float(input("請輸入身高(公分): ")) / 100
weight = float(input("請輸入體重(公斤): "))
bmi = weight / (height ** 2)
print(f"BMI: {bmi:.2f}")
if bmi < 18.5:
    print("過輕")
elif 18.5 <= bmi < 24:
    print("正常")
elif 24 <= bmi < 27:
    print("過重")
elif 27 <= bmi < 30:
    print("輕度肥胖")
elif 30 <= bmi < 35:
    print("中度肥胖")
else:
    print("重度肥胖")
```

3. 簡單計算機
```python=
num1 = float(input("請輸入第一個數字: "))
num2 = float(input("請輸入第二個數字: "))
operation = input("請選擇運算 (+, -, *, /): ")
if operation == '+':
    print(f"結果: {num1 + num2}")
elif operation == '-':
    print(f"結果: {num1 - num2}")
elif operation == '*':
    print(f"結果: {num1 * num2}")
elif operation == '/':
    if num2 != 0:
        print(f"結果: {num1 / num2}")
    else:
        print("無法除以零")
else:
    print("無效的運算符")
```

# 數字與型態
## 整數類型
1. 基本類型：
    1. int: 整數類型，例如：1, -2, 100。
    2. bool: 布林值，僅有 True 和 False。
    注意：True 和 1 等價，False 和 0 等價。
    範例：
```python=
a = 0
print(a + True)  # 結果：1
print(a + False) # 結果：0
```

2. 浮點數類型
    1. 常見類型：
        1. float: 浮點數類型，例如：3.14, -0.01。
        2. decimal.Decimal: 高精度浮點運算，用於金融等精度敏感場合。
        3. complex: 複數類型，例如：1 + 2j。

    2. 精度問題：
    由於計算機使用二進位存儲，某些數值（如 0.1）存在存儲誤差。
    3. 範例：
```python=
print(0.1 + 0.2)  # 結果：0.30000000000000004
```

# 格式化輸出
## 使用 % 運算符
1. 格式符：
    1. %d: 以十進位整數輸出。
    2. %f: 以浮點數輸出。
    3. %s: 將變數轉換為字串輸出。
    4. %x: 十六進位輸出。
    5. 修飾符：
        1. %-: 靠左對齊。
        2. %0: 補零。
        3. %n.mf: 控制總寬度和小數位數。
2. 範例：
```python=
import math
print("PI = %f" % math.pi)       # 結果：PI = 3.141593
print("PI = %8.4f" % math.pi)    # 結果：PI =    3.1416
print("PI = %-8.4f" % math.pi)   # 結果：PI = 3.1416  
```

## 使用 str.format()
1. 格式化方式：
    1. {} 占位符，format() 方法填充。
    2. {位置} 或 {名稱} 指定填充順序。
    3. :.nf 控制小數位數。
2. 範例：
```python=
name = "帳單之門"
age = 99
gender = "male"
print("姓名: {0}".format(name))
print("年齡: {0}".format(age))
print("性別: {0}".format(gender))
```


## 練習題
1：格式化浮點數
題目：
請撰寫一程式，讓使用者輸入一個浮點數，並將其輸出到小數點後 2 位與 4 位。

提示：
使用 f-string 或 str.format() 來格式化浮點數。

範例程式碼：
```python=
# 輸入浮點數
num = float(input("請輸入一個浮點數："))

# 輸出小數點後 2 位與 4 位
print(f"小數點後 2 位：{num:.2f}")
print(f"小數點後 4 位：{num:.4f}")
```

輸入範例：
請輸入一個浮點數：12.345678

輸出範例：
小數點後 2 位：12.35
小數點後 4 位：12.3457


2. 日期格式化
題目：
請撰寫一程式，讓使用者輸入一個日期，然後輸出該日期的不同格式顯示（如：年-月-日 和 日/月/年）。

提示：
使用 datetime 模組來解析並格式化日期。
範例程式碼：
```python=
from datetime import datetime

# 輸入日期
date_str = input("請輸入日期 (格式：yyyy-mm-dd)：")

# 解析日期
date_obj = datetime.strptime(date_str, "%Y-%m-%d")

# 格式化日期
print(f"年-月-日 格式：{date_obj.strftime('%Y-%m-%d')}")
print(f"日/月/年 格式：{date_obj.strftime('%d/%m/%Y')}")
```
輸入範例：
請輸入日期 (格式：yyyy-mm-dd)：2024-11-29

輸出範例：
年-月-日 格式：2024-11-29
日/月/年 格式：29/11/2024

3. 列印表格
題目：
請撰寫一程式，列印一個數學表格，顯示從 1 到 5 的數字及其平方和立方。

提示：
使用格式化字串來對齊表格中的數據。
使用 f-string 或 str.format() 可以讓數字對齊。

範例程式碼：
```python=
print(f"{'數字':<6}{'平方':<6}{'立方':<6}")
for i in range(1, 6):
    print(f"{i:<6}{i**2:<6}{i**3:<6}")
```

輸出範例: 
```
數字  平方  立方  
1      1      1    
2      4      8    
3      9      27   
4      16     64   
5      25     125  
```

練習題 4：格式化對齊
題目：
請撰寫一程式，讓使用者輸入姓名與年齡，並輸出一個表格，將姓名右對齊，年齡左對齊。

提示：
使用 f-string 來對齊輸出的文本。
可以使用 <（左對齊）和 >（右對齊）來控制對齊方式。
範例程式碼：
```python=
# 輸入姓名和年齡
name = input("請輸入姓名：")
age = int(input("請輸入年齡："))

# 格式化輸出
print(f"{'姓名':<10}{'年齡':<10}")
print(f"{name:>10}{age:<10}")
```
輸入範例：
```
請輸入姓名：Alice
請輸入年齡：30
```
輸出範例：
```
姓名      年齡      
     Alice30      
```

5. 百分比格式化
題目：
請撰寫一程式，計算一個數字的百分比，並將其格式化輸出到小數點後 1 位。

提示：
使用 f-string 並將數字乘以 100。
使用 .1f 來輸出到小數點後 1 位。
範例程式碼：
```python=
# 輸入數字
num = float(input("請輸入一個數字："))

# 計算百分比並格式化輸出
percentage = num * 100
print(f"百分比為：{percentage:.1f}%")
```
輸入範例：
請輸入一個數字：0.763

輸出範例：
百分比為：76.3%

6. 計算平面上兩點的距離
設計說明:
請撰寫一程式,讓使用者輸入平面座標上,A點(x1,y1) 與 B點(x2,y2) 的座標值,並輸出正確的座標顯示與兩點的距離。

提示1:座標距離=√(x1 − x2)² + (y1 – y2)2
提示2:座標距離輸出到小數點後4位

範例程式碼:
```python=
import math

# 輸入 A 點與 B 點的座標
x1, y1 = map(float, input("請輸入 A 點的座標 (x1 y1): ").split())
x2, y2 = map(float, input("請輸入 B 點的座標 (x2 y2): ").split())

# 計算兩點的距離
distance = math.sqrt((x1 - x2)**2 + (y1 - y2)**2)

# 輸出座標與距離
print(f"A點: ({x1:.1f}, {y1:.1f})")
print(f"B點: ({x2:.1f}, {y2:.1f})")
print(f"兩點距離: {distance:.4f}")
```
輸入與輸出範例
輸入:
```
請輸入 A 點的座標 (x1 y1): 3.5 5.5
請輸入 B 點的座標 (x2 y2): 6.5 1.5
```
輸出:
```
A點: (3.5, 5.5)
B點: (6.5, 1.5)
兩點距離: 5.0000
```
解釋:
![image](https://hackmd.io/_uploads/SyygnSmw1x.png)


# 字串操作
## 基本操作
1. 定義字串：
    1. 單引號：'string'。
    2. 雙引號："string"。
    3. 三引號（多行）：'''string'''。

2. 索引與切片：
    1. 使用索引訪問字串的特定位置。
    2. 切片語法：str[start:end:step]。
3. 範例：
```python=
s = "Hello, World"
print(s[0])   # 結果：H
print(s[-1])  # 結果：d
print(s[0:5]) # 結果：Hello
```

## 字串方法
1. 常用方法：
    1. .lower() / .upper()：轉換大小寫。
    2. .strip()：去除首尾空格。
    3. .replace(old, new)：替換子字串。
    4. .split(delimiter)：分割字串。
    5. .join(iterable)：合併序列。
2. 範例：
```python=
s = " Hello, World! "
print(s.strip())              # 結果：Hello, World!
print(s.lower())              # 結果： hello, world! 
print(s.replace("World", "Python"))  # 結果： Hello, Python! 
```

# 型態轉換
## 常用函數
1. 數值轉換：
    1. int(x)：轉為整數。
    2. float(x)：轉為浮點數。

2. 容器轉換：
    1. list(s)：轉為列表。
    2. tuple(s)：轉為元組。
    3. str(x)：轉為字串。
3. 範例：
```python=
x = "123"
print(int(x))  # 結果：123
print(float(x))  # 結果：123.0
print(str(123))  # 結果："123"
```

### 練習題
1. 兩數相加：
```python=
a, b = 5.10, 2.30
print(f"{a:.2f} + {b:.2f} = {a + b:.2f}")  # 結果：5.10 + 2.30 = 7.40
```

2. 九九乘法表：
```python=
for i in range(1, 6):
    for j in range(1, 9):
        print(f"{i}*{j}={i*j:2}", end=" ")
    print()
```

# 函式基礎
Python 中的函式（function）是一段可以重複使用的程式碼，用於執行某個特定任務。以下詳細解釋各種函式特性與範例。

1. 定義函式與不傳參數:
    1. 函式可以定義一些執行的邏輯，並透過名稱來呼叫它。當不需要傳遞參數時，可以直接定義一個簡單的函式。

    2. 語法:
```python=
def 函式名稱():
    執行敘述
```

範例:
```python=
def say_hello():
    print("Hello, Python!")

# 呼叫函式
say_hello()
```

輸出：Hello, Python!

2. 傳遞參數
    1. 函式可以接受參數（parameters）來改變其行為。

    2. 語法:
```python=
def 函式名稱(參數1, 參數2):
    執行敘述
```
範例:
```python=
def greet(name, age):
    print(f"你好, {name}! 你今年 {age} 歲。")

# 呼叫函式
greet("小明", 18)
```

輸出：你好, 小明! 你今年 18 歲。


3. 預設參數值
    1. 函式中的參數可以有預設值。如果呼叫函式時未提供對應引數，會自動使用預設值。

    2. 語法:
```python=
def 函式名稱(參數1, 參數2=預設值):
    執行敘述
```

範例:
```python=
def greet(name, age=20):
    print(f"你好, {name}! 你今年 {age} 歲。")

# 呼叫函式（使用預設值）
greet("小明")

# 呼叫函式（覆寫預設值）
greet("小華", 25)
```
輸出：
```
你好, 小明! 你今年 20 歲。
你好, 小華! 你今年 25 歲。
```

4. 回傳值
    1. 函式可以使用 return 關鍵字將結果傳回呼叫者。

     2. 語法:
```python=
def 函式名稱(參數):
    執行敘述
    return 回傳值
```

範例:次方函式
```python=
def power(x, y):
    return x ** y

# 主程式
base = int(input("請輸入底數數字："))
exponent = int(input("請輸入次方數字："))
result = power(base, exponent)
print(f"{base} 的 {exponent} 次方為 {result}")
```
範例輸入：
```
請輸入底數數字：3
請輸入次方數字：4
```
範例輸出：3 的 4 次方為 81

5. 進階範例：開次方根
    1. 設計一個函式計算開𝑛次方根的結果。

    2. 範例:
```python=
def nroot(x, y):
    return x ** (1 / y)

# 主程式
radicand = float(input("請輸入被開方數字："))
root = float(input("請輸入開方數字："))
result = nroot(radicand, root)
print(f"{radicand} 的 {root} 次方根為 {result:.3f}")
```

範例輸入：
```
請輸入被開方數字：64
請輸入開方數字：6
```
範例輸出：64 的 6 次方根為 2.000

詳細解釋:
1. 函式結構
    1. def 關鍵字定義函式。
    2. 函式名稱應該具有描述性。
    3. 函式內的程式碼需有一致的縮排。

2. 傳遞參數
    1. 位置參數：按順序傳遞給函式。
    2. 預設參數值：若不提供引數，使用定義時的預設值。
    3. 關鍵字參數：明確指定參數名稱，提高可讀性。

3. 回傳值:函式可以回傳一個值，也可以回傳多個值（以元組形式）。

4. 應用場合:次方運算與開次方根是常見的數學運算，可用於科學計算與資料分析。

# 容器
## Tuple（序對）
在 Python 中，元組 (tuple) 是一種資料結構，類似於列表 (list)，但有幾個關鍵的不同點：

1. 不可變性 (Immutability)：
元組一旦創建，就無法再改變其內容。與列表不同，元組的元素無法被新增、修改或刪除，只能覆蓋。這使得元組適用於需要保證資料不被修改的場合。

2. 語法與列表區別：元組使用小括弧 () 表示，而列表則使用中括弧 []。

3. 可包含多種資料類型：元組中的元素可以是不同資料型態的，如整數、浮點數、字串等。

### 元組的基本操作
1. 建立元組：
    1. 空元組：tuple1 = tuple() 或 tuple1 = ()
    2. 有初始值的元組：tuple1 = (1, 2, 3, 4, 5)
    3. 可以包含不同型別的資料：tuple1 = (1, "項目1", 5.2, True)

2. 內建函式：
    1. len(tuple1)：計算元組的長度（項目數）。
    2. max(tuple1)：返回元組中最大值。
    3. min(tuple1)：返回元組中最小值。
    4. sum(tuple1)：返回元組中所有元素的總和。

3. 其他方法：
    1. tuple1.count(x)：返回元素 x 在元組中出現的次數。
    2. tuple1.index(x)：返回元素 x 在元組中第一次出現的索引值。

4. 基本操作：

    1. 建立：t = ('a', 'b', 'c')
    2. 取值：t[0] 或 t[-1] (正序與倒序)
    3. 方法：
    count(value)：計算特定值出現的次數。
    index(value[, start[, stop]])：回傳指定值的索引。
    
5. 元組的修改操作
雖然元組本身不可變，但可以通過建立新的元組來進行“修改”操作。可以將兩個元組進行連接，得到一個新的元組：
```python=
tuple1 = (1, 2, 3)
tuple2 = (4, 5)
tuple1 = tuple1 + tuple2  # 這會創建一個新的元組
```
注意：
1. 元組的元素是不可變的，但元組本身的參考（變數）是可以重新指派的。
2. 元組的元素如果是單一的數字（例如 (6)），則這樣其實不是元組，而是一個數字。如果要讓它成為元組，需要在數字後加上逗號（例如 (6,)）。

6. 限制：
    1. tuple.count() 無法指定範圍。
    2. 不支援如 append、remove 等修改方法。



### 範例：
1.
```python=
t = ('a', 'b', 'mary', 'john', 'a', 'mary', 'a')
print(t.index('a', 1, 5))  # Output: 4
print(t.count('mary'))     # Output: 2
```

2. 串列數組轉換
根據你的需求，這是一個將串列轉換為元組的範例，並顯示元組的長度、最大值、最小值和總和。

程式設計說明：
    1. 使用者輸入若干個整數，直到輸入 -9999 停止。
    2. 不將 -9999 加入串列，並將串列轉換為元組。
    3. 輸出該元組的長度、最大值、最小值及總和。

程式碼實現：
```python=
# 建立空的串列
numbers_list = []

# 不斷請使用者輸入數字，直到輸入 -9999
print("請輸入整數（輸入 -9999 結束）：")
while True:
    try:
        num = int(input(f"請輸入第{len(numbers_list) + 1}個數字："))
        if num == -9999:  # 停止條件
            break
        numbers_list.append(num)  # 將輸入的數字加入串列
    except ValueError:
        print("請輸入有效的整數！")

# 將串列轉換為數組 (tuple)
numbers_tuple = tuple(numbers_list)

# 顯示數組及相關資訊
print(f"\n數組內容：{numbers_tuple}")
print(f"長度：{len(numbers_tuple)}")
print(f"最大值：{max(numbers_tuple)}")
print(f"最小值：{min(numbers_tuple)}")
print(f"總和：{sum(numbers_tuple)}")
```
範例輸入：
```
請輸入整數（輸入 -9999 結束）：
請輸入第1個數字：6
請輸入第2個數字：-29
請輸入第3個數字：51
請輸入第4個數字：32
請輸入第5個數字：18
請輸入第6個數字：-73
請輸入第7個數字：30
請輸入第8個數字：-9999
```
範例輸出：
```
數組內容：(6, -29, 51, 32, 18, -73, 30)
長度：7
最大值：51
最小值：-73
總和：35
```
程式邏輯詳解：
使用 while True 不斷讓使用者輸入數字，直到輸入 -9999 為止。
輸入的數字會加入到 numbers_list 這個串列中。
使用 tuple() 將串列轉換為元組。
輸出元組的長度、最大值、最小值和總和，分別使用 len()、max()、min() 和 sum() 來取得。

## List（串列）
### 串列基本定義與操作
1. 建立串列
    1. 空串列：list1 = list() 或 list1 = []
    2. 初始值：list1 = [1, 2, 3, 4, 5]
    3. 支援多型態：list1 = [1, "文字", 3.5, True]

2. 取值與索引
    1. list1[index]：取單一項目。
    2. 負索引：list1[-1] 表示最後一項。
    3. 切片操作：list1[start:end]，不含 end，可省略 start 或 end。

3.嵌套列表:支援多層結構：如 list1 = [1, [10, 20], 3]，使用 list1[1][0] 取得子串列值。

4. 修改內容:直接賦值：list1[2] = "新值"

### 運算與操作
1. 串列運算
    1. 合併：list1 + list2
    2. 重複：list1 * 3
    3. 刪除：del list1[index]

2. 成員測試
    1. 是否存在：'a' in list1
    2. 比較串列：list1 == list2

3. 內建函式
    1. 長度：len(list1)
    2. 最大/最小值：max(list1), min(list1)
    3. 總和：sum(list1)

常用方法：

    1. 新增資料：
        1. append(x)：在尾端新增一個元素。
        2. extend(iterable)：將另一可迭代物件展開後加入。
        3. insert(index, x)：插入元素至指定索引。
    2. 刪除資料：
        1. remove(value)：刪除第一個匹配的值。
        2. pop([index])：移除並回傳指定索引的值（預設最後一項）。
        3. clear()：清空所有元素。
    3. 查詢與計數：
        1. index(value[, start[, stop]])：查找索引。
        2. count(value)：計算值的出現次數。
    4. 排序與反轉：
        1. sort()：排序（預設升序，可傳入 reverse=True）。
        2. reverse()：反轉順序。
    5. 複製：copy()：回傳一份淺拷貝。
    
```python=
# 建立與基本操作
lst = [1, 2, 3]
lst.append(4)  # [1, 2, 3, 4]
lst.extend([5, 6])  # [1, 2, 3, 4, 5, 6]
lst.insert(2, 10)  # [1, 2, 10, 3, 4, 5, 6]
lst.pop()  # 移除並回傳最後一項 [1, 2, 10, 3, 4, 5]

# 排序
lst = [3, 1, 2]
lst.sort()  # [1, 2, 3]
lst.sort(reverse=True)  # [3, 2, 1]
```
3. 應用：倒序與回復 問題：使用 append 和 pop 實現倒序與回復。
```python=
folder = []
for i in range(5, 0, -1):
    folder.append(i)
for _ in range(len(folder)):
    print(folder.pop())
```

結果:
```python=
5
4
3
2
1
```
## Tuple 與 List 的比較
1. 基本特性
| 特性       | Tuple（元組）                      | List（列表）                                       |
| -------- | ------------------------------ | ---------------------------------------------- |
| **定義方式** | 使用小括號 `()`                     | 使用方括號 `[]`                                     |
| **可變性**  | 不可變 (**Immutable**)            | 可變 (**Mutable**)                               |
| **元素類型** | 可以包含不同類型的元素                    | 可以包含不同類型的元素                                    |
| **長度**   | 長度固定，不能動態增減元素                  | 長度可變，可以動態增減元素                                  |
| **方法**   | 僅支援少量方法（如 `count()`、`index()`） | 提供多種操作方法（如 `append()`、`remove()`、`extend()` 等） |

    1. Tuple 的性能優勢：
        1. Tuple 是不可變的，因此它的實現比 List 更高效，尤其是在需要存儲不變數據的情況下。
        2. Tuple 在內存使用上通常比 List 更小，因為它不需要額外的內存用於動態調整大小。
    2. List 的靈活性：List 的可變性使其適合需要頻繁修改（增刪改）數據的情境，但這也帶來了稍高的內存和性能成本。

3. 使用場景

| 使用場景         | Tuple（元組） ✅      | List（列表） ✅                        |
| ------------ | ---------------- | --------------------------------- |
| **數據不變性要求**  | 適合（如座標、日期等不可變資料） | 不適合（因為可修改）                        |
| **需要頻繁修改數據** | 不適合（無法增刪改）       | 適合（支援增刪改，如 `append()`、`remove()`） |
| **作為字典的鍵**   | 可以（因為不可變）        | 不可以（因為可變）                         |
| **函數返回多個值**  | 常用（例如 `(x, y)`）  | 不常用（但可以回傳 List）                   |

4. 常見操作與差異
Tuple 操作範例
```
# 定義一個 Tuple
t = (1, 2, 3, 4, 5)

# 訪問元素
print(t[0])  # 輸出：1

# 元組長度
print(len(t))  # 輸出：5

# 不可修改
# t[1] = 10  # 會引發錯誤，因為 Tuple 不可變

# 支援解包
a, b, c, d, e = t
print(a, b, c)  # 輸出：1 2 3
```
List 操作範例
```
# 定義一個 List
l = [1, 2, 3, 4, 5]

# 訪問與修改元素
print(l[0])  # 輸出：1
l[1] = 10
print(l)  # 輸出：[1, 10, 3, 4, 5]

# 添加與刪除元素
l.append(6)
print(l)  # 輸出：[1, 10, 3, 4, 5, 6]
l.remove(10)
print(l)  # 輸出：[1, 3, 4, 5, 6]
```
5. 總結比較

| 特性       | Tuple（元組）        | List（列表）       |
| -------- | ---------------- | -------------- |
| **不可變性** | 不可變，適合保存固定數據     | 可變，適合頻繁操作的數據集合 |
| **效能**   | 內存使用較少，存取速度較快    | 佔用內存較多，靈活但速度稍慢 |
| **靈活性**  | 靈活性較低            | 靈活性較高          |
| **用途建議** | 用於數據不可變的情境或作為字典鍵 | 用於需要頻繁改變數據的場景  |

### 串列練習題
1. 撲克牌總和
```python=
# 建立牌面與點數對應表
card_values = {'A': 1, 'J': 11, 'Q': 12, 'K': 13}
card_values.update({str(i): i for i in range(2, 11)})

# 輸入五張牌面
cards = [input(f"請輸入第{i+1}個牌面：") for i in range(5)]

# 計算總和
total = sum(card_values[card] for card in cards)
print(f"總點數為 {total}")
```

2. 奇數索引數值加總
```python=
# 輸入10個整數
numbers = [int(input(f"請輸入第{i+1}個數字：")) for i in range(10)]

# 計算奇數索引數值加總
odd_index_sum = sum(numbers[i] for i in range(1, len(numbers), 2))
print(f"奇數索引數值總和為：{odd_index_sum}")
```


3. 成績列印
```python=
# 輸入10個成績
scores = [int(input(f"請輸入第{i+1}個成績：")) for i in range(10)]

# 計算最高分、最低分、總和、平均
max_score = max(scores)
min_score = min(scores)
total_score = sum(scores)
average_score = total_score / len(scores)

print(f"最高分為：{max_score}")
print(f"最低分為：{min_score}")
print(f"總和成績為：{total_score}")
print(f"平均成績為：{average_score:.1f}")
```

4. 出現最多次的數字
```python=
# 輸入10個整數
numbers = [int(input(f"請輸入第{i+1}個數字：")) for i in range(10)]

# 計算出現次數最多的數字
most_common = max(numbers, key=numbers.count)
count = numbers.count(most_common)

print(f"{most_common} 出現最多次，共出現 {count} 次")
```

5. 數字排序
```python=
# 輸入10個整數
numbers = [int(input(f"請輸入第{i+1}個數字：")) for i in range(10)]

# 排序
sorted_numbers = sorted(numbers, reverse=True)

# 取出最大與最小的三個數字
largest_three = sorted_numbers[:3]
smallest_three = sorted_numbers[-3:]

print(f"最大三個數：{largest_three}")
print(f"最小三個數：{smallest_three}")
```


6. 大樂透隨機號碼產生程式
```python=
import random

# 隨機選取6個中獎號碼，從1到49中選出，並排序
winning_numbers = sorted(random.sample(range(1, 50), 6))

# 隨機選取特別號，且與中獎號碼不重複
special_number = random.choice([num for num in range(1, 50) if num not in winning_numbers])

# 輸出結果
print(f"樂透中獎號碼：{winning_numbers}")
print(f"特別號：{special_number}")
```
解說

    1. 隨機選號：
    使用 random.sample 從範圍 1~49 中隨機選出 6 個不重複數字。
    排序後使用 sorted 顯示中獎號碼。

    2. 特別號：
    使用 random.choice 從剩下的未選中的號碼中隨機選取一個特別號，確保不與中獎號碼重複。

    3. 執行範例輸出：

```
樂透中獎號碼：[2, 5, 25, 26, 37, 42]
特別號：8
```
 
    4. 補充:快速產生規律串列的技巧
        以下為常用的方法補充：

        利用 range
        ```
        list1 = list(range(1, 50))  # 產生 1~49 的串列
        ```

        利用 map
        ```
        str_numbers = ["1", "2", "3"]
        int_numbers = list(map(int, str_numbers))  # 轉為整數：[1, 2, 3]
        ```
        隨機工具
        random.shuffle：
        ```
        numbers = [1, 2, 3, 4, 5]
        random.shuffle(numbers)  # 將順序打亂
        ```


        random.sample：
        ```
        subset = random.sample(range(1, 50), 6)  # 從 1~49 中取 6 個不重複數字
        ```


7. 猜數字遊戲
```python=
import random

# 生成4位不重複的隨機密碼
def generate_secret_code():
    return random.sample(range(0, 10), 4)

# 計算幾A幾B
def calculate_ab(secret, guess):
    A = sum(s == g for s, g in zip(secret, guess))  # 位置正確的數字個數
    B = sum(g in secret for g in guess) - A       # 數字正確但位置錯誤的數字個數
    return A, B

# 確保輸入為合法的4位不重複數字
def get_valid_guess():
    while True:
        guess = input("請輸入4個不重複的數字：")
        if len(guess) == 4 and guess.isdigit() and len(set(guess)) == 4:
            return [int(x) for x in guess]
        print("輸入錯誤！請輸入4個不重複的數字。")

# 主遊戲邏輯
def main():
    print("歡迎來到猜數字遊戲！")
    secret_code = generate_secret_code()
    attempts = 0

    while True:
        attempts += 1
        guess = get_valid_guess()
        A, B = calculate_ab(secret_code, guess)
        print(f"{A}A{B}B")
        
        if A == 4:  # 猜中4A0B，遊戲結束
            print(f"恭喜你猜對了！總共嘗試了 {attempts} 次。")
            break

# 運行遊戲
if __name__ == "__main__":
    main()
```
程式說明
1. 生成密碼：使用 random.sample 隨機生成 4 個不重複的 0~9 數字作為密碼。

2. 輸入檢查：使用 get_valid_guess 確保玩家輸入的數字為 4位且無重複。
若輸入非法，會提示玩家重新輸入。

3. 計算幾A幾B：
    1. A (位置與數字正確)：比較密碼和猜測數字的對應位置，計算相等數字的個數。
    2. B (數字正確但位置錯誤)：計算猜測中出現在密碼中的數字，減去 A 的個數。

4. 遊戲迴圈：
    1. 玩家輸入後計算 幾A幾B 並顯示結果。
    2. 當結果為 4A0B 時，顯示總共嘗試的次數並結束遊戲。

執行範例
範例輸入與輸出:
```
歡迎來到猜數字遊戲！
請輸入4個不重複的數字：1234
0A2B
請輸入4個不重複的數字：5678
1A1B
請輸入4個不重複的數字：5693
4A0B
恭喜你猜對了！總共嘗試了 3 次。
```


8. BlackJack (21點)
```python=
import random

# 建立撲克牌並洗牌
def create_deck():
    suits = ['♠', '♥', '♦', '♣']  # 花色
    ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']  # 點數
    deck = [(rank, suit) for suit in suits for rank in ranks]
    random.shuffle(deck)
    return deck

# 計算手牌總點數
def calculate_points(hand):
    points = 0
    aces = 0
    for card in hand:
        rank = card[0]
        if rank in ['J', 'Q', 'K']:
            points += 10
        elif rank == 'A':
            points += 11
            aces += 1
        else:
            points += int(rank)

    # 調整A的點數 (如總點數超過21則將A計為1)
    while points > 21 and aces:
        points -= 10
        aces -= 1
    return points

# 顯示手牌
def display_hand(hand, is_dealer=False):
    if is_dealer:
        print(f"莊家的牌：[{hand[0][0]}{hand[0][1]}] + ?")
    else:
        hand_str = " ".join([f"{card[0]}{card[1]}" for card in hand])
        print(f"玩家的牌：{hand_str}")

# 主遊戲邏輯
def blackjack():
    print("歡迎來到 21 點遊戲！")
    deck = create_deck()
    player_hand = [deck.pop(), deck.pop()]
    dealer_hand = [deck.pop()]

    # 初始顯示
    display_hand(player_hand)
    display_hand(dealer_hand, is_dealer=True)

    # 玩家操作
    while True:
        player_points = calculate_points(player_hand)
        print(f"玩家目前點數：{player_points}")
        if player_points > 21:
            print("爆牌！莊家勝利！")
            return

        action = input("是否要牌？(y/n): ").strip().lower()
        if action == 'y':
            player_hand.append(deck.pop())
            display_hand(player_hand)
        elif action == 'n':
            break
        else:
            print("請輸入 'y' 或 'n'！")

    # 莊家操作
    while True:
        dealer_points = calculate_points(dealer_hand)
        if dealer_points >= 17:
            break
        dealer_hand.append(deck.pop())

    # 最終結果
    player_points = calculate_points(player_hand)
    dealer_points = calculate_points(dealer_hand)
    dealer_hand_str = " ".join([f"{card[0]}{card[1]}" for card in dealer_hand])

    print(f"\n莊家的牌：{dealer_hand_str}，總點數：{dealer_points}")
    print(f"玩家的牌：{' '.join([f'{card[0]}{card[1]}' for card in player_hand])}，總點數：{player_points}")

    if dealer_points > 21 or player_points > dealer_points:
        print("恭喜玩家獲勝！")
    elif player_points < dealer_points:
        print("莊家獲勝！")
    else:
        print("平局！")

# 運行遊戲
if __name__ == "__main__":
    blackjack()
```
程式說明:
    
    1. 撲克牌生成與洗牌：使用 create_deck 函數創建 52 張牌，並隨機打亂順序。

    2. 點數計算：calculate_points 函數將 J, Q, K 視為 10 點，A 可靈活計算為 1 或 11。

    3. 玩家回合：玩家可選擇是否要牌，直到停止要牌或爆牌為止。

    4. 莊家回合：莊家點數不足 17 時自動抽牌，直到大於等於 17 點為止。

    5. 勝負判定：
        1. 玩家爆牌，莊家直接勝出。
        2. 莊家爆牌或玩家點數更接近 21，則玩家勝出。
        3. 若雙方點數相同則平局。
執行範例:
```
歡迎來到 21 點遊戲！
玩家的牌：5♠ K♣
莊家的牌：[9♥] + ?

玩家目前點數：15
是否要牌？(y/n): y
玩家的牌：5♠ K♣ 2♦
玩家目前點數：17
是否要牌？(y/n): n

莊家的牌：9♥ 6♦，總點數：15
莊家的牌：9♥ 6♦ 4♣，總點數：19

玩家的牌：5♠ K♣ 2♦，總點數：17
莊家獲勝！
```
# 集合操作 (Set Operations)
1. 集合的基本概念
    1. 集合是一種無序、不重複的數據結構。
    2. 可以使用大括號 {} 或 set() 創建集合。
    3. 集合操作包括交集 (intersection)、聯集 (union)、差集 (difference)、對稱差集 (symmetric_difference)、新增、刪除元素等。


## 集合建立set
1.建立一個空的set(也相當於宣告)：
set1 = set( ) 但不可以是set1 = { }，這樣型態為dict

2. 建立時給予初始值:
set1 = { 1, 2, 3, 4, 5 }
 
3. set 內的元素可以是不同型態
set1 = { 1, "項目1", 5.2, True }

## 內建函式
set1 = { 1, 3, 5, 7, 9, 1, 3, 5, 1}
1. len( set1 )  5：計算集合長度(項目數)，項目不重複
2. max( set1 )  9 ：取項目中最大值
3. min( set1 )  1 ：取項目中最小值
4. sum( set1 )  25 ：項目總和

## set 支援的運算子
1. in 或not in 運算子，檢查元素是否存在集合
2. ==、!=、<=、<、>=、>比較運算子，檢查項目是否相等、或是否完全包含或被包含等，不是比集合長度
3. set 無順序之分，不支援連接運算子(+)、重複運算子( * )、索引運算子([] )、片段運算子( [start: end] )

## set 運算與方法
| 方法                                       | 說明                       |       |
| ---------------------------------------- | ------------------------ | ----- |
| **add(x)**                               | 將元素 `x` 添加到集合中。          |       |
| **remove(x)**                            | 從集合中移除元素 `x`，若不存在則拋出錯誤。  |       |
| **discard(x)**                           | 從集合中移除元素 `x`，若不存在則不拋出錯誤。 |       |
| **pop()**                                | 隨機移除集合中的一個元素，並返回該元素。     |       |
| **clear()**                              | 清空集合中的所有元素。              |       |
| \**union(*others)**                      | 返回集合的聯集（等價於 \`           | \`）。  |
| \**intersection(*others)**               | 返回集合的交集（等價於 `&`）。        |       |
| \**difference(*others)**                 | 返回集合的差集（等價於 `-`）。        |       |
| **symmetric\_difference(other)**         | 返回集合的對稱差集（等價於 `^`）。      |       |
| \**update(*others)**                     | 更新集合為聯集（等價於 \`           | =\`）。 |
| \**intersection\_update(*others)**       | 更新集合為交集（等價於 `&=`）。       |       |
| \**difference\_update(*others)**         | 更新集合為差集（等價於 `-=`）。       |       |
| **symmetric\_difference\_update(other)** | 更新集合為對稱差集（等價於 `^=`）。     |       |

說明：
1. x in s 和 x not in s 用來判斷元素 x 是否在集合 s 中，或是是否不在集合 s 中。
2. 交集 (&)：返回兩個集合共同擁有的元素。
3. 聯集 (|)：返回兩個集合的所有元素，去掉重複的部分。
4. 對稱差集 (^)：返回兩個集合中，只屬於其中一個集合的元素，不包括交集的部分。
5. 差集 (-)：返回一個集合中有，但另一集合中沒有的元素。
6. 子集合 (<=) 和 真子集合 (<)：檢查集合 s1 是否為集合 s2 的子集合或真子集合。
7. 超集合 (>=) 和 真超集合 (>)：檢查集合 s1 是否為集合 s2 的超集合或真超集合。

| 方法                 | 功能                                      | 範例                                              | 結果                           |
| ------------------ | --------------------------------------- | ----------------------------------------------- | ---------------------------- |
| **isdisjoint(s2)** | 檢查集合與 `s2` 是否沒有共同元素。返回 `True` 或 `False` | `s1 = {1,2,3}; s2 = {4,5,6}; s1.isdisjoint(s2)` | `True`                       |
| **copy()**         | 返回集合的淺拷貝（不同物件，內容相同）                     | `s1 = {1,2,3}; s2 = s1.copy()`                  | `s2 = {1,2,3}`，但與 `s1` 不共用內存 |
| **add(x)**         | 添加元素 `x` 到集合中（若已存在則無效）                  | `s1 = {1,2}; s1.add(3)`                         | `s1 = {1,2,3}`               |
| **remove(x)**      | 移除元素 `x`，若不存在則拋出 `KeyError`             | `s1 = {1,2,3}; s1.remove(2)`                    | `s1 = {1,3}`                 |
| **discard(x)**     | 移除元素 `x`，若不存在則什麼也不做                     | `s1 = {1,2,3}; s1.discard(4)`                   | `s1 = {1,2,3}`               |
| **pop()**          | 隨機移除並返回一個元素；若集合為空，拋出 `KeyError`         | `s1 = {1,2,3}; x = s1.pop()`                    | 可能返回 `1`，並更新為 `s1 = {2,3}`   |
| **clear()**        | 清空集合                                    | `s1 = {1,2,3}; s1.clear()`                      | `s1 = set()`                 |

說明：
1. s1.isdisjoint(s2)：檢查兩個集合 s1 和 s2 是否沒有共同元素。如果兩個集合沒有交集，返回 True，否則返回 False。
2. s1.copy()：返回集合 s1 的一個新拷貝。這不會影響原來的集合。
3. s1.add(x)：將元素 x 添加到集合 s1 中。如果元素已經存在，則不會添加重複的元素。
4. s1.remove(x)：從集合 s1 中移除元素 x。如果元素 x 不在集合中，會拋出 KeyError。
5. s1.pop()：隨機從集合 s1 中移除並返回一個元素。由於集合是無序的，因此移除的元素是隨機的。
6. s1.clear()：移除集合 s1 中的所有元素，使集合變成空集。
##  基本運算與範例
1. 交集 (AND):找出兩集合中共有的元素。
    1. 方法: A & B 或 A.intersection(B)
    2. 範例:
```python=
A = {"California", "New York"}
B = {"New York", "Phoenix", "Chicago"}
print(A & B)  # {'New York'}
```

2. 聯集 (OR):找出兩集合中所有元素（不重複）。
    1. 方法: A | B 或 A.union(B)
    2. 範例
```python=
print(A | B)  # {'California', 'New York', 'Phoenix', 'Chicago'}
```

3. 差集 (Differenˊce):找出在集合 A 中但不在集合 B 中的元素。
1. 方法: A - B 或 A.difference(B)
2. 範例:
```python=
print(A - B)  # {'California'}
```

3. 對稱差集 (XOR):找出兩集合中不重複的元素（僅屬於其中一個集合）。
    1. 方法: A ^ B 或 A.symmetric_difference(B)
    2. 範例:
```python=
print(A ^ B)  # {'California', 'Phoenix', 'Chicago'}
```

## 實作範例 
1：水果集合操作
題目需求:
itemsA 加入任意兩樣水果，刪除一樣與「蘋果」。
itemsB 加入任意兩樣水果，刪除一樣與「蓮霧」。
計算以下集合操作：
所有的水果且不重複
兩者皆有的水果
itemsA 獨有的水果
itemsB 獨有的水果
兩者不重複的水果
```python=
# 初始集合
itemsA = {"蘋果", "香蕉", "鳳梨", "芭樂"}
itemsB = {"鳳梨", "蘋果", "水梨", "蓮霧"}

# 修改集合
itemsA.add("橘子")
itemsA.add("葡萄")
itemsA.remove("蘋果")

itemsB.add("草莓")
itemsB.add("芒果")
itemsB.remove("蓮霧")

# 計算
all_fruits = itemsA | itemsB  # 聯集
common_fruits = itemsA & itemsB  # 交集
unique_to_A = itemsA - itemsB  # A 獨有
unique_to_B = itemsB - itemsA  # B 獨有
symmetric_diff = itemsA ^ itemsB  # 對稱差集

# 結果輸出
print("所有的水果且不重覆:", sorted(all_fruits))
print("兩者皆有的水果:", sorted(common_fruits))
print("itemsA 獨有的水果:", sorted(unique_to_A))
print("itemsB 獨有的水果:", sorted(unique_to_B))
print("兩者不重覆的水果:", sorted(symmetric_diff))
```

2：學生名單操作
題目需求:
數學及格但英文不及格的同學。
數學不及格但英文及格的同學。
兩者皆及格的同學。
```python=
# 初始集合
math_pass = {"柯南", "灰原", "步美", "美環", "光彦"}
english_pass = {"柯南", "灰原", "丸尾", "野口", "步美"}

# 計算
math_only = math_pass - english_pass  # 數學及格但英文不及格
english_only = english_pass - math_pass  # 英文及格但數學不及格
both_pass = math_pass & english_pass  # 兩者皆及格

# 結果輸出
print("數學及格但英文不及格的同學:", sorted(math_only))
print("數學不及格但英文及格的同學:", sorted(english_only))
print("兩者皆及格的同學:", sorted(both_pass))
```