# 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
2. 在vscode裡面執行
# 基礎
## 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 開始），例如：

x = "Hello, World"
print(x[7])  # 輸出 'W' 空格也是一個字符

3. 容器型別（Container Types）
tuple: 序對，有順序但不可變，使用 ( )。
list: 清單，有順序且可變，使用 [ ]。
set: 集合，無順序且不可重複，使用 { }。
dict: 字典，鍵值對形式，使用 {key: value}。
## 2. 檢查資料型態
使用 type() 函數來檢查變數的型態：

x = 123
print(type(x))  # <class 'int'>

## 3. print() 函數
1. 基本格式：

print(value1, value2, ..., sep=' ', end='\n')

2. 參數說明：
sep：指定多個值之間的分隔符，預設為空格。
end：輸出結尾，預設為換行符號 \n。
3. 範例:

print("Hello", "World", sep="@")  # 輸出：Hello@World
print("Python", end="!")         # 輸出：Python!

## 4. 跳脫字元
1. 常見的跳脫字元：
\n：換行
\t：水平定位
\\：印出反斜線
\' 或 \"：印出單引號或雙引號
2. 範例:

print("姓名\t年齡\n王小明\t20")  # 格式化輸出

3. 結果:

## 5. 使用者輸入
1. input() 函數：
1. 用於接收使用者輸入，預設為字串型別。
2. 可以用 int() 或 float() 將輸入轉為數值型態。
2. 範例:

num1 = int(input("請輸入數字1: "))
num2 = int(input("請輸入數字2: "))
print("兩數相加結果:", num1 + num2)

## 6. eval() 函數
1. 將輸入轉為 Python 表達式進行運算，但要小心安全性問題。
2. 範例：

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 支援簡單的變數值交換，例如：

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)`
✅ 範例：

name = "小明"
place = "台中"
print("{}今天去了{}".format(name, place))

🔄 輸出：
`小明今天去了台中`
🔧 特色與功能：
1. 可指定位置：`"{1}在{0}工作".format("台北", "小王") # 小王在台北工作`
2. 可指定變數名稱：`"{name}來自{name_place}".format(name="小艾", name_place="高雄")`
## 方法二：f-string（Python 3.6+ 推出）
✅ 語法：`f"文字{變數}文字{表達式}"`
✅ 範例：

name = "小明"
place = "台中"
print(f"{name}今天去了{place}")

🔄 輸出：
`小明今天去了台中`

💡 f-string 也支援表達式與函式！

x = 10
y = 5
print(f"總和是：{x + y}")  # 總和是：15
print(f"名稱大寫：{name.upper()}")  # 名稱大寫：小明 → 小明

## 📊 比較總表
# 格式化字符
## 數字對齊與寬度控制
語法： {格式}

範例:

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

輸出:

       123
       123
123       
   123    

## 小數精度與符號控制
語法： {格式}

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

輸出:

3.142
+3.142
3

## 補充：更多數值格式選項
1. 格式化的常用符號
2. 對齊方式

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

輸出:

0000000123
123*******
~~~123~~~~

2. 千分位分隔符
1. 語法：{:,.格式}
2. 在數字中插入千分位逗號。

num = 1234567.89
print("{:,.2f}".format(num))  # 保留兩位小數，千分位逗號分隔

輸出:1,234,567.89
# 判斷式
## if
1. 單向判斷 (if...)
適用於條件成立時執行某段程式碼。

if a > b:
    print("a比較大")

2. 雙向判斷 (if...else)
條件成立執行第一段程式碼，否則執行第二段。

if a > b:
    print("a比較大")
else:
    print("b等於a或比較大")

3. 多向判斷 (if...elif...else)
適用於多條件分支情境。

if a > b and a > c:
    print("a最大")
elif b > a and b > c:
    print("b最大")
else:
    print("c最大")

4. 巢狀判斷
判斷式內部包含另一個判斷式，用於處理複雜條件。

if a > 0:
    if a % 2 == 0:
        print("a是正偶數")
    else:
        print("a是正奇數")
