# 新手魔法師的第一個咒語
def say_hello(name):
    return f"? 魔法的問候：{name}！"
# 施展魔法！
result = say_hello("Python學徒")  # 看，函數(shù)調(diào)用了！
print(result)  # 輸出：? 魔法的問候：Python學徒！

import traceback
def explore_stack():
    """探索當前調(diào)用棧的冒險家"""
    print("?? 當前調(diào)用棧深度：", len(traceback.extract_stack()))
    for frame_info in traceback.extract_stack()[:-1]:
        print(f"  在 {frame_info.filename} 的第 {frame_info.lineno} 行：{frame_info.name}()")
def deep_magic(level):
    """遞歸的深淵"""
    if level <= 0:
        explore_stack()  # 看看我們有多深！
        return "觸底反彈"
    return deep_magic(level - 1)  # 繼續(xù)下潛！
deep_magic(3)
# 輸出：
# ?? 當前調(diào)用棧深度：5
#   在 test.py 的第 20 行：<module>()
#   在 test.py 的第 16 行：deep_magic()
#   在 test.py 的第 16 行：deep_magic()
#   在 test.py 的第 16 行：deep_magic()

def make_potion(ingredient1, ingredient2, ingredient3):
    return f"?? 魔藥配方：{ingredient1} + {ingredient2} + {ingredient3}"
# 標準調(diào)用方式
print(make_potion("龍鱗", "鳳凰淚", "獨角獸毛"))

# 明確指定參數(shù)名，順序不重要！
print(make_potion(
    ingredient3="獨角獸毛",
    ingredient1="龍鱗", 
    ingredient2="鳳凰淚"
))

def enchant_item(item, magic_level=5, spell="Lumos"):
    """給物品附魔"""
    return f"? {item} 被施放了 {spell}（魔力等級：{magic_level}）"
print(enchant_item("魔杖"))  # 使用默認值
print(enchant_item("寶劍", magic_level=8, spell="Incendio"))  # 覆蓋默認值

def problematic_spellbook(spells=[]):  # 危險！所有巫師共享同一個列表！
    spells.append("Expelliarmus")
    return spells
book1 = problematic_spellbook()
book2 = problematic_spellbook()
print(book2)  # 輸出：['Expelliarmus', 'Expelliarmus'] 啊哦！
# 正確做法：
def safe_spellbook(spells=None):
    if spells is None:
        spells = []  # 每次都是新列表！
    spells.append("Expelliarmus")
    return spells

# *args：接收任意數(shù)量的位置參數(shù)（變成元組）
def summon_creatures(*creatures):
    return f"召喚：{', '.join(creatures)}！"
print(summon_creatures("龍", "鳳凰", "獅鷲", "獨角獸"))
# **kwargs：接收任意數(shù)量的關(guān)鍵字參數(shù)（變成字典）
def create_potion(**ingredients):
    recipe = " + ".join(f"{k}({v}克)" for k, v in ingredients.items())
    return f"魔藥配方：{recipe}"
print(create_potion(龍鱗=10, 鳳凰淚=5, 月光草=3))
# 拆包魔法：把列表/字典變成參數(shù)
creatures_list = ["龍", "鳳凰", "獅鷲"]
print(summon_creatures(*creatures_list))  # 相當于 summon_creatures("龍", "鳳凰", "獅鷲")
ingredients_dict = {"龍鱗": 10, "鳳凰淚": 5}
print(create_potion(**ingredients_dict))

def shout(text):
    return text.upper() + "!"
def whisper(text):
    return text.lower() + "..."
def greet(name, formatter):
    """formatter 是一個函數(shù)！"""
    return formatter(f"Hello, {name}")
print(greet("Alice", shout))   # 輸出：HELLO, ALICE!
print(greet("Bob", whisper))   # 輸出：hello, bob...

def make_multiplier(factor):
    """工廠函數(shù)：生產(chǎn)乘法器"""
    def multiplier(x):
        return x * factor
    return multiplier
double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))  # 輸出：10
print(triple(5))  # 輸出：15
# 看看閉包的神奇屬性
print(double.__closure__[0].cell_contents)  # 輸出：2（還記得因子2?。?/pre>

import time
def timer_decorator(func):
    """給函數(shù)添加計時功能的裝飾器"""
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)  # 調(diào)用原始函數(shù)
        end_time = time.time()
        print(f"??  {func.__name__} 執(zhí)行時間：{end_time - start_time:.4f}秒")
        return result
    return wrapper
