Python 第二課：迴圈與列表

# 印出「你好」5次
for i in range(5):
    print("你好，這是第", i+1, "次！")

# 印出 1 到 5
for num in range(1, 6):
    print(num)

# range(stop): 從 0 開始，到 stop-1 結束
for i in range(5):
    print(i)  # 輸出: 0, 1, 2, 3, 4

# range(start, stop): 從 start 開始，到 stop-1 結束
for i in range(2, 8):
    print(i)  # 輸出: 2, 3, 4, 5, 6, 7

# range(start, stop, step): 從 start 開始，到 stop-1 結束，每次增加 step
for i in range(1, 10, 2):
    print(i)  # 輸出: 1, 3, 5, 7, 9

# 倒序的 range
for i in range(10, 0, -1):
    print(i)  # 輸出: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

# 遍歷字串中的每個字符
for char in "Python":
    print(char)  # 輸出: P, y, t, h, o, n

# 遍歷列表中的每個元素
for fruit in ["蘋果", "香蕉", "橙"]:
    print("我喜歡吃", fruit)

# 遍歷字典中的每個鍵
student = {"name": "小明", "age": 15, "grade": "高一"}
for key in student:
    print(key, ":", student[key])

# 使用 enumerate() 同時獲取索引和元素
fruits = ["蘋果", "香蕉", "橙"]
for index, fruit in enumerate(fruits):
    print(f"索引 {index}: {fruit}")

count = 0
while count < 5:
    print("While 迴圈執行中，count =", count)
    count = count + 1  # 或 count += 1
print("While 迴圈結束！")

# 猜數字遊戲
import random
secret_number = random.randint(1, 10)  # 生成 1-10 之間的隨機數
guess = 0
attempts = 0

while guess != secret_number:
    guess = int(input("猜一個 1 到 10 之間的數字: "))
    attempts += 1
    
    if guess < secret_number:
        print("太小了！再猜一次。")
    elif guess > secret_number:
        print("太大了！再猜一次。")

print(f"恭喜你，猜對了！答案是 {secret_number}。")
print(f"你總共猜了 {attempts} 次。")

# 等待用戶輸入 'q' 來退出
user_input = ""
while user_input != "q":
    user_input = input("輸入 'q' 退出，或輸入任何其他內容繼續: ")
    if user_input != "q":
        print("繼續執行...")
print("程式已退出。")

# 無限迴圈示例 (小心運行！)
# while True:
#     print("這是一個無限迴圈！")
    
# 一個安全的無限迴圈，使用 break 來退出
counter = 0
while True:
    print("迴圈執行中...")
    counter += 1
    if counter >= 5:
        print("達到 5 次，退出迴圈！")
        break

# break 例子
for i in range(1, 11):
    if i == 5:
        print("去到5，我要用 break 跳出迴圈了！")
        break
    print("i 的值是:", i)
print("迴圈已結束 (因為 break)")

# continue 例子
for i in range(1, 6):
    if i == 3:
        print("遇到3，用 continue 跳過這次迭代！")
        continue
    print("處理數字:", i)
print("迴圈結束")

# for 迴圈搭配 else
for i in range(1, 6):
    print(i)
else:
    print("for 迴圈正常完成！")

# 當 break 退出迴圈時，else 不會執行
for i in range(1, 6):
    print(i)
    if i == 3:
        break
else:
    print("這條消息不會顯示，因為迴圈被 break 中斷了。")

# while 迴圈也可以使用 else
count = 0
while count < 5:
    print(count)
    count += 1
else:
    print("while 迴圈正常完成！")

# 在列表中搜尋特定值
numbers = [4, 2, 7, 1, 9, 5]
search_value = 7

for num in numbers:
    if num == search_value:
        print(f"找到了 {search_value}！")
        break
else:
    print(f"{search_value} 不在列表中。")

# 尋找列表中的最大值和最小值
numbers = [4, 2, 7, 1, 9, 5]
max_value = numbers[0]  # 假設第一個元素是最大值
min_value = numbers[0]  # 假設第一個元素是最小值

