弄清楚装饰器前要理解三个东西：

函数对象、函数嵌套、函数构成闭包。

学习内容：函数对象、函数嵌套、闭包、装饰器

函数对象好说，python编程语言属于动态语言，python中一切皆对象，所以函数也是对象。

函数对象用函数名称表示（仅名称，没有括号，也没有参数）。

例如，定义了一个求和函数add，那么此处的add就是个函数对象。

def add(username, a, b):
    print(f"{
   a}+{
   b}={
   a + b}")
    return a + b

函数嵌套或者嵌套函数，就是定义函数时，函数体内还有定义函数的操作。（def 和 def的嵌套）

例如：定义函数check_admin时，还def 另一个函数。定义一个函数的过程中定义另一个函数。

def check_admin():
    def wrapper():
        ...
        return
    return

闭包实际也特殊嵌套函数。

嵌套函数满足条件是：外层函数的返回值为内层 函数对象 （也是前面解释的函数对象）。也就是闭包定义后，创建后还可再调用。举个例子

比如：闭包实现一元二次方程运算

# 定义闭包：定义特殊嵌套函数
def func(a, b, c):
    def quadratic_equation(x):
        return a*x**2 + b*x + c
    return quadratic_equation

这里是：定义了外层函数 func ，返回return 内层函数对象quadratic_equation
测试+调试：

# 调用闭包，返回新函数，QE引用了quadratic_equation函数对向
QE = func(5, 5, 5)
# 调用新函数
val = QE(2)

有人可能会疑惑：形参 a,b,c 的值是不是传给 quadratic_equation 函数里的方程式 a*x**2 + b*x + c 了,它们的作用域都不一样？是的，传了，不要怀疑。内层函数会优先找自己作用域内的，没有会向上一层找，一直找不到才报错。反过来，内层函数的变量只在内函数内有用。

装饰器：理解了函数对象，函数嵌套，和闭包后，装饰器就是在闭包的基础上再特殊一点。形式上呢，装饰器就是要闭包嵌套的两层函数的外层函数的参数是 函数对象 。就是 参数是函数对象的闭包 ，这是形状结构。看完这个例子，再总结概念。

例如：一个用于判断用户的装饰器

def check_admin(func):
    def wrapper(*args, **kwargs):
        if kwargs.get('username') != 'admin' and 'admin' not in args: 
            raise Exception("This User do not have permission")
        return func(*args, **kwargs)

    return wrapper

这是一个装饰器，被装饰的对象是即将输入的参数–func一个函数对象（方法或操作）。

装饰什么操作就在谁头上加装饰（戴头饰 @check_admin ）。

比如：我要在压栈操作前加装饰。就在定义push的时候加头饰，那么 push 就会被当作参数传给 func 。

@check_admin
def push(username, item):
	items = []
	items.append(item)

可以想象一下，如果在操作数据库或者个人数据的时候，每个方法的使用都要判断你有没有权限，不然不让你动数据，如果，增删改等操作一多，你是不是要写好多重复代码？所以在这个时候，我们装饰器就非常有用，把判断权限这个动作做成头饰，不，装饰器，发给每个方法，往动作前面一套，就节省好多代码。再调用方法做数据操作的时候，装饰过的函数自动就帮你把用户权限校验了。多好！

将用户权限的例子写完整：

# 装饰器
def check_admin(func):
    def wrapper(*args, **kwargs):
        if kwargs.get('username') != 'admin' and 'admin' not in args: 
            raise Exception("This User do not have permission")
        return func(*args, **kwargs)

    return wrapper


class Stack:
    def __init__(self):
        self.item = []

    @check_admin
    def push(self, username, item):
        self.item.append(item)

    @check_admin
    def pop(self, username):
        if not self.item:
            raise Exception("no element in stack")
        return self.item.pop()

测试+调试，看看结果变化

当用户username='admin’的时候，压栈成功。

当username不是admin的时候，raise异常，就不允许操作数据了。

出栈操作也同样套上装饰器审判以下权限，再操作数据。如果有其他修改，更新操作，也可以套上装饰器。非常方便。

嗯。。。

简洁明了的装饰器就这些内容，可怜我学了N次，都没明白。n>10

原来是有原因的。

首先，装饰器结构记不住，用途不清楚是主因。

然后，函数对象 和 闭包 两个概念理解不透彻，

最后，少见多怪，不求甚解。

怎么学不明白？

总结：

「装饰器」为 Python 高级语言特性中的重要部分，是修改函数的一种超级便捷的方式，适当使用能够有效提高代码的可读性和可维护性，非常的便利灵活。

「装饰器」本质上就是一个函数，这个函数的特点是可以接受其它的函数当作它的参数，并将其改造成一个新的函数。

学习进阶：带参数的装饰器

1. 常见的装饰器：@classmethod 类方法装饰器：定义类方法中加上这个装饰器，就变成类的方法，而不再是实例方法。也就是说，定义的时候加上装饰器，其第一个参数 cls 引用的是这个类对象，即将类本身作为作为引用对象传到这个方法里。不受实例控制。@staticmethod 静态方法装饰器：定义类方法中加上这个装饰器，就变成类的静态方法。也就是说，定义这个方法的时候没有self参数，那么调用这个方法的时候可以通过类调用，也可以通过实例来调用。
2. 装饰器能否传参？

答案是：能。比如我想知道是哪一个方法加了我这个装饰器。例如：在装饰器外加一层传参函数，套路一层。

# 含参数的装饰器
def new_tips(argv):
    def tips(func):
        def wrapper(*args):
            print("装饰内容：{}".format(argv))
            return func(*args)

        return wrapper

    return tips


@new_tips("add")
def add(a, b):
    print(f"{
   a}+{
   b}={
   a + b}")
    return a + b


@new_tips("sub")
def sub(a, b):
    print(f"{
   a}-{
   b}={
   a - b}")
    return a - b

测试+调试

add1 = add(3, 5)
sub1 = sub(8, 2)

其实： @new_tips("add") 中的 new_tips("add") 相当于tips，因为一执行 new_tips("add") 就返回tips。 @new_tips("add")等价于@tips ，就变成我们熟悉的装饰器了。

学习产出：学了这么多，那么能回答面试笔试中遇到的问题了么？

例如：

1、 什么是闭包？

2、 装饰器又是什么？装饰器有什么作用？

3、 你用过装饰器吗？请写一个装饰器的例子？

原文链接：https://blog.csdn.net/beauthy/article/details/121537007