函数是Python中最基本的代码组织单元，理解它的底层机制是从入门走向进阶的关键一步。很多初学者能写函数，却说不清函数在内存中是什么、参数到底是值传递还是引用传递、为什么默认参数用列表会出问题。这篇文章将围绕Python函数的核心原理展开，配合大量实战案例，帮你把函数这块知识彻底吃透。
一、函数的本质：一切皆对象
在Python中，函数不是简单的代码块，而是一等公民（first-class object）。这意味着函数可以赋值给变量、作为参数传递、作为返回值返回，甚至可以塞进列表和字典里。def语句执行时，实际上是创建了一个函数对象，并把函数名绑定到这个对象上。
def greet(name):
return f"hello, {name}"
# 函数可以赋值给另一个变量
say = greet
print(say("Python")) # 输出: hello, Python
# 函数可以放进容器
funcs = [greet, len, print]
print(funcs[1]("abcdef")) # 输出: 6函数对象身上携带了很多有用属性，例如__name__记录函数名，__doc__存储文档字符串，__defaults__保存默认参数值。理解这些属性对调试和分析第三方代码非常有帮助，尤其是后面讲默认参数陷阱时会用到__defaults__。
正因为函数是对象，Python才具备了函数式编程的基础能力。内置的map、filter、sorted的key参数，都依赖“函数当参数传”这个特性。比如用sorted(data, key=lambda x: x["age"])对字典列表排序，本质就是把一个匿名函数对象交给了sorted内部去调用。
二、参数传递机制：可变对象与不可变对象的差异
Python的参数传递既不是纯粹的值传递，也不是纯粹的引用传递，更准确的说法是“传对象引用”（pass by object reference）。函数接收的是对象的引用副本，行为差异取决于对象本身是否可变。
对于数字、字符串、元组这类不可变对象，函数内部重新赋值只会让局部变量指向新对象，不会影响外部变量。而列表、字典、集合这类可变对象，在函数内部原地修改（如append、update）会直接影响调用方的数据。
def modify(a, b):
a = 100 # 不可变对象，重新绑定，不影响外部
b.append(4) # 可变对象，原地修改，影响外部
x = 1
y = [1, 2, 3]
modify(x, y)
print(x) # 输出: 1
print(y) # 输出: [1, 2, 3, 4]接着要重点讲一个经典陷阱：默认参数在函数定义时只求值一次，而不是每次调用时重新创建。如果默认值是可变对象，它会在所有调用之间共享。
def add_item(item, items=[]): # 危险写法
items.append(item)
return items
print(add_item(1)) # 输出: [1]
print(add_item(2)) # 输出: [1, 2]，意外吗？
# 正确做法：用None作为哨兵值
def add_item_safe(item, items=None):
if items is None:
items = []
items.append(item)
return items可以通过add_item.__defaults__观察到那个被共享的列表一直在膨胀。这是面试和实际生产中都高频出现的问题，务必养成“可变默认参数一律用None”的习惯。
再补充可变参数的语法。*args收集多余的位置参数成元组，**kwargs收集多余的关键字参数成字典。它们既能用于函数定义，也能在调用时反向解包，写出非常灵活的接口。关键字参数和仅限位置参数（/）、仅限关键字参数（*）配合使用，可以设计出签名清晰的API。
def connect(host, port, /, *, timeout=5, retry=3):
print(host, port, timeout, retry)
connect("127.0.0.1", 3306, timeout=10)
# host、port只能按位置传，timeout、retry只能按关键字传
def wrapper(*args, **kwargs):
return wrapper_target(*args, **kwargs) # 参数透传的典型写法三、作用域与闭包：LEGB规则的实战应用
Python查找变量名遵循LEGB顺序：Local（函数内部）→ Enclosing（外层函数）→ Global（模块级）→ Builtin（内置命名空间）。在函数内想修改外层变量，需要用nonlocal或global声明，否则会被当作新的局部变量。
闭包是理解装饰器的前置知识。当一个内层函数引用了外层函数的变量，并且内层函数被返回到外部时，就形成了闭包。被引用的变量会保存在函数的__closure__属性中，即使外层函数已经执行结束，这些值依然存活。
def make_counter():
count = 0
def counter():
nonlocal count # 声明修改外层变量
count += 1
return count
return counter
c = make_counter()
print(c(), c(), c()) # 输出: 1 2 3注意一个易错点：在循环中创建闭包时，闭包捕获的是变量本身而不是当时的值。经典例子是循环生成多个lambda，最后所有lambda拿到的都是循环结束后的最终值。解决办法是在默认参数中固化当前值，例如lambda x=i: x * 2，利用默认参数在定义时求值的特性来绑定快照。
闭包最常见的工程应用就是装饰器。装饰器本质是一个接收函数并返回新函数的高阶函数，配合@语法糖，可以在不修改原函数代码的前提下增加日志、计时、缓存、权限校验等横切逻辑。
import functools
import time
def timer(func):
@functools.wraps(func) # 保留原函数的元信息
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
cost = time.perf_counter() - start
print(f"{func.__name__} 耗时 {cost:.4f}s")
return result
return wrapper
@timer
def slow_task():
time.sleep(0.5)
slow_task()functools.wraps这个细节非常关键。如果不加它，被装饰后的函数的__name__会变成wrapper，导致日志、调试信息和文档全部失真。标准库还提供了现成的functools.lru_cache装饰器做备忘录优化，对纯计算函数加一行@lru_cache(maxsize=None)往往能让递归算法性能提升几个数量级，比如计算斐波那契数列时从指数级复杂度降到线性。
四、实战案例：递归、生成器函数与类型注解
递归是函数调用自身的编程技巧，写递归要牢牢把握两个要素：基准情形（终止条件）和递归推进（问题规模缩小）。以目录遍历为例，用递归处理嵌套结构比多层循环清晰得多。但要注意Python默认递归深度限制约为1000层，深层递归可用sys.setrecursionlimit调整，或者改写成显式栈的迭代版本。
def flatten(nested):
"""递归展平任意深度的嵌套列表"""
result = []
for item in nested:
if isinstance(item, list):
result.extend(flatten(item)) # 递归处理子列表
else:
result.append(item)
return result
print(flatten([1, [2, [3, 4]], 5])) # 输出: [1, 2, 3, 4, 5]生成器函数是函数家族中的特殊成员：函数体中包含yield关键字，调用它不执行函数体，而是返回一个生成器对象。每次next时执行到yield处暂停并交出值，函数的整个执行状态被完整保留。这种惰性求值方式在处理大文件、无限序列时内存占用极低。
def read_large_file(path):
"""逐行读取大文件，内存友好"""
with open(path, "r", encoding="utf-8") as f:
for line in f:
yield line.strip()
def fibonacci():
a, b = 0, 1
while True: # 无限序列也没问题
yield a
a, b = b, a + b最后提一下类型注解。虽然Python运行时不强制检查类型，但用typing模块给函数签名加上注解，配合mypy等静态检查工具，能大幅减少传参错误，也让IDE的智能提示更加准确。团队协作项目中，类型注解几乎是现代Python代码的标配写法。
from typing import Optional
def parse_int(value: str, default: Optional[int] = None) -> Optional[int]:
"""尝试解析字符串为整数，失败时返回默认值"""
try:
return int(value)
except ValueError:
return default总结一下，掌握Python函数需要打通四条主线：函数对象模型、参数传递与可变默认参数陷阱、LEGB作用域与闭包装饰器、以及递归和生成器等高级形态。把这些原理吃透后，再去阅读框架源码、编写通用工具函数，都会顺畅很多。建议把文中的示例逐个敲一遍，尤其亲手复现默认参数陷阱和闭包变量捕获问题，印象会深刻得多。