for num in numbers[1:]:  # 從第二個元素開始比較
    if num > max_value:
        max_value = num
    if num < min_value:
        min_value = num

print(f"最大值：{max_value}，最小值：{min_value}")

# 使用方括號創建列表
fruits = ["蘋果", "香蕉", "橙"]
numbers = [1, 2, 3, 4, 5]
mixed_list = ["你好", 100, 3.14, True]  # 可以混合不同類型
empty_list = []  # 空列表

# 使用 list() 函數創建列表
chars = list("Python")  # 從字串創建：['P', 'y', 't', 'h', 'o', 'n']
numbers_range = list(range(1, 6))  # 從 range 創建：[1, 2, 3, 4, 5]

# 索引從 0 開始
fruits = ["蘋果", "香蕉", "橙", "西瓜", "芒果"]
#          0       1      2     3      4

# 正向索引
print(fruits[0])  # 第一個元素：蘋果
print(fruits[2])  # 第三個元素：橙

# 負向索引（從末尾開始計數）
print(fruits[-1])  # 最後一個元素：芒果
print(fruits[-3])  # 倒數第三個元素：橙

# 切片：[開始索引:結束索引:步長]
print(fruits[1:4])    # 從索引 1 到 3：['香蕉', '橙', '西瓜']
print(fruits[:3])     # 從開頭到索引 2：['蘋果', '香蕉', '橙']
print(fruits[2:])     # 從索引 2 到結尾：['橙', '西瓜', '芒果']
print(fruits[::2])    # 從開頭到結尾，步長為 2：['蘋果', '橙', '芒果']
print(fruits[::-1])   # 反轉列表：['芒果', '西瓜', '橙', '香蕉', '蘋果']

# 1. 修改元素
fruits = ["蘋果", "香蕉", "橙"]
fruits[1] = "葡萄"
print(fruits)  # ['蘋果', '葡萄', '橙']

# 2. 添加元素
fruits.append("芒果")  # 在尾部添加元素
print(fruits)  # ['蘋果', '葡萄', '橙', '芒果']

fruits.insert(1, "草莓")  # 在指定位置插入元素
print(fruits)  # ['蘋果', '草莓', '葡萄', '橙', '芒果']

fruits.extend(["西瓜", "藍莓"])  # 添加多個元素（合併列表）
print(fruits)  # ['蘋果', '草莓', '葡萄', '橙', '芒果', '西瓜', '藍莓']

# 3. 刪除元素
fruits.remove("葡萄")  # 刪除第一個值為 "葡萄" 的元素
print(fruits)  # ['蘋果', '草莓', '橙', '芒果', '西瓜', '藍莓']

popped_fruit = fruits.pop()  # 移除並返回最後一個元素
print(popped_fruit)  # 藍莓
print(fruits)  # ['蘋果', '草莓', '橙', '芒果', '西瓜']

popped_at_index = fruits.pop(1)  # 移除並返回指定索引的元素
print(popped_at_index)  # 草莓
print(fruits)  # ['蘋果', '橙', '芒果', '西瓜']

del fruits[0]  # 使用 del 語句刪除元素
print(fruits)  # ['橙', '芒果', '西瓜']

# 4. 獲取列表長度
print(len(fruits))  # 3

# 5. 檢查元素是否存在
print("芒果" in fruits)  # True
print("蘋果" in fruits)  # False

# 1. 排序
numbers = [3, 1, 4, 1, 5, 9, 2]
numbers.sort()  # 原地排序（修改原列表）
print(numbers)  # [1, 1, 2, 3, 4, 5, 9]

fruits = ["橙", "蘋果", "香蕉"]
sorted_fruits = sorted(fruits)  # 返回排序後的新列表，不修改原列表
print(sorted_fruits)  # ['橙', '蘋果', '香蕉']
print(fruits)  # ['橙', '蘋果', '香蕉']

# 降序排序
numbers.sort(reverse=True)
print(numbers)  # [9, 5, 4, 3, 2, 1, 1]

