1.装饰器的思想：进一步复用

装饰器（Decorator）是 Python 中一种强大的编程工具，核心作用是在不修改原函数代码的前提下，为函数添加额外功能（如日志记录、性能统计、权限校验等）。它充分利用了 Python 中 “函数是一等公民”（可作为参数传递、赋值、返回）的特性，通过 “包装” 原函数来扩展其行为。

装饰器本质是一个返回函数的高阶函数。它接收被装饰的函数作为参数，返回一个 “包装后的新函数”。这个新函数在保留原函数功能的基础上，增加了额外逻辑。

如果让一个函数具备太多功能，那么他看起来就会比较乱，可读性比较差，如果把其中一部分相同甚至可以复用的功能用一个新的函数来调用，然后让2个函数同时实现，就会做到

（1）进一步封装了函数的一些用法，做到dry原则（don't repeat yourself）

（2）使函数更加具有可读性

所以装饰器本身就是函数中调用其他函数，实现先拆分函数，再合并函数的功能。

2.函数的装饰器写法

（1）普通函数

这个函数实现的是计算2到9999的所有质数（在大于 1 的自然数中，除了 1 和它自身外，不能被其他自然数整除的数），并且打印找到这些数需要的时间。

会发现，这个time模块让整个代码逻辑很混乱，因为函数的主体是找质数，time模块是找质数的时间，如果可以time模块放在函数外，这样逻辑才清晰

import time# 是否为质数
def is_prime(n):if n <= 1 :return Falsefor i in range(2, int(n**0.5) + 1):if n % i == 0:return Falsereturn True# 定义一个函数，循环2到9999的数字，判断是否为质数
def prime_nums():t1 = time.time()for i in range(2, 10000):if is_prime(i):print(i)t2 = time.time()print(f"程序运行时间为：{t2 - t1}秒")# 调用函数
prime_nums()

（2）装饰器函数

装饰器的本质是一个高阶函数，它接收一个函数作为参数，并返回一个新函数来替代原函数。这个新函数需要：

a、保留原函数的调用方式（参数和返回值）。

b、在原函数执行前后添加额外逻辑（如计时、日志等）。

因此，我们需要在装饰器内部定义一个新函数来实现这些功能。

import time# 定义一个装饰器函数，用于计算函数的运行时间
def display_time(func):def wrapper():      # 定义一个内部函数，用于包装被装饰的函数，在装饰器中wrapper函数是一个常用的函数名start_time = time.time()  # 记录开始时间func()  # 直接调用原函数（无参数），这里的func()是指装饰器需要修饰的函数，在这里是prime_nums()end_time = time.time()  # 记录结束时间  print(f"函数 {func.__name__} 运行时间: {end_time - start_time} 秒")  # 打印函数运行时间# return wrapper是返回函数对象，如果是return wrapper()则是立即执行wrapper函数return wrapper  # 返回包装后的函数，这里的wrapper是指装饰器内部定义的函数，在这里是display_time()

# 继续定义判断质数的函数def is_prime(num):"""判断一个数是否为质数（处理负数和非整数输入）"""if num <= 1:  # 1和负数不是质数return Falsefor i in range(2, int(num**0.5) + 1):  # 只需要检查到平方根if num % i == 0:  # 如果能被整除，不是质数return Falsereturn True  # 否则是质数# 装饰器的标准写法
@display_time  # 应用装饰器，统计函数执行时间
def prime_nums():"""找到2到9999之间的所有质数并打印"""for i in range(2, 10000):  if is_prime(i):  # 如果是质数，打印print(i)# 调用函数，显示执行时间
prime_nums()
# 执行时间每次都会变，但是变动不大，一般计算稳定的执行时间我们都是重复1000遍，然后取平均

之所以采取这种写法可以实现这个逻辑，是因为装饰器在设计的时候底层思想如下，@display_time等价于

def prime_nums():...  # 函数体prime_nums = display_time(prime_nums) 

      装饰器的执行流程为：

a、定义装饰器函数 display_time：它接收一个函数 func 作为参数，并返回 wrapper 函数。

b、定义被装饰函数 prime_nums：此时 prime_nums 是一个普通函数对象。

c、应用装饰器：Python 自动将 prime_nums 作为参数传递给 display_time，即执行 display_time(prime_nums)。

d、替换原函数：display_time 返回 wrapper 函数，Python 用这个新函数覆盖了原来的 prime_nums。

