本文为 Python 60 Days Challenge 课程学习整理，原作者与原 Notebook 链接见「课程资料」。代码按章节顺序运行；语法示意和故意报错的反例已单独标注。

文中保留的截图、性能表和数值属于原讲义的历史示例，不是本次修订后的重新训练结果。实际输出受数据、版本、随机种子和训练预算影响。

打卡任务

  • 阅读本节讲义或 Notebook
  • 跑通示例代码
  • 整理 3 个关键点
  • 完成当日打卡输出

课程资料

学习内容

友情提示：今天的内容难度较大，也是在我之前学习的时候卡住我很久都没理解的地方，所以任务量不多，着重理解我的示例代码即可

昨天我们接触到了函数大部分的功能，然后在你日常ctrl点进某个复杂的项目，发现函数上方有一个@xxx,它就是装饰器

装饰器本质上是一个 Python 函数，它可以让其他函数或方法在不需要做任何代码修改的前提下增加额外功能。--本质是如果让一个函数具备太多功能，那么他看起来就会比较乱，可读性比较差，如果把其中一部分相同甚至可以复用的功能用一个新的函数来调用，然后让2个函数同时实现，就会做到

  1. 进一步封装了函数的一些用法，做到dry原则（don't repeat yourself）
  2. 使函数更加具有可读性

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

普通的函数

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

  1. 定义一个判断是否为质数
  2. 定义一个函数，循环2到9999的数，通过判断质数函数来筛选每个数
  3. 在函数中通过time模块进行记时

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

import time


def is_prime(num):
    if num < 2:
        return False
    elif num == 2:
        return True
    else:
        for i in range(2, num):
            if num % i == 0:
                return False
        return True


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()

装饰器函数

import time

# 定义一个装饰器
def display_time(func):
    def wrapper(): # 定义一个内部函数，在装饰器中wrapper函数是一个常用的函数名，并非强制，约定俗成的
        start_time = time.time()
        func()  # 直接调用原函数（无参数），这里的func()是指装饰器需要修饰的函数，在这里是prime_nums()
        end_time = time.time()
        print(f"执行时间: {end_time - start_time} 秒")
    return wrapper # return wrapper是返回函数对象，如果是return wrapper()则是立即执行wrapper函数

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

  1. 保留原函数的调用方式（参数和返回值）。
  2. 在原函数执行前后添加额外逻辑（如计时、日志等）。

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

# 继续定义判断质数的函数
def is_prime(num):
    """
    判断一个数是否为素数
    """
    if num < 2:
        return False
    elif num == 2:
        return True
    else:
        for i in range(2, num):
            if num % i == 0:
                return False
        return True

# 装饰器的标准写法
@display_time
def prime_nums(): # 这2行是一个整体
    """
    找出2到10000之间的所有素数并打印
    """
    for i in range(2, 10000):
        if is_prime(i):
            print(i)


prime_nums()
# 执行时间每次都会变，但是变动不大，一般计算稳定的执行时间我们都是重复1000遍，然后取平均

复制上述完整的代码到py文件，然后在say_hello()处打上断点，进行单步调试（不用逐过程因为需要进入到函数内部）查看执行顺序

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

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

prime_nums = display_time(prime_nums)

装饰器的执行流程为：

  1. 定义装饰器函数 ​display_time​​：它接收一个函数 func​ 作为参数，并返回 wrapper 函数。
  2. 定义被装饰函数 ​prime_nums​​：此时 prime_nums 是一个普通函数对象。
  3. 应用装饰器：Python 自动将 prime_nums​ 作为参数传递给 display_time​，即执行 display_time(prime_nums)。
  4. 替换原函数：display_time​ 返回 wrapper​ 函数，Python 用这个新函数覆盖了原来的 prime_nums。

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

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

  1. 记录开始时间
  2. 调用 func()（即原函数）
  3. 记录结束时间并打印耗时

这种等价的设计，会让初学者搞不懂为什么突然可以采取这种优雅的写法，类似的写法还有很多，在python中叫做语法糖：通过规范的写法来让代码更加优美和简洁，比如列表推导式也是，我们在后面再提。

你可以把@理解为语法糖操作，实际上并非是@装饰器，而是@装饰器+下一行的代码 二者是一个整体

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

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

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

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

import time

def display_time(func):
    """支持任意参数的时间统计装饰器"""
    def wrapper(*args, **kwargs):  # 接收任意数量的位置参数和关键字参数
        t1 = time.time()
        result = func(*args, **kwargs)  # 将参数传递给原函数，注意之前的无参数写法和现在不同
        t2 = time.time()
        print(f"函数执行时间: {t2 - t1} 秒")
        return result  # 返回原函数的返回值
    return wrapper

@display_time
def add(a, b):
    return a + b

add(3, 5)  # 正常接收参数并计算

最后一个tips：注意下内部函数有无返回值？

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

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

今日作业

# 作业答案

def logger(func):
    def wrapper(*args, **kwargs):  # args 是元组，kwargs 是字典
        print(f"开始执行函数 {func.__name__}，参数: {args}, {kwargs}")
        result = func(*args, **kwargs)
        print(f"函数 {func.__name__} 执行完毕，返回值: {result}")
        return result
    return wrapper

@logger
def multiply(a, b):
    return a * b 

multiply(2, 3)  # 调用 multiply 函数，观察日志输出

multiply(a=2, b=3)

multiply(2, b=3)

以下是语法示意或故意报错的反例，不是需要整段运行的正常程序。

multiply(a = 2, 3)

报错是因为关键字参数必须跟在所有位置参数之后