Python函数调用的底层秘密与实战技巧

# 新手魔法师的第一个咒语
def say_hello(name):
    return f"✨ 魔法的问候：{name}！"
# 施展魔法！
result = say_hello("Python学徒")  # 看，函数调用了！
print(result)  # 输出：✨ 魔法的问候：Python学徒！

import traceback
def explore_stack():
    """探索当前调用栈的冒险家"""
    print("🔍 当前调用栈深度：", 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)  # 继续下潜！
deep_magic(3)
# 输出：
# 🔍 当前调用栈深度：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}"
# 标准调用方式
print(make_potion("龙鳞", "凤凰泪", "独角兽毛"))

# 明确指定参数名，顺序不重要！
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：接收任意数量的位置参数（变成元组）
def summon_creatures(*creatures):
    return f"召唤：{', '.join(creatures)}！"
print(summon_creatures("龙", "凤凰", "狮鹫", "独角兽"))
# **kwargs：接收任意数量的关键字参数（变成字典）
def create_potion(**ingredients):
    recipe = " + ".join(f"{k}({v}克)" for k, v in ingredients.items())
    return f"魔药配方：{recipe}"
print(create_potion(龙鳞=10, 凤凰泪=5, 月光草=3))
# 拆包魔法：把列表/字典变成参数
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 是一个函数！"""
    return formatter(f"Hello, {name}")
print(greet("Alice", shout))   # 输出：HELLO, ALICE!
print(greet("Bob", whisper))   # 输出：hello, bob...

def make_multiplier(factor):
    """工厂函数：生产乘法器"""
    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！）

import time
def timer_decorator(func):
    """给函数添加计时功能的装饰器"""
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)  # 调用原始函数
        end_time = time.time()
        print(f"⏱️  {func.__name__} 执行时间：{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 执行时间：0.0452秒
# 333332833333500000（计算结果）

def magic_sequence(limit):
    """生成器函数：按需生成值"""
    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循环
for square in magic_sequence(3):
    print(f"得到：{square}")
# 输出：
# 🔮 生成器开始工作...
# 得到：0
# 得到：1
# 得到：4
# ✨ 生成器工作完成

def running_average():
    """协程：维护运行平均值"""
    total = 0
    count = 0
    average = 0
    while True:
        value = yield average  # 接收值，返回平均值
        total += value
        count += 1
        average = total / count
# 使用协程
avg_coroutine = running_average()
next(avg_coroutine)  # 启动协程（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:
    """一个可调用的咒语类"""
    def __init__(self, incantation):
        self.incantation = incantation
    def __call__(self, target):
        return f"💫 {self.incantation}！{target}被施法了！"
# 创建咒语对象
expelliarmus = Spell("除你武器")
lumos = Spell("荧光闪烁")
# 像调用函数一样调用对象！
print(expelliarmus("马尔福的魔杖"))  # 输出：💫 除你武器！马尔福的魔杖被施法了！
print(lumos("黑暗的走廊"))           # 输出：💫 荧光闪烁！黑暗的走廊被施法了！

def mysterious_function(x, y=10, *args, **kwargs):
    """一个神秘的函数"""
    return x + y + sum(args) + sum(kwargs.values())
# 看看这个函数的所有信息！
print("函数名：", mysterious_function.__name__)
print("文档字符串：", mysterious_function.__doc__)
print("参数信息：", mysterious_function.__code__.co_varnames)
print("参数个数：", mysterious_function.__code__.co_argcount)
print("默认值：", mysterious_function.__defaults__)
# 输出：
# 函数名： mysterious_function
# 文档字符串： 一个神秘的函数
# 参数信息： ('x', 'y', 'args', 'kwargs')
# 参数个数： 2
# 默认值： (10,)

# 避免在循环中重复计算
def process_items(items):
    """优化前：每次循环都计算长度"""
    for i in range(len(items)):  # len()在每次迭代都被调用
        process(items[i])
    """优化后：预先计算长度"""
    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)  # 快速调用！
    return result

import sys
import traceback
def debug_call(func, *args, **kwargs):
    """调试函数调用的神奇工具"""
    print(f"🔧 调试 {func.__name__}...")
    print(f"   参数：args={args}, kwargs={kwargs}")
    try:
        result = func(*args, **kwargs)
        print(f"   结果：{result}")
        return result
    except Exception as e:
        print(f"   💥 出错：{e}")
        print("   调用栈：")
        traceback.print_exc()
        raise
# 使用示例
def risky_division(a, b):
    return a / b
debug_call(risky_division, 10, 2)   # 正常情况
debug_call(risky_division, 10, 0)   # 除以零错误！