else:
    print("a不是正數")

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

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

範例程式碼：

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年又是閏年
範例程式碼：

# 輸入年份
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 迴圈
適用於遍歷序列（如清單、字串）。

for i in range(5):
    print(i)

2. while 迴圈
當條件成立時重複執行。

count = 0
while count < 5:
    print(count)
    count += 1

3. 巢狀迴圈
迴圈內部包含另一個迴圈。

for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

4. 控制迴圈流程
1. break：強制結束迴圈。
2. continue：跳過本次迴圈，進入下一次迴圈。

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 的數字序列。

範例：

for i in range(5):
    print(i)

輸出：:

0
1
2
3
4

這代表 range(5) 會生成從 0 到 4 的數字序列。

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

範例：

for i in range(5, 10):
    print(i)

輸出:

5
6
7
8
9

這代表 range(5, 10) 會生成從 5 到 9 的數字序列。

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

範例：

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 層的直角三角形，使用 @ 字元。

範例程式碼：

# 讓使用者輸入數字 n
n = int(input("請輸入數字："))

# 列印直角三角形
for i in range(1, n + 1):
    print('@' * i)

範例輸入：`7`
範例輸出：

@
@@
@@@
@@@@
@@@@@
@@@@@@
@@@@@@@

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

範例程式碼：

# 讓使用者輸入數字 n
n = int(input("請輸入數字："))

# 列印反直角三角形
for i in range(n, 0, -1):
    print('@' * i)

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

範例輸出：

@@@@@@@
@@@@@@
@@@@@
@@@@
@@@
@@
@

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

範例程式碼：

# 讓使用者輸入數字 n
n = int(input("請輸入數字："))

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

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

     @
    @@@
   @@@@@
  @@@@@@@
 @@@@@@@@@
@@@@@@@@@@@

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

範例程式碼：

# 讓使用者輸入數字 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. 列印兩位數的八進位數字
設計說明： 列印兩位數的八進位數字，每行列印八組數字，中間一個空白。

範例程式碼：

# 列印兩位數的八進位數字
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 開始，並逐行減少一個數字。

範例程式碼：

# 列印數字三角形
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（逐行增加），並且每行減少一個數字。

範例程式碼：

# 列印數字三角形
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。

範例程式碼：

# 列印數字三角形
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. 列印九九乘法表（整齊排列）
設計說明： 列印九九乘法表，並保持排列整齊，輸出每一個乘法式。

範例程式碼：

# 列印九九乘法表
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

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. 找出輸入值中的最小值

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. 找出輸入值中的最大值

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. 數字反轉

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. 數字加總

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. 倍數的個數與總和

# 輸入起始與結束值
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. 成績判斷

score = int(input("請輸入分數: "))
if score >= 95:
    print("獎金2000元")
elif 90 <= score < 95:
    print("獎金1000元")
elif 80 <= score < 90:
    print("獎金500元")
else:
    print("無獎金")

2. BMI計算

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. 簡單計算機

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 等價。
範例：

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. 範例：

print(0.1 + 0.2)  # 結果：0.30000000000000004

# 格式化輸出
## 使用 % 運算符
1. 格式符：
1. %d: 以十進位整數輸出。
2. %f: 以浮點數輸出。
3. %s: 將變數轉換為字串輸出。
4. %x: 十六進位輸出。
5. 修飾符：
1. %-: 靠左對齊。
2. %0: 補零。
3. %n.mf: 控制總寬度和小數位數。
2. 範例：

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. 範例：

name = "帳單之門"
age = 99
gender = "male"
print("姓名: {0}".format(name))
print("年齡: {0}".format(age))
print("性別: {0}".format(gender))

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

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

範例程式碼：

# 輸入浮點數
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 模組來解析並格式化日期。
範例程式碼：

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() 可以讓數字對齊。

範例程式碼：

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 來對齊輸出的文本。
可以使用 <（左對齊）和 >（右對齊）來控制對齊方式。
範例程式碼：

# 輸入姓名和年齡
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 位。
範例程式碼：