# 2. 反轉
fruits.reverse()  # 原地反轉
print(fruits)  # ['香蕉', '蘋果', '橙']

# 3. 計數
numbers = [1, 2, 3, 1, 4, 1, 5]
print(numbers.count(1))  # 3 (1 出現了 3 次)

# 4. 查找索引
print(numbers.index(4))  # 4 (4 的索引是 4)
# print(numbers.index(6))  # 值不存在會引發 ValueError

# 5. 清空列表
numbers.clear()
print(numbers)  # []

# 6. 複製列表
fruits = ["蘋果", "香蕉", "橙"]
fruits_copy1 = fruits.copy()  # 方法 1：使用 copy() 方法
fruits_copy2 = list(fruits)   # 方法 2：使用 list() 函數
fruits_copy3 = fruits[:]      # 方法 3：使用切片

# 注意：這些都是淺複製 (shallow copy)

# 二維列表（列表的列表）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 訪問元素
print(matrix[0][0])  # 1 (第一行第一列)
print(matrix[1][2])  # 6 (第二行第三列)

# 修改元素
matrix[2][0] = 10
print(matrix)  # [[1, 2, 3], [4, 5, 6], [10, 8, 9]]

# 遍歷二維列表
for row in matrix:
    for element in row:
        print(element, end=" ")
    print()  # 換行

# 遍歷列表中的每個元素
fruits = ["蘋果", "香蕉", "橙", "葡萄"]
for fruit in fruits:
    print("我喜歡吃", fruit)

# 同時獲取索引和元素
for index, fruit in enumerate(fruits):
    print(f"第 {index+1} 個水果是 {fruit}")

# 平方數列表生成
numbers = [1, 2, 3, 4, 5]
squared = []
for num in numbers:
    squared.append(num ** 2)
print(squared)  # [1, 4, 9, 16, 25]

# 篩選偶數
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = []
for num in numbers:
    if num % 2 == 0:
        evens.append(num)
print(evens)  # [2, 4, 6, 8, 10]

# 1. 合併列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(combined)  # [1, 2, 3, 4, 5, 6]

# 2. 重複列表
repeated = [0] * 5
print(repeated)  # [0, 0, 0, 0, 0]

# 3. 將字串轉換為字符列表，再轉回字串
message = "Python"
chars = list(message)
print(chars)  # ['P', 'y', 't', 'h', 'o', 'n']
chars[0] = 'J'
new_message = ''.join(chars)
print(new_message)  # 'Jython'

# 4. 使用 min(), max(), sum() 函數
numbers = [4, 2, 8, 6, 10]
print(min(numbers))  # 2
print(max(numbers))  # 10
print(sum(numbers))  # 30

# 5. 查找共同元素
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common = []
for item in list1:
    if item in list2:
        common.append(item)
print(common)  # [4, 5]

# 基本語法
# [表達式 for 變數 in 可迭代對象]

# 範例：生成 1 到 10 的平方列表
squares = [x**2 for x in range(1, 11)]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 基本語法
# [表達式 for 變數 in 可迭代對象 if 條件]

# 範例：過濾出偶數並求其平方
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares)  # [4, 16, 36, 64, 100]

# 範例：過濾長度大於 3 的單詞
words = ["hello", "world", "python", "programming", "ai", "ml"]
long_words = [word for word in words if len(word) > 3]
print(long_words)  # ['hello', 'world', 'python', 'programming']

# 基本語法
# [表達式 for 變數1 in 可迭代對象1 for 變數2 in 可迭代對象2]

# 範例：生成所有可能的坐標對
coordinates = [(x, y) for x in range(1, 4) for y in range(1, 3)]
print(coordinates)  # [(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)]

# 創建二維矩陣
matrix = [[i + j for j in range(3)] for i in range(0, 9, 3)]
print(matrix)  # [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

# 基本語法
# [表達式1 if 條件 else 表達式2 for 變數 in 可迭代對象]

# 範例：判斷數字奇偶性
numbers = [1, 2, 3, 4, 5]
parity = ["偶數" if x % 2 == 0 else "奇數" for x in numbers]
print(parity)  # ['奇數', '偶數', '奇數', '偶數', '奇數']

