装饰器

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，提高了代码的复用性。装饰器是一个函数，它接收一个函数返回另一个函数。装饰器主要有以下功能：

• 引入日志。
• 函数执行时间统计。
• 执行函数前预备处理。
• 执行函数后的清理功能。
• 权限校验等场景。
• 缓存

装饰器其实就是一个以函数作为参数并返回一个替换函数的可执行函数。在不改动原函数代码的情 况下，为其增加新的功能。

例1：

import time
import fimctools
def add():
    printf('调用(add)函数时间:％s' ％time.strftime('%Y-%m-%d %H:%M:%S'))
#装饰器
def log(func):
    def wrapper():
        #__name__可以获得函数名称
        printf('调用％s 函数时间:%s' %(func.__name__,time.strftime('%Y-%m-%d %H:%M:%S'))) 
        func()
    return wrapper

add_wrap = log(add)
add_wrap()

运行结果：

调用 add 函数时间:2019-01-18 13:33:15
调用(add)函数时间:2019-01-18 13:33:15

例2：

#装饰器
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()

#装饰器装饰方法 
a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
#调用
a_function_requiring_decoration()

运行结果：

#I am the function which needs some decoration to remove my foul smell

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

例2 @的方式调用方法：

@a_new_decorator
def a_function_requiring_decoration():
    print("I am the function which needs some decoration to remove my foul smell")
a_function_requiring_decoration()
#但是查看函数名字却不对
a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
print(a_function_requiring_decoration.__name__)

运行结果：

#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()
#但是查看函数名字却不对
# Output: wrapTheFunction

@wraps(a_func)

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

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

模板：

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

授权(Authorization)

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

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)

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

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

带参数的装饰器

来想想这个问题，难道@wraps不也是个装饰器吗？但是，它接收一个参数，就像任何普通的函数能做的那样。那么，为什么我们不也那样做呢？ 这是因为，当你使用@my_decorator语法时，你是在应用一个以单个函数作为参数的一个包裹函数。记住，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 的文件出现了，里面的内容就是上面的字符串

装饰器类

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

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

class logit(object):

    _logfile = 'out.log'

    def __init__(self, func):
        self.func = func

    def __call__(self, *args):
        log_string = self.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 base func
        return self.func(*args)



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

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

logit._logfile = 'out2.log' # 如果需要修改log文件参数
@logit
def myfunc1():
    pass

myfunc1()
# 输出: myfunc1 was called

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

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 产生同样的效果，但是在打日志的基础上，还会多发送一封邮件给管理员。

当然可以！Python的装饰器（decorator）是一个用于修改函数或类行为的函数。它可以在不改变原始函数或类代码的情况下，为它们增加功能。

装饰器的基本概念

• 本质：装饰器是一个函数，它接受另一个函数（或类）作为参数，并返回一个新函数（或类）。
• 用途：常用于代码复用、权限验证、日志记录、性能测试等。

---

一个简单的例子

# 一个简单的装饰器
def my_decorator(func):
    def wrapper():
        print("装饰器：在调用原函数之前执行")
        func()
        print("装饰器：在调用原函数之后执行")
    return wrapper

# 用装饰器装饰函数
@my_decorator
def say_hello():
    print("Hello, Python!")

# 调用被装饰的函数
say_hello()

输出：

装饰器：在调用原函数之前执行
Hello, Python!
装饰器：在调用原函数之后执行

---

工作原理

1. @my_decorator 是装饰器语法糖，它等价于：

   say_hello = my_decorator(say_hello)

2. my_decorator 返回一个 wrapper 函数，它取代了原来的 say_hello。

---

装饰器的常见应用

1. 记录函数调用日志

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"调用了函数 {func.__name__}，参数：{args}, {kwargs}")
        return func(*args, **kwargs)
    return wrapper

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

print(add(3, 5))

2. 权限验证

def auth_decorator(func):
    def wrapper(user):
        if user != "admin":
            print("权限不足！")
            return
        return func(user)
    return wrapper

@auth_decorator
def access_dashboard(user):
    print(f"欢迎 {user}，进入后台管理系统")

access_dashboard("guest")  # 输出：权限不足！
access_dashboard("admin")  # 输出：欢迎 admin，进入后台管理系统

3. 计算函数执行时间

import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"函数 {func.__name__} 执行时间：{end - start:.2f} 秒")
        return result
    return wrapper

@timer_decorator
def slow_function():
    time.sleep(2)
    print("执行完成")

slow_function()

---

多装饰器叠加

当一个函数有多个装饰器时，装饰器会从下到上依次执行：

def decorator1(func):
    def wrapper():
        print("装饰器1")
        func()
    return wrapper

def decorator2(func):
    def wrapper():
        print("装饰器2")
        func()
    return wrapper

@decorator1
@decorator2
def my_function():
    print("执行原函数")

my_function()

输出：

装饰器1
装饰器2
执行原函数

---

小结

1. 装饰器是增强函数功能的简洁方法。
2. 通过 *args 和 **kwargs 支持任意类型的函数参数。
3. 常用于日志、性能监控和代码复用场景。