Sat Mar 01 2025

2420 words · 15 minutes

Python装饰器

tech python

Table of Contents

经过一晚上的学习，总算把装饰器大体弄明白了，一下是我参考一些内容：

B站UP主码农高天的视频：

菜鸟教程装饰器

python装饰器是什么？ Link to python装饰器是什么？

以下是DeepSeek对此问题的回答：

Python 装饰器（Decorator）是一种用于修改或增强函数/类行为的语法工具，它通过 @ 符号实现，本质上利用了函数式编程和高阶函数的特性。装饰器可以在不修改原函数/类代码的前提下，为其添加新功能。

理解 Link to 理解

本质：装饰器本身是一个可调用对象（函数或类），接收一个函数/类作为参数，返回修改后的函数/类。
作用：为代码提供非侵入式的功能扩展（如日志、权限校验、性能测试等）。
语法糖：@decorator 等价于 func = decorator(func)。

为了回答好这个问题首先要回答的是什么是函数

什么是函数？ Link to 什么是函数？

函数本质就是一个对象，本身是callable的

函数可以作为另一个函数的变量本身 Link to 函数可以作为另一个函数的变量本身

PYTHON

def double(x):
    return 2*x

def triple(x):
    return 3*x

def calc(func, x):
    return func(x)

print(calc(double, 2))
print(calc(triple, 3))

输出为：

CONSOLE

1
2

4
9

函数也可以作为另一个函数的返回值 Link to 函数也可以作为另一个函数的返回值

PYTHON

def generate_func(n):

    def multiple_func(x):
        return n*x

    return multiple_func

double = generate_func(2)
triple = generate_func(3)

print(double(2))
print(triple(3))

输出为

CONSOLE

1
2

4
9

decorator是输入和输出都是函数的函数(更正：函数或者对象) Link to decorator是输入和输出都是函数的函数(更正：函数或者对象)

PYTHON

    def dec(f):
        return f

    @dec
    def double(x):
        return x * 2

    #等价于
    double = dec(double)

第一个装饰器 Link to 第一个装饰器

一个很有用的装饰器的实例：

PYTHON

def a_new_decorator(a_func):

    def wrapTheFunction():
        print("I am doing some boring work before executing a_func()")

        a_func()

        print("I am doing some boring work after executing a_func()")

    return wrapTheFunction

def a_function_requiring_decoration():
    print("I am the function which needs some decoration to remove my foul smell")

a_function_requiring_decoration()
#outputs: "I am the function which needs some decoration to remove my foul smell"

a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
#now a_function_requiring_decoration is wrapped by wrapTheFunction()

a_function_requiring_decoration()
#outputs:I am doing some boring work before executing a_func()
#        I am the function which needs some decoration to remove my foul smell
#        I am doing some boring work after executing a_func()

我们刚刚应用了之前学习到的原理。这正是 python 中装饰器做的事情！它们封装一个函数，并且用这样或者那样的方式来修改它的行为。

现在你也许疑惑，我们在代码里并没有使用 @ 符号？那只是一个简短的方式来生成一个被装饰的函数。这里是我们如何使用 @ 来运行之前的代码：

PYTHON

@a_new_decorator
def a_function_requiring_decoration():
    """Hey you! Decorate me!"""
    print("I am the function which needs some decoration to "
          "remove my foul smell")

a_function_requiring_decoration()
#outputs: I am doing some boring work before executing a_func()
#         I am the function which needs some decoration to remove my foul smell
#         I am doing some boring work after executing a_func()

#the @a_new_decorator is just a short way of saying:
a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)

如何正确地输出函数名称 Link to 如何正确地输出函数名称

希望你现在对 Python 装饰器的工作原理有一个基本的理解。如果我们运行如下代码会存在一个问题：

CONSOLE

1
2

print(a_function_requiring_decoration.__name__)
# Output: wrapTheFunction

这并不是我们想要的！Ouput输出应该是”a_function_requiring_decoration”。这里的函数被warpTheFunction替代了。它重写了我们函数的名字和注释文档(docstring)。幸运的是Python提供给我们一个简单的函数来解决这个问题，那就是functools.wraps。我们修改上一个例子来使用functools.wraps：

PYTHON

from functools import wraps

def a_new_decorator(a_func):
    @wraps(a_func)
    def wrapTheFunction():
        print("I am doing some boring work before executing a_func()")
        a_func()
        print("I am doing some boring work after executing a_func()")
    return wrapTheFunction

@a_new_decorator
def a_function_requiring_decoration():
    """Hey yo! Decorate me!"""
    print("I am the function which needs some decoration to "
          "remove my foul smell")

print(a_function_requiring_decoration.__name__)
# Output: a_function_requiring_decoration

装饰器的一些常用场景 Link to 装饰器的一些常用场景

下面是python装饰器的一些常用的场景

蓝本规范: Link to 蓝本规范:

PYTHON

