Linux C/C++静态库与动态库：从原理到实战的完整指南
2026/7/22 7:19:17
视频链接：
https://space.bilibili.com/70431433?spm_id_from=333.1007.0.0
文章代码链接：
https://github.com/zyf-ngu/Qmatter
4高阶函数
内部函数-闭包
在 Python 中，内部函数（嵌套函数）可以直接访问外部函数的参数和变量，这种特性称为闭包（Closure）。闭包允许内部函数捕获并记住外部函数的环境，即使外部函数已经执行完毕。
闭包类似 “实例化” 的效果 —— 创建多个独立的 “函数实例”，它们拥有各自独立的状态，互不干扰。通过 “局部状态记忆” 替代全局变量，将状态封装在函数内部，避免全局变量易引发命名冲突（如多个模块定义count变量）。
闭包的典型应用（记住外部环境）
def make_counter():
count = 0 # 外部函数的变量
def counter():
nonlocal count
count += 1
return count
# 返回内部函数（闭包）
return counter
# 创建计数器实例
counter1 = make_counter()
counter2 = make_counter()
# 调用闭包，每个实例会记住自己的count状态
print(counter1()) # 1
print(counter1()) # 2
print(counter2()) # 1
print(counter1()) # 3
print(counter2()) # 2
关键规则：
- 读取外部参数 / 变量：内部函数可以直接读取外部函数的参数和变量。
- 修改限制：默认情况下，内部函数不能直接修改外部函数的不可变类型变量（如 int、str、tuple），但可以修改可变类型变量（如 list、dict）。
强制修改：如果需要修改外部函数的不可变变量，可以使用nonlocal关键字声明。
以下是关于 Python 嵌套函数（闭包）的具体实例，展示了不同情况下内部函数对外部变量的访问和修改方式：
实例 1：内部函数读取外部变量
def outer_function(message):
# 外部函数的变量
outer_var = "外部变量"
def inner_function():
# 内部函数读取外部变量和参数
print(f"内部函数访问外部参数: {message}")
print(f"内部函数访问外部变量: {outer_var}")
# 调用内部函数，一般用于多线程处理
inner_function()
# 调用外部函数
outer_function("外部参数")
输出：
内部函数访问外部参数: 外部参数
内部函数访问外部变量: 外部变量
实例 2：修改外部可变类型变量（list/dict）
def outer_function():
# 外部函数的可变类型变量（列表）
outer_list = [1, 2, 3]
def inner_function():
# 直接修改外部可变类型变量（无需特殊声明）
outer_list.append(4)
print(f"内部函数修改后的列表: {outer_list}")
inner_function()
return outer_list
# 调用外部函数
result = outer_function()
print(f"外部函数返回的列表: {result}")
输出：
内部函数修改后的列表: [1, 2, 3, 4]
外部函数返回的列表: [1, 2, 3, 4]
实例 3：修改外部不可变类型变量（需用 nonlocal）
def outer_function():
# 外部函数的不可变类型变量（整数）
outer_num = 10
def inner_function():
#声明需要修改外部不可变变量
nonlocal outer_num
outer_num = 20 # 现在可以修改了
print(f"内部函数修改后的数值: {outer_num}")
inner_function()
return outer_num
# 调用外部函数
result = outer_function()
print(f"外部函数返回的数值: {result}")
输出：
内部函数修改后的数值: 20
外部函数返回的数值: 20
装饰器函数
我们知道，函数是封装了特定功能的代码块，前面也介绍了函数参数的具体传递，不过参数均是简单的变量。如果我们想对函数的功能进行扩展应该怎么做呢？直接修改函数代码必然不是一个好选择，python提供了装饰器。
装饰器是Python中一个非常强大的功能，它允许我们修改或增强函数、方法或类的行为，而不需要改变其本身的代码。装饰器本质上是一个可调用对象（通常是一个函数），它接受一个函数作为参数，并返回一个新的函数。新函数包括2部分，核心部分是原函数的功能，第2部分就是新增的模式化的通用功能。
其基本结构如下：
#1 定义一个接收函数为参数的装饰器函数
def decorator_function(func):
#2定义一个包装函数（wrapper），参数使用*args,**kwargs，以适应各种参数的原函数，这里参数和原函数是对应的
def wrapper(*args,**kwargs):
语句1#3.在原函数前后增加一些通用的功能语句，也可以使用上面传递进来的参数
result=func(*args,**kwargs)#4.调用原函数
语句2
return result#5原函数有返回值则返回值，包装函数结束
return wrapper#最后返回扩展函数，装饰器函数结束
# 6 使用方式，@+装饰器函数名，下面跟着接收函数的定义，之后正常调用接收函数
@decorator_function
def func:
pass
举个例子，在调用原函数前后添加了额外日志记录的功能。
def log_decorator(func):
defwrapper(*args, **kwargs):
for num in args:#内部扩展函数的其它语句也可以使用
print('num:',num)
print(f"Before function {func.__name__} is called.")
result = func(*args, **kwargs)
print(f"After function {func.__name__} is called.")
return result
return wrapper
@log_decorator# 接收函数为参数的函数名前面加@符号即为装饰器。
def add(a, b):#原函数定义在下方
return a + b
result = add(3, 5)
print(result)
# 带参数的装饰器需要三层嵌套
def require_role(role):
#外层接收装饰器参数
def decorator(original_func):
# 中间层接收函数
def wrapper(*args, **kwargs):
# 内层实现装饰逻辑
if role == "admin":
print("管理员权限验证通过")
return original_func(*args, **kwargs)
else:
raise PermissionError("权限不足!")
return wrapper
return decorator
# 应用带参数的装饰器
@require_role("admin")
def delete_database():
print("数据库已删除!")
@require_role("user")
def view_data():
print("显示数据...")
# 测试
delete_database() # 成功执行
try:
view_data() # 触发异常
except PermissionError as e:
print(f"错误: {e}")
总结一下，装饰器函数本质上是一个函数，其主要功能和作用体现在以下几个方面：
1. 代码复用和模块化
装饰器可以将一些通用的功能（如日志记录、权限验证、性能测试等）封装起来，然后应用到多个不同的函数上，避免了代码的重复编写，提高了代码的复用性和可维护性。
2. 功能增强
在不修改原函数代码的前提下，为原函数添加额外的功能。这符合软件开发中的开闭原则，即对扩展开放，对修改关闭。
3. 分离关注点
将与核心业务逻辑无关的功能（如日志、权限控制等）从业务逻辑中分离出来，使代码结构更加清晰，便于维护和管理。
注意事项-
装饰器会改变被装饰函数的元信息（如函数名、文档字符串等），可以使用`functools.wraps`来保留这些信息。
- 装饰器在模块导入时就会执行，因此装饰器内部的代码会在导入时运行。
使用functools.wraps保留原始函数的元信息，
import functools
def my_decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print("装饰器中...")
return func(*args, **kwargs)
return wrapper
@my_decoratordef example():
print("Hello")
print(example.__name__) # 输出 'example' 而不是 'wrapper'
print(example.__doc__) # 输出 '示例函数的文档字符串' 而不是 '包装函数的文档字符串'```
匿名函数（Lambda 函数）
匿名函数（Lambda 函数）是一种不需要使用def关键字定义的函数，它使用lambda关键字创建。Lambda 函数是一个小型、匿名的函数，可以接受任意数量的参数，但只能有一个表达式。
语法：
func（可选，函数对象）=lambdaarguments: expression
原理：
Lambda 函数在运行时创建，返回一个函数对象。这个函数对象可以像普通函数一样被调用，参数在调用时传递进去，但它没有函数名（因此称为"匿名"函数）。
简洁性：对于简单的操作，使用 lambda 函数比定义完整函数更简洁
一次性使用：适用于只需要使用一次的小型函数
函数式编程：常与高阶函数（如 map(), filter(), reduce()）配合使用
回调函数：作为参数传递给其他函数
# 1. lambda基本用法
add= lambda x, y: x + y
print(add(5, 3)) # 输出: 8
# 2. 与普通函数对比
def add_def(x, y):
return x + y
# Lambda 版本更简洁
# 3. 在排序中使用
students = [("Alice", 90), ("Bob", 85), ("Charlie", 95)]# 按分数排序
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students) # 输出: [('Bob', 85), ('Alice', 90), ('Charlie', 95)]
# 4. 立即调用 lambda 函数
result = (lambda x, y: x * y)(5, 6)
print(result) # 输出: 30
高阶函数
高阶函数是指能够接收函数作为参数或将函数作为返回值的函数。在 Python 中，函数是一等对象（first-class objects），这意味着函数可以像其他对象一样被传递和操作。通过将函数作为参数或返回值，实现了更高层次的抽象和代码复用。
抽象通用模式：将通用操作模式抽象出来，具体行为通过函数参数定制
代码复用：减少重复代码，提高代码的可维护性
函数组合：通过组合简单函数构建复杂功能
延迟执行：可以创建并返回函数，在需要时执行
高阶函数、闭包和装饰器之间的关系可以概括为：装饰器是闭包的一种应用，而闭包又是高阶函数的一种形式。
高阶函数是指能够接收函数作为参数，或者将函数作为返回值的函数。
闭包是指在一个内部函数中，对外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包。闭包允许函数记住并访问其词法作用域中的变量，即使函数是在其作用域之外执行。
装饰器本质上是一个函数，它接收一个函数作为参数，并返回一个新的函数。装饰器通常用于在不修改原函数代码的情况下，为函数添加新的功能。
装饰器是利用闭包和高阶函数的特性来实现的。
装饰器是一个高阶函数，因为它接收函数作为参数并返回函数。
装饰器内部通常会定义一个闭包（内部函数），这个闭包会引用外部函数的参数（即被装饰的函数）以及外部作用域的变量。
# 1. 接收函数作为参数的高阶函数（lambda函数作为参数）
def apply_operation(func, x, y):
"""应用给定的操作到两个参数上"""
return func(x, y)
# 使用不同的操作
result1 = apply_operation(lambda a, b: a + b, 5, 3)
result2 = apply_operation(lambda a, b: a * b, 5, 3)
print(result1, result2) # 输出: 8 15
#2. Python 内置高阶函数
from functools import reduce
numbers = [1, 2, 3, 4, 5]
# map() - 对每个元素应用函数
squared = list(map(lambda x: x**2, numbers))
print(squared) # 输出: [1, 4, 9, 16, 25]
# filter() - 过滤满足条件的元素
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens) # 输出: [2, 4]
# reduce() - 累积计算序列中的元素
sum_all = reduce(lambda x, y: x + y, numbers)
print(sum_all) # 输出: 15