Python 进阶 - 第十七节

---

📋 本节要点

知识点	说明
lambda	匿名函数，单行表达式
返回函数	一个函数返回另一个函数
闭包	内部函数引用外部函数的变量
偏函数	固定部分参数简化函数调用

---

1. lambda 匿名函数

lambda 是没有名字的函数，用于创建简单的单行函数对象。

lambda 参数: 表达式  # 等价于 def 函数(参数): return 表达式

1.1 基本用法

# 普通函数
def add(a, b):
    return a + b

# 等价的 lambda
add_lambda = lambda a, b: a + b

print(add(1, 2))         # 3
print(add_lambda(1, 2))  # 3

1.2 配合高阶函数使用

# map() 批量转换
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

# filter() 条件过滤
evens = list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6]))
print(evens)  # [2, 4, 6]

# sorted() 自定义排序
students = [("张三", 85), ("李四", 92), ("王五", 78)]
sorted_students = sorted(students, key=lambda x: x[1], reverse=True)
print(sorted_students)  # [('李四', 92), ('张三', 85), ('王五', 78)]

1.3 lambda 的限制

lambda 只能包含单个表达式，不能包含语句（如赋值、return）。

# 正确：单个表达式
square = lambda x: x ** 2

# 错误：不能有语句
# square = lambda x: result = x ** 2  # 语法错误

---

2. 返回函数

返回函数是指一个函数返回另一个函数，而不是返回一个值。返回的函数在后续调用时才会执行。

def outer():
    def inner():
        print("函数内容")
    return inner  # 返回 inner 函数本身（不执行）

f = outer()   # f 就是 inner 函数
f()           # 真正执行 inner

2.1 延迟计算

返回函数的典型应用：延迟计算——不需要立即得到结果，在需要的时候再调用。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax += n
        return ax
    return sum

f = lazy_sum(1, 3, 5, 7, 9)
print(f)     # <function lazy_sum.<locals>.sum at ...>
print(f())   # 25（真正执行求和）

2.2 闭包

闭包是指内部函数引用了外部函数的变量（如上面示例中 sum() 引用了 args）。即使外部函数已执行完毕，内部函数仍然可以访问这些变量。

---

3. 偏函数（partial）

偏函数通过固定函数的部分参数，创建简化版的新函数，类似默认参数的效果。

from functools import partial

# 原始函数
def power(base, exponent):
    return base ** exponent

# 固定 exponent 参数，创建偏函数
square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25（5²）
print(cube(2))    # 8（2³）

3.1 实际应用

# 固定 round() 的小数位数
from functools import partial

round2 = partial(round, ndigits=2)
print(round2(3.1415926))  # 3.14

# 固定 int() 的进制
int_base2 = partial(int, base=2)
int_base16 = partial(int, base=16)
print(int_base2("1010"))   # 10
print(int_base16("FF"))    # 255

---

4. 实战案例：计算器

用偏函数和 lambda 实现一个简易计算器：

from functools import partial

def calculate(a, b, operator):
    if operator == "+":
        return a + b
    elif operator == "-":
        return a - b
    elif operator == "*":
        return a * b
    elif operator == "/":
        return a / b if b != 0 else "Error"

# 创建偏函数
add = lambda a: partial(calculate, a, operator="+")
sub = lambda a: partial(calculate, a, operator="-")
mul = lambda a: partial(calculate, a, operator="*")
div = lambda a: partial(calculate, a, operator="/")

# 使用
print(add(10)(5))   # 15
print(sub(10)(5))   # 5
print(mul(10)(5))   # 50
print(div(10)(5))   # 2.0

运行结果：

15
5
50
2.0

---

下一节预告：装饰器