from functools import wraps
def decorator_name(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        if not can_run:
            return "Function will not run"
        return f(*args, **kwargs)
    return decorated

@decorator_name
def func():
    return("Function is running")

can_run = True
print(func())
# Output: Function is running

can_run = False
print(func())
# Output: Function will not run

注意：@wraps接受一个函数来进行装饰，并加入了复制函数名称、注释文档、参数列表等等的功能。这可以让我们在装饰器里面访问在装饰之前的函数的属性。

函数运算计时 Link to 函数运算计时

PYTHON

import time
def timeit(f):
    def wrapper(*args, **kwags)
        start = time.time()
        result = f(*args, **kwags)
        cosume = time.time() - start
        print(Caluating Time:f{consume})
        return result
    return wrapper

@timeit
def my_func():
    pass

授权(Authorization) Link to 授权(Authorization)

装饰器能有助于检查某个人是否被授权去使用一个web应用的端点(endpoint)。它们被大量使用于Flask和Django web框架中。这里是一个例子来使用基于装饰器的授权：

PYTHON

from functools import wraps

def requires_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            authenticate()
        return f(*args, **kwargs)
    return decorated

日志(Logging) Link to 日志(Logging)

日志是装饰器运用的另一个亮点。这是个例子：

PYTHON

from functools import wraps

def logit(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print(func.__name__ + " was called")
        return func(*args, **kwargs)
    return with_logging

@logit
def addition_func(x):
   """Do some math."""
   return x + x

result = addition_func(4)
# Output: addition_func was called

带参数的装饰器 Link to 带参数的装饰器

来想想这个问题，难道@wraps不也是个装饰器吗？但是，它接收一个参数，就像任何普通的函数能做的那样。那么，为什么我们不也那样做呢？这是因为，当你使用@my_decorator语法时，你是在应用一个以单个函数作为参数的一个包裹函数。记住，Python里每个东西都是一个对象，而且这包括函数！记住了这些，我们可以编写一下能返回一个包裹函数的函数。

在函数中嵌入装饰器 Link to 在函数中嵌入装饰器

我们回到日志的例子，并创建一个包裹函数，能让我们指定一个用于输出的日志文件。

PYTHON

from functools import wraps

def logit(logfile='out.log'):
    def logging_decorator(func):
        @wraps(func)
        def wrapped_function(*args, **kwargs):
            log_string = func.__name__ + " was called"
            print(log_string)
            # 打开logfile，并写入内容
            with open(logfile, 'a') as opened_file:
                # 现在将日志打到指定的logfile
                opened_file.write(log_string + '\n')
            return func(*args, **kwargs)
        return wrapped_function
    return logging_decorator

@logit()
def myfunc1():
    pass

myfunc1()
# Output: myfunc1 was called
# 现在一个叫做 out.log 的文件出现了，里面的内容就是上面的字符串

@logit(logfile='func2.log')
def myfunc2():
    pass

myfunc2()
# Output: myfunc2 was called
# 现在一个叫做 func2.log 的文件出现了，里面的内容就是上面的字符串

装饰器类 Link to 装饰器类

现在我们有了能用于正式环境的logit装饰器，但当我们的应用的某些部分还比较脆弱时，异常也许是需要更紧急关注的事情。比方说有时你只想打日志到一个文件。而有时你想把引起你注意的问题发送到一个email，同时也保留日志，留个记录。这是一个使用继承的场景，但目前为止我们只看到过用来构建装饰器的函数。

幸运的是，类也可以用来构建装饰器。那我们现在以一个类而不是一个函数的方式，来重新构建logit。

PYTHON

from functools import wraps

class logit(object):
    def __init__(self, logfile='out.log'):
        self.logfile = logfile

    def __call__(self, func):
        @wraps(func)
        def wrapped_function(*args, **kwargs):
            log_string = func.__name__ + " was called"
            print(log_string)
            # 打开logfile并写入
            with open(self.logfile, 'a') as opened_file:
                # 现在将日志打到指定的文件
                opened_file.write(log_string + '\n')
            # 现在，发送一个通知
            self.notify()
            return func(*args, **kwargs)
        return wrapped_function

    def notify(self):
        # logit只打日志，不做别的
        pass

这个实现有一个附加优势，在于比嵌套函数的方式更加整洁，而且包裹一个函数还是使用跟以前一样的语法：

PYTHON

1
2
3

@logit()
def myfunc1():
    pass

现在，我们给 logit 创建子类，来添加 email 的功能(虽然 email 这个话题不会在这里展开)。

PYTHON

class email_logit(logit):
    '''
    一个logit的实现版本，可以在函数调用时发送email给管理员
    '''
    def __init__(self, email='admin@myproject.com', *args, **kwargs):
        self.email = email
        super(email_logit, self).__init__(*args, **kwargs)

    def notify(self):
        # 发送一封email到self.email
        # 这里就不做实现了
        pass

从现在起，@email_logit 将会和 @logit 产生同样的效果，但是在打日志的基础上，还会多发送一封邮件给管理员。

Thanks for reading!

Python装饰器

Sat Mar 01 2025

2420 words · 15 minutes

tech python