Python函数是第一类对象，可赋值、传参、返回、动态创建并带状态；定义用def、调用必加括号；lambda仅支持单表达式；参数传递本质是对象引用，是否原地修改决定外部是否可见；装饰器是接收并返回函数的高阶函数。

Python 中的 function 不是语法糖，而是第一类对象（first-class object）——这意味着它能被赋值、传参、返回、动态创建，甚至可以带状态。理解这点，才能避开“函数只是写一堆代码”的误区。

如何正确定义和调用 function

定义必须用 def，且函数名后紧跟括号和冒号；调用时括号不能省略（哪怕无参）。常见错误是把函数名当值用却忘了加 ()，结果得到的是函数对象本身，而非执行结果。

实操建议：

• 函数体必须缩进，且缩进需一致（推荐 4 空格）
• 参数默认值只在定义时求值一次，def f(x=[]) 是危险模式，应改用 None 作为占位符
• 函数末尾未写 return，自动返回 None；显式写 return 无值，也等价于 return None

def greet(name=None):
    if name is None:
        name = "World"
    return f"Hello, {name}!"
print(greet())      # Hello, World!
print(greet("Alice"))  # Hello, Alice!

为什么 lambda 不等于 function 的简化写法

lambda 只能包含单个表达式，不能有语句（如 if、for、赋值），也不能有文档字符串。它本质是匿名函数表达式，不是 def 的语法别名。

使用场景有限：多用于高阶函数（如 sorted()、map()）中临时传入简单逻辑。

容易踩的坑：

• lambda x: x if x > 0 else 0 合法；lambda x: if x > 0: return x 直接报 SyntaxError
• 闭包陷阱：循环中创建多个 lambda 共享同一个变量，导致全部捕获最后的值

funcs = []
for i in range(3):
    funcs.append(lambda: i)  # 全部返回 2
print([f() for f in funcs])  # [2, 2, 2]
正确写法：用默认参数固化当前值
funcs = []
for i in range(3):
funcs.append(lambda i=i: i)
print([f() for f in funcs])  # [0, 1, 2]

function 的参数传递机制：可变 vs 不可变对象的实际影响

Python 是“对象引用传递”，但效果常被误读为“值传递”或“引用传递”。关键看函数体内是否对参数对象做了**原地修改**（in-place mutation）。

实操判断依据：

• 对 list、dict、set 调用 .append()、.update() 等方法 → 原对象被改，调用方可见
• 对任何对象重新赋值（x = ...）→ 只改变局部变量指向，不影响外部
• str、int、tuple 不可变，所有“修改”操作都生成新对象

def modify_list(lst):
    lst.append(99)     # 原地修改，生效
    lst = [1, 2, 3]    # 仅重绑定局部变量，无效
a = [1, 2]
modify_list(a)
print(a)  # [1, 2, 99] —— 注意不是 [1, 2]

装饰器（@decorator）的本质就是 function 的函数式应用

装饰器是接收一个 function 并返回另一个 function 的高阶函数。它的语法糖 @xxx 等价于手动赋值：f = xxx(f)。

容易忽略的细节：

• 被装饰函数的元信息（__name__、__doc__）会被覆盖，需用 @functools.wraps(func) 修复
• 带参数的装饰器（如 @retry(times=3)）其实是三层嵌套函数：外层接收装饰器参数，中层接收被装饰函数，内层是实际 wrapper
• 装饰器在模块导入时就执行（即 def 完成后立即运行），不是调用时才触发

from functools import wraps
def log_calls(func):
@wraps(func)
def wrapper(*args, *kwargs):
print(f"Calling {func.name}")
return func(args, **kwargs)
return wrapper
@log_calls
def add(a, b):
"""Return sum of a and b."""
return a + b
print(add.name)  # add（不是 wrapper），因为用了 @wraps

真正难的不是写 function，而是判断何时该拆、何时该合、何时该用闭包、何时该用装饰器——这些决策背后全是对象生命周期、作用域规则和引用关系的综合权衡。