# 根據長度對字符串進行描述
words = ["python", "ai", "programming", "ml"]
descriptions = [word if len(word) < 3 else word[:3] + "..." for word in words]
print(descriptions)  # ['pyt...', 'ai', 'pro...', 'ml']

# 傳統方式：使用 for 循環
squares_traditional = []
for x in range(1, 11):
    squares_traditional.append(x**2)
print(squares_traditional)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 列表生成式：簡潔優雅
squares_comprehension = [x**2 for x in range(1, 11)]
print(squares_comprehension)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 比較兩個結果
print(squares_traditional == squares_comprehension)  # True

# 測試執行時間（在實際環境中運行會更明顯）
import time

# 使用傳統方式
start = time.time()
result1 = []
for i in range(1000000):
    result1.append(i * i)
end = time.time()
print(f"傳統方式耗時：{end - start:.6f} 秒")

# 使用列表生成式
start = time.time()
result2 = [i * i for i in range(1000000)]
end = time.time()
print(f"列表生成式耗時：{end - start:.6f} 秒")

# 1. 數據轉換
celsius = [0, 10, 20, 30, 40]
fahrenheit = [(9/5) * temp + 32 for temp in celsius]
print(fahrenheit)  # [32.0, 50.0, 68.0, 86.0, 104.0]

# 2. 數據篩選
scores = [65, 72, 88, 92, 45, 78]
passed = [score for score in scores if score >= 60]
print(passed)  # [65, 72, 88, 92, 78]

# 3. 提取數據
people = [("Alice", 25), ("Bob", 30), ("Charlie", 35), ("David", 40)]
names = [person[0] for person in people]
print(names)  # ['Alice', 'Bob', 'Charlie', 'David']
ages = [person[1] for person in people]
print(ages)  # [25, 30, 35, 40]

# 使用小括號創建元組
coordinates = (10, 20)
rgb_color = (255, 0, 128)

# 不使用小括號也可以創建元組
person = "Alice", 30, "Engineer"
print(person)  # ('Alice', 30, 'Engineer')

# 創建只有一個元素的元組（需要逗號）
singleton = (42,)  # 注意這個逗號
print(type(singleton))  # 

# 不是元組，而是一個整數
not_tuple = (42)
print(type(not_tuple))  # 

# 使用 tuple() 函數將其他序列轉換為元組
tuple_from_list = tuple([1, 2, 3])
tuple_from_string = tuple("Python")
print(tuple_from_list)  # (1, 2, 3)
print(tuple_from_string)  # ('P', 'y', 't', 'h', 'o', 'n')

# 創建空元組
empty_tuple = ()
print(empty_tuple)  # ()

# 使用索引訪問元素
coordinates = (10, 20, 30)
print(coordinates[0])  # 10
print(coordinates[2])  # 30
print(coordinates[-1])  # 30

# 使用切片獲取部分元素
numbers = (0, 1, 2, 3, 4, 5)
print(numbers[1:4])  # (1, 2, 3)
print(numbers[:3])   # (0, 1, 2)
print(numbers[3:])   # (3, 4, 5)
print(numbers[::2])  # (0, 2, 4)

# 1. 元組是不可變的
coordinates = (10, 20, 30)
# coordinates[0] = 100  # 這會引發 TypeError

# 2. 但如果元組的元素是可變對象，那麼該元素的內容可以改變
mutable_in_tuple = ([1, 2], [3, 4])
mutable_in_tuple[0].append(5)
print(mutable_in_tuple)  # ([1, 2, 5], [3, 4])

# 3. 元組支持的操作
# 獲取長度
print(len(coordinates))  # 3

# 元素存在性檢查
print(10 in coordinates)  # True
print(100 in coordinates)  # False

# 連接元組
tuple1 = (1, 2)
tuple2 = (3, 4)
combined = tuple1 + tuple2
print(combined)  # (1, 2, 3, 4)