@timer_decorator  # 這就是裝飾器語法糖！
def heavy_calculation(n):
    """一個耗時的計算"""
    return sum(i ** 2 for i in range(n))
print(heavy_calculation(1000000))
# 輸出：
# ??  heavy_calculation 執(zhí)行時間：0.0452秒
# 333332833333500000（計算結(jié)果）

def magic_sequence(limit):
    """生成器函數(shù)：按需生成值"""
    print("?? 生成器開始工作...")
    n = 0
    while n < limit:
        yield n ** 2  # 不是return！是yield！
        n += 1
    print("? 生成器工作完成")
# 使用生成器
squares = magic_sequence(5)
print(next(squares))  # 輸出：?? 生成器開始工作... 然后 0
print(next(squares))  # 輸出：1
print(next(squares))  # 輸出：4
# 或者用for循環(huán)
for square in magic_sequence(3):
    print(f"得到：{square}")
# 輸出：
# ?? 生成器開始工作...
# 得到：0
# 得到：1
# 得到：4
# ? 生成器工作完成

def running_average():
    """協(xié)程：維護運行平均值"""
    total = 0
    count = 0
    average = 0
    while True:
        value = yield average  # 接收值，返回平均值
        total += value
        count += 1
        average = total / count
# 使用協(xié)程
avg_coroutine = running_average()
next(avg_coroutine)  # 啟動協(xié)程（prime the coroutine）
print(avg_coroutine.send(10))  # 輸出：10.0
print(avg_coroutine.send(20))  # 輸出：15.0
print(avg_coroutine.send(30))  # 輸出：20.0

class Spell:
    """一個可調(diào)用的咒語類"""
    def __init__(self, incantation):
        self.incantation = incantation
    def __call__(self, target):
        return f"?? {self.incantation}！{target}被施法了！"
# 創(chuàng)建咒語對象
expelliarmus = Spell("除你武器")
lumos = Spell("熒光閃爍")
# 像調(diào)用函數(shù)一樣調(diào)用對象！
print(expelliarmus("馬爾福的魔杖"))  # 輸出：?? 除你武器！馬爾福的魔杖被施法了！
print(lumos("黑暗的走廊"))           # 輸出：?? 熒光閃爍！黑暗的走廊被施法了！

def mysterious_function(x, y=10, *args, **kwargs):
    """一個神秘的函數(shù)"""
    return x + y + sum(args) + sum(kwargs.values())
# 看看這個函數(shù)的所有信息！
print("函數(shù)名：", mysterious_function.__name__)
print("文檔字符串：", mysterious_function.__doc__)
print("參數(shù)信息：", mysterious_function.__code__.co_varnames)
print("參數(shù)個數(shù)：", mysterious_function.__code__.co_argcount)
print("默認值：", mysterious_function.__defaults__)
# 輸出：
# 函數(shù)名： mysterious_function
# 文檔字符串： 一個神秘的函數(shù)
# 參數(shù)信息： ('x', 'y', 'args', 'kwargs')
# 參數(shù)個數(shù)： 2
# 默認值： (10,)

# 避免在循環(huán)中重復計算
def process_items(items):
    """優(yōu)化前：每次循環(huán)都計算長度"""
    for i in range(len(items)):  # len()在每次迭代都被調(diào)用
        process(items[i])
    """優(yōu)化后：預(yù)先計算長度"""
    n = len(items)  # 只計算一次
    for i in range(n):
        process(items[i])
# 使用局部變量加速
def fast_calculation(values):
    """局部變量查找比全局/屬性查找更快"""
    append = values.append  # 將方法引用保存到局部變量
    result = []
    append_result = result.append
    for value in values:
        append_result(value * 2)  # 快速調(diào)用！
    return result

import sys
import traceback
def debug_call(func, *args, **kwargs):
    """調(diào)試函數(shù)調(diào)用的神奇工具"""
    print(f"?? 調(diào)試 {func.__name__}...")
    print(f"   參數(shù)：args={args}, kwargs={kwargs}")
    try:
        result = func(*args, **kwargs)
        print(f"   結(jié)果：{result}")
        return result
    except Exception as e:
        print(f"   ?? 出錯：{e}")
        print("   調(diào)用棧：")
        traceback.print_exc()
        raise
# 使用示例
def risky_division(a, b):
    return a / b
debug_call(risky_division, 10, 2)   # 正常情況
debug_call(risky_division, 10, 0)   # 除以零錯誤！