也就是说装饰后，原函数名指向 wrapper，而非原始函数。

       当你调用 prime_nums() 时，实际上执行的是 wrapper()，它会：

a、记录开始时间

b、调用 func()（即原函数）

c、记录结束时间并打印耗时

        这种等价的设计，会让初学者搞不懂为什么突然可以采取这种优雅的写法，类似的写法还有很多，在python中叫做语法糖：通过规范的写法来让代码更加优美和简洁。可以把@理解为语法糖操作，实际上并非是@装饰器，而是@装饰器+下一行的代码 二者是一个整体。

（3）语法糖

        语法糖（Syntactic Sugar）是编程语言中为简化代码书写、提升可读性而设计的语法特性。它本质是对底层逻辑的 “包装”，让开发者用更简洁的方式实现相同功能，但不会改变程序的实际行为或性能（即 “语法层面的优化”）。语法糖的核心目标是降低代码的 “心智负担”。通过更贴近自然语言或更紧凑的写法，让开发者用更少的代码表达相同逻辑，同时减少出错概率。

# 装饰器函数（统计耗时）
def timer(func):def wrapper(*args, **kwargs):start = time.time()res = func(*args, **kwargs)print(f"耗时：{time.time()-start:.2f}s")return resreturn wrapper# 无语法糖：手动绑定装饰器
def my_func():time.sleep(1)
my_func = timer(my_func)  # 必须显式赋值# 有语法糖：用 @ 符号直接标记（等价于上面的手动赋值）
@timer
def my_func():time.sleep(1)# 列表推导式 需求：生成一个包含 0-9 平方的列表
# 无语法糖：普通循环
squares = []
for x in range(10):squares.append(x**2)  # 3行代码# 有语法糖：列表推导式（1行代码）
squares = [x**2 for x in range(10)]# 三元表达式 需求：根据年龄判断是否成年
age = 20# 无语法糖：普通 if-else
if age >= 18:result = "成年"
else:result = "未成年"  # 4行代码# 有语法糖：三元表达式（1行代码）
result = "成年" if age >= 18 else "未成年"# with语句（上下文管理器） 需求：读取文件内容
# 无语法糖：手动 open/close（可能遗漏关闭）
f = open("test.txt", "r")
try:content = f.read()
finally:f.close()  # 必须显式关闭，否则可能占用资源# 有语法糖：with 语句（自动关闭文件）
with open("test.txt", "r") as f:content = f.read()  # 无需手动关闭，退出 with 块自动释放

3.注意内部函数的返回值

进一步拓展装饰器实现复用

可以看到，上述这个写法的时候，prime_nums()没有传入参数，如果函数有参数，那么必须给外部函数传入参数，也就是需要给外部的装饰器函数传入参数。

那么装饰器函数是需要复用的，不同的内部函数传入的参数不同，那就需要装饰器可以传入可变参数来维持这个特性。这就是说到了我们昨天的可变参数

装饰器函数返回的是wrapper函数，所以，在调用装饰器函数的时候，返回的还是wrapper函数，而不是被修饰的函数。他是被修饰函数的外层函数，参数要大于等于被修饰函数的参数

import time
def display_time(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} 秒")  # 打印函数执行时间return result  # 返回函数的执行结果return wrapper  # 返回装饰器函数@display_time  # 应用装饰器到函数上，注意这里的括号不能少
def add(a, b):"""简单的加法函数"""return a + b  # 返回两个参数的和
add(3, 5) # 正常接收函数并计算

注意下内部函数有无返回值？

注意到之前被修饰的函数在无参数情况下，wrapper里面只有func(),现在是result = func(*args, **kwargs)以及加上了return result

为什么会这样？因为被修饰的函数是return xxxx，而不是print xxx，被修饰的函数如果有返回值，装饰器函数就需要搭配返回值。

4.作业：

编写一个装饰器 logger，在函数执行前后打印日志信息（如函数名、参数、返回值）
@logger
def multiply(a, b):
    return a * b

multiply(2, 3)  
# 输出:
# 开始执行函数 multiply，参数: (2, 3), {}
# 函数 multiply 执行完毕，返回值: 6

def logger(func):def wrapper(*args, **kwargs):   # args 是元组，kwargs 是字典print(f"调用函数: {func.__name__}")print(f"参数: {args}, {kwargs}")result = func(*args, **kwargs)print(f"函数 {func.__name__} 执行完毕，返回值: {result}")return resultreturn wrapper@logger
def multiply(a, b):return a * bmultiply(2, 3)  

@浙大疏锦行