# 重複元組
repeated = tuple1 * 3
print(repeated)  # (1, 2, 1, 2, 1, 2)

# 基本的元組解包
coordinates = (10, 20, 30)
x, y, z = coordinates
print(x)  # 10
print(y)  # 20
print(z)  # 30

# 交換變數值
a, b = 5, 10
a, b = b, a  # 使用元組解包交換值
print(a, b)  # 10 5

# 忽略某些值（使用下劃線）
person = ("Alice", 30, "Engineer", "New York")
name, age, _, city = person
print(name, age, city)  # Alice 30 New York

# 使用星號獲取剩餘元素
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(first)   # 1
print(middle)  # [2, 3, 4]
print(last)    # 5

# 在函數返回值中使用元組
def get_user_info():
    return "Alice", 30, "alice@example.com"

name, age, email = get_user_info()
print(f"姓名：{name}, 年齡：{age}, 電子郵件：{email}")

# 導入 namedtuple
from collections import namedtuple

# 定義一個命名元組類型
Point = namedtuple('Point', ['x', 'y', 'z'])

# 創建命名元組實例
p = Point(1, 2, 3)

# 通過名稱或索引訪問元素
print(p.x)      # 1 (通過名稱)
print(p[0])     # 1 (通過索引)
print(p)        # Point(x=1, y=2, z=3)

# 命名元組是不可變的
# p.x = 10  # 這會引發 AttributeError

# 使用命名元組使代碼更具可讀性
Person = namedtuple('Person', 'name age job')
p1 = Person("Alice", 30, "Engineer")
p2 = Person("Bob", 25, "Designer")

print(f"{p1.name} 的職業是 {p1.job}")  # Alice 的職業是 Engineer
print(f"{p2.name} 的年齡是 {p2.age}")  # Bob 的年齡是 25

# 使用大括號創建字典
student = {"name": "小明", "age": 15, "grade": "高一"}

# 使用 dict() 函數創建字典
person = dict(name="Alice", age=30, job="Engineer")

# 使用 zip() 函數將兩個列表組合成字典
keys = ["a", "b", "c"]
values = [1, 2, 3]
letter_dict = dict(zip(keys, values))
print(letter_dict)  # {'a': 1, 'b': 2, 'c': 3}

# 使用字典推導式創建字典
squares = {x: x**2 for x in range(1, 6)}
print(squares)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 創建空字典
empty_dict = {}
empty_dict2 = dict()

# 訪問字典中的值
student = {"name": "小明", "age": 15, "grade": "高一"}

# 使用鍵訪問值
print(student["name"])  # 小明
print(student["age"])   # 15

# 使用 get() 方法（更安全，鍵不存在時不會引發錯誤）
print(student.get("grade"))      # 高一
print(student.get("address"))    # None（鍵不存在，返回 None）
print(student.get("address", "未提供"))  # 未提供（自定義默認值）

# 修改值
student["age"] = 16
print(student)  # {'name': '小明', 'age': 16, 'grade': '高一'}

# 添加新的鍵值對
student["school"] = "明德中學"
print(student)  # {'name': '小明', 'age': 16, 'grade': '高一', 'school': '明德中學'}

# 刪除鍵值對
del student["grade"]
print(student)  # {'name': '小明', 'age': 16, 'school': '明德中學'}

# 使用 pop() 方法移除並返回值
school = student.pop("school")
print(school)   # 明德中學
print(student)  # {'name': '小明', 'age': 16}

# 取得字典的鍵、值和鍵值對
student = {"name": "小明", "age": 15, "grade": "高一"}

# keys() 方法：返回所有鍵
keys = student.keys()
print(keys)  # dict_keys(['name', 'age', 'grade'])

# values() 方法：返回所有值
values = student.values()
print(values)  # dict_values(['小明', 15, '高一'])

# items() 方法：返回所有鍵值對
items = student.items()
print(items)  # dict_items([('name', '小明'), ('age', 15), ('grade', '高一')])

# 更新字典
student.update({"age": 16, "address": "台北市"})
print(student)  # {'name': '小明', 'age': 16, 'grade': '高一', 'address': '台北市'}