# 輸入數字
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位

範例程式碼:

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

解釋:

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

2. 索引與切片：
1. 使用索引訪問字串的特定位置。
2. 切片語法：str[start:end:step]。
3. 範例：

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. 範例：

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. 範例：

x = "123"
print(int(x))  # 結果：123
print(float(x))  # 結果：123.0
print(str(123))  # 結果："123"

### 練習題
1. 兩數相加：

a, b = 5.10, 2.30
print(f"{a:.2f} + {b:.2f} = {a + b:.2f}")  # 結果：5.10 + 2.30 = 7.40

2. 九九乘法表：

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. 語法:

def 函式名稱():
    執行敘述

範例:

def say_hello():
    print("Hello, Python!")

# 呼叫函式
say_hello()

輸出：Hello, Python!

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

2. 語法:

def 函式名稱(參數1, 參數2):
    執行敘述

範例:

def greet(name, age):
    print(f"你好, {name}! 你今年 {age} 歲。")

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

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

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

2. 語法:

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

範例:

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

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

# 呼叫函式（覆寫預設值）
greet("小華", 25)

輸出：

你好, 小明! 你今年 20 歲。
你好, 小華! 你今年 25 歲。

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

2. 語法:

def 函式名稱(參數):
    執行敘述
    return 回傳值

範例:次方函式

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. 範例:

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. 元組的修改操作
雖然元組本身不可變，但可以通過建立新的元組來進行“修改”操作。可以將兩個元組進行連接，得到一個新的元組：

tuple1 = (1, 2, 3)
tuple2 = (4, 5)
tuple1 = tuple1 + tuple2  # 這會創建一個新的元組

注意：
1. 元組的元素是不可變的，但元組本身的參考（變數）是可以重新指派的。
2. 元組的元素如果是單一的數字（例如 (6)），則這樣其實不是元組，而是一個數字。如果要讓它成為元組，需要在數字後加上逗號（例如 (6,)）。

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

### 範例：
1.

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. 輸出該元組的長度、最大值、最小值及總和。

程式碼實現：

# 建立空的串列
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()：回傳一份淺拷貝。

# 建立與基本操作
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 實現倒序與回復。

folder = []
for i in range(5, 0, -1):
    folder.append(i)
for _ in range(len(folder)):
    print(folder.pop())

結果:

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. 撲克牌總和

# 建立牌面與點數對應表
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. 奇數索引數值加總

# 輸入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. 成績列印

# 輸入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. 出現最多次的數字

# 輸入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. 數字排序

# 輸入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. 大樂透隨機號碼產生程式

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. 猜數字遊戲

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點)

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. 範例:

A = {"California", "New York"}
B = {"New York", "Phoenix", "Chicago"}
print(A & B)  # {'New York'}

2. 聯集 (OR):找出兩集合中所有元素（不重複）。
1. 方法: A | B 或 A.union(B)
2. 範例

print(A | B)  # {'California', 'New York', 'Phoenix', 'Chicago'}

3. 差集 (Differenˊce):找出在集合 A 中但不在集合 B 中的元素。
1. 方法: A - B 或 A.difference(B)
2. 範例:

print(A - B)  # {'California'}

3. 對稱差集 (XOR):找出兩集合中不重複的元素（僅屬於其中一個集合）。
1. 方法: A ^ B 或 A.symmetric_difference(B)
2. 範例:

print(A ^ B)  # {'California', 'Phoenix', 'Chicago'}

## 實作範例
1：水果集合操作
題目需求:
itemsA 加入任意兩樣水果，刪除一樣與「蘋果」。
itemsB 加入任意兩樣水果，刪除一樣與「蓮霧」。
計算以下集合操作：
所有的水果且不重複
兩者皆有的水果
itemsA 獨有的水果
itemsB 獨有的水果
兩者不重複的水果

# 初始集合
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：學生名單操作
題目需求:
數學及格但英文不及格的同學。
數學不及格但英文及格的同學。
兩者皆及格的同學。

# 初始集合
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))