# 檢查鍵是否存在
print("name" in student)   # True
print("phone" in student)  # False

# 清空字典
student.clear()
print(student)  # {}

# 準備一個示例字典
scores = {"數學": 90, "英文": 85, "科學": 95}

# 遍歷鍵
for subject in scores:
    print(subject)
# 輸出:
# 數學
# 英文
# 科學

# 遍歷值
for score in scores.values():
    print(score)
# 輸出:
# 90
# 85
# 95

# 同時遍歷鍵和值
for subject, score in scores.items():
    print(f"{subject}: {score}")
# 輸出:
# 數學: 90
# 英文: 85
# 科學: 95

# 字典中的值可以是另一個字典
students = {
    "小明": {
        "age": 15,
        "grade": "高一",
        "scores": {"數學": 90, "英文": 85}
    },
    "小華": {
        "age": 16,
        "grade": "高二",
        "scores": {"數學": 80, "英文": 95}
    }
}

# 訪問巢狀字典
print(students["小明"]["age"])          # 15
print(students["小華"]["scores"]["英文"])  # 95

# 修改巢狀字典
students["小明"]["scores"]["數學"] = 95
print(students["小明"]["scores"])  # {'數學': 95, '英文': 85}

# 遍歷巢狀字典
for name, info in students.items():
    print(f"{name}:")
    print(f"  年齡: {info['age']}")
    print(f"  年級: {info['grade']}")
    print("  成績:")
    for subject, score in info['scores'].items():
        print(f"    {subject}: {score}")

# 計數應用：統計字符出現次數
text = "hello world"
char_count = {}

for char in text:
    if char in char_count:
        char_count[char] += 1
    else:
        char_count[char] = 1
        
print(char_count)  # {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

# 使用 get() 方法簡化計數
char_count = {}
for char in text:
    char_count[char] = char_count.get(char, 0) + 1
    
print(char_count)  # {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

# 以字典作為數據庫
products = {
    "A001": {"name": "蘋果手機", "price": 35000, "stock": 10},
    "A002": {"name": "筆記型電腦", "price": 32000, "stock": 5},
    "A003": {"name": "無線耳機", "price": 5000, "stock": 20}
}

# 查詢產品
product_id = "A002"
if product_id in products:
    product = products[product_id]
    print(f"產品名稱: {product['name']}")
    print(f"價格: ${product['price']}")
    print(f"庫存: {product['stock']} 件")

# 定義一個打招呼的函式
def say_hello():
    print("你好呀！")
    print("歡迎來到Python的世界！")
    print("希望你學得開心！")

# 呼叫函式
say_hello()

print("--- 我是分隔線 ---")

# 可以重複呼叫
say_hello()

# 定義帶參數的函式
def greet(name):
    print(f"你好，{name}！")

# 呼叫帶參數的函式
greet("小明")  # 輸出: 你好，小明！
greet("小華")  # 輸出: 你好，小華！

# 多個參數的函式
def describe_person(name, age, job):
    print(f"{name} 是一位 {age} 歲的 {job}。")

# 呼叫多參數函式
describe_person("張三", 30, "工程師")  # 輸出: 張三 是一位 30 歲的 工程師。

# 關鍵字參數（順序可變）
describe_person(age=25, job="設計師", name="李四")  # 輸出: 李四 是一位 25 歲的 設計師。

# 定義帶默認參數的函式
def greet_with_language(name, language="中文"):
    if language == "中文":
        print(f"你好，{name}！")
    elif language == "英文":
        print(f"Hello, {name}!")
    else:
        print(f"不支持的語言: {language}")

# 使用默認參數
greet_with_language("小明")  # 輸出: 你好，小明！

# 覆蓋默認參數
greet_with_language("Bob", "英文")  # 輸出: Hello, Bob!

# 支持多個默認參數
def calculate_price(price, tax=0.05, discount=0):
    final_price = price * (1 + tax) * (1 - discount)
    return final_price

# 不指定則使用默認值
print(calculate_price(100))  # 輸出: 105.0

# 可選擇性覆蓋部分或全部默認參數
print(calculate_price(100, 0.1))  # 輸出: 110.0 (修改稅率)
print(calculate_price(100, discount=0.2))  # 輸出: 84.0 (使用默認稅率，修改折扣)
print(calculate_price(100, 0.08, 0.15))  # 輸出: 91.8 (修改稅率和折扣)

# 定義返回值的函式
def square(number):
    return number * number

# 使用返回值
result = square(5)
print(result)  # 輸出: 25
print(square(3) + square(4))  # 輸出: 25 (9 + 16)

# 返回多個值
def get_person_info():
    name = "小明"
    age = 15
    job = "學生"
    return name, age, job

# 接收多個返回值
info = get_person_info()
print(info)  # 輸出: ('小明', 15, '學生') (返回為元組)

# 使用元組解包接收多個返回值
name, age, job = get_person_info()
print(f"姓名: {name}, 年齡: {age}, 職業: {job}")  # 輸出: 姓名: 小明, 年齡: 15, 職業: 學生

# 提前返回
def is_adult(age):
    if age < 18:
        return False
    return True

print(is_adult(15))  # 輸出: False
print(is_adult(20))  # 輸出: True

# 全局變量
global_var = "我是全局變量"

def test_scope():
    # 局部變量
    local_var = "我是局部變量"
    print(global_var)  # 可以訪問全局變量
    print(local_var)   # 可以訪問局部變量

test_scope()
print(global_var)  # 可以訪問全局變量
# print(local_var)  # 錯誤！不能在函式外訪問局部變量

# 修改全局變量
def modify_global():
    global global_var  # 聲明要修改全局變量
    global_var = "全局變量被修改了"

modify_global()
print(global_var)  # 輸出: 全局變量被修改了

# *args: 接收任意數量的位置參數
def sum_all(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total

print(sum_all(1, 2))          # 輸出: 3
print(sum_all(1, 2, 3, 4, 5))  # 輸出: 15

# **kwargs: 接收任意數量的關鍵字參數
def print_person_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

print_person_info(name="小明", age=15, job="學生")
# 輸出:
# name: 小明
# age: 15
# job: 學生

# 結合位置參數、*args 和 **kwargs
def complex_function(a, b, *args, **kwargs):
    print(f"a = {a}")
    print(f"b = {b}")
    print(f"args = {args}")
    print(f"kwargs = {kwargs}")

complex_function(1, 2, 3, 4, 5, x=10, y=20, z=30)
# 輸出:
# a = 1
# b = 2
# args = (3, 4, 5)
# kwargs = {'x': 10, 'y': 20, 'z': 30}

# 階乘計算的遞迴實現
def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 輸出: 120 (5 * 4 * 3 * 2 * 1)

# 斐波那契數列的遞迴實現
def fibonacci(n):
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

for i in range(10):
    print(fibonacci(i), end=" ")  # 輸出: 0 1 1 2 3 5 8 13 21 34

# 定義 lambda 表達式
square = lambda x: x * x
print(square(5))  # 輸出: 25

# 在調用時直接定義和使用
print((lambda x: x * x)(5))  # 輸出: 25

# 多參數 lambda 表達式
sum_lambda = lambda x, y: x + y
print(sum_lambda(3, 4))  # 輸出: 7

# 在函式中使用 lambda
def get_sorting_key(sort_by):
    if sort_by == "name":
        return lambda person: person["name"]
    elif sort_by == "age":
        return lambda person: person["age"]
    else:
        return lambda person: 0

# 使用 lambda 進行排序
people = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 20},
    {"name": "Charlie", "age": 30}
]

# 按姓名排序
people.sort(key=get_sorting_key("name"))
print([person["name"] for person in people])  # 輸出: ['Alice', 'Bob', 'Charlie']

# 按年齡排序
people.sort(key=get_sorting_key("age"))
print([person["name"] for person in people])  # 輸出: ['Bob', 'Alice', 'Charlie']