13518219792
装饰器(decorator)是Python中的高级语法。装饰的意思就是动态扩展被装饰对象的功能。装饰器可以用于装饰函数、方法和类。
目前成都创新互联公司已为上1000家的企业提供了网站建设、域名、雅安服务器托管、成都网站托管、企业网站设计、潮阳网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。
一 嵌套函数
# 定义一个外层函数def foo(): # 定义了一个内部函数 def bar(): print("hello world")
函数bar是一个定义在foo函数内部的函数。
Python中的函数是支持嵌套的，也就是可以在一个函数内部再定义一个函数。
然后，我们还知道函数是可以当作变量的，于是我们就可以在foo函数中把定义的这个bar函数返回。就像下面这样：
# 定义一个外层函数def foo(): # 定义了一个内层函数 def bar(): print("hello world") return
barfunc = foo()func() # func -- bar，这里执行func其实就相当于执行了在foo函数内部定义的bar函数
二 闭包形态1
# 闭包形态1def foo(): name = "Andy" # 外部函数的局部变量 # 定义了一个内部函数 def bar():
print(name) # 虽然bar函数中没有定义name变量，但是它可以访问外部函数的局部变量name return barfunc =
foo()func() # func -- bar -- 除了是一个函数，还包含一个值(它外层函数的局部变量)的引用
三 闭包形态2
# 闭包形态2def foo(name): # 给一个函数传参也相当于给函数定义了一个局部变量 # 定义了一个内部函数 def bar():
print(name) # 内部函数同样可以获取到传到外部函数的变量(参数) return barfunc = foo("Andy") #
把“Andy”当成参数传入foo函数 -- 其内部定义的bar函数也能拿到这个“Andy”func() # func -- bar --
除了是一个函数，还包含一个值(它外层函数的参数)的引用
四 装饰器形态1
# 还是定义一个外层函数def foo(name): # 我接收的参数是一个函数名 # 定义了一个内部函数 def bar():
print("这是新功能。。。") # 新功能 name() # 函数名加()就相当于执行-- 我传进来原函数的函数名，这里就相当于执行了原函数
return bar# 定义一个被装饰的函数def f1(): print("hello world.") # 用foo函数装饰f1函数f1 =
foo(f1)# 不改变f1的调用方式f1() # -- 此时函数已经扩展了新功能
五 装饰器形态2
# 还是定义一个外层函数def foo(name): # 接收的参数是一个函数名 # 定义了一个内部函数 def bar():
print("这是新功能。。。") # 新功能 name() # 函数名加()就相当于执行-- 传进来原函数的函数名，这里就相当于执行了原函数
return bar# 定义一个被装饰的函数# 用foo函数装饰f1函数@foo # 使用f1 =
foo(f1)语法装饰的话稍显啰嗦，Python就提供了@语法，让装饰过程更简便def f1(): print("hello world.") #
不改变f1的调用方式f1() # -- 此时函数已经扩展了新功能。
本文目的是由浅入深地介绍python装饰器原理
装饰器(Decorators)是 Python 的一个重要部分
其功能是， 在不修改原函数(类)定义代码的情况下，增加新的功能
为了理解和实现装饰器，我们先引入2个核心操作：
在这个例子中，函数hi的形参name，默认为'world'
在函数内部，又定义了另一个函数 howdoyoudo，定义这个函数时，将形参name作为新函数的形参name2的默认值。
因此，在函数内部调用howdoyoudo()时，将以调用hi时的实参为默认值，但也可以给howdoyoudo输入其他参数。
上面的例子运行后输出结果为：
这里新定义的howdoyoudo可以称作一个“闭包”。不少关于装饰器的blog都提到了这个概念，但其实没必要给它取一个多专业的名字。我们知道闭包是 函数内的函数 就可以了
当我们进行 def 的时候，我们在做什么？
这时，hi函数，打印一个字符串，同时返回一个字符串。
但hi函数本身也是一个对象，一个可以执行的对象。执行的方式是hi()。
这里hi和hi()有本质区别，
hi 代表了这个函数对象本身
hi() 则是运行了函数，得到函数的返回值。
作为对比，可以想象以下代码
此时也是b存在，可以正常使用。
我们定义2个函数，分别实现自加1， 自乘2，
再定义一个函数double_exec，内容是将某个函数调用2次
在调用double_exec时，可以将函数作为输入传进来
输出结果就是
7
27
同样，也可以将函数作为输出
输出结果为
6
10
有了以上两个核心操作，我们可以尝试构造装饰器了。
装饰器的目的： 在不修改原函数(类)定义代码的情况下，增加新的功能
试想一下，现在有一个原函数
在不修改原函数定义代码的情况下，如果想进行函数内容的添加，可以将这个函数作为一个整体，添加到这样的包裹中：
我们定义了一个my_decorator函数，这个函数进行了一种操作：
对传入的f，添加操作(运行前后增加打印)，并把添加操作后的内容连同运行原函数的内容，一起传出
这个my_decorator，定义了一种增加前后打印内容的行为
调用my_decorator时，对这个行为进行了操作。
因此，new_function是一个在original_function上增加了前后打印行为的新函数
这个过程被可以被称作装饰。
这里已经可以发现，装饰器本身对于被装饰的函数是什么，是不需要考虑的。装饰器本身只定义了一种装饰行为，这个行为是通过装饰器内部的闭包函数()进行定义的。
运行装饰前后的函数，可以清晰看到装饰的效果
我们复现一下实际要用装饰器的情况，我们往往有一种装饰器，想应用于很多个函数，比如
此时，如果我们想给3个print函数都加上装饰器，需要这么做
实际调用的时候，就需要调用添加装饰器的函数名了
当然，也可以赋值给原函数名
这样至少不需要管理一系列装饰前后的函数。
同时，在不需要进行装饰的时候，需要把
全部删掉。
事实上，这样并不方便，尤其对于更复杂的装饰器来说
为此，python提供了一种简写方式
这个定义print1函数前的@my_decorator，相当于在定义完print1后，自动直接运行了
不论采用@my_decorator放在新函数前，还是显示地重写print1 = my_decorator(print1)，都会存在一个问题：
装饰后的函数，名字改变了(其实不止名字，一系列的索引都改变了)
输出结果为:
这个现象的原因是，装饰行为本身，是通过构造了一个新的函数（例子中是wrap_func函数）来实现装饰这个行为的，然后把这个修改后的函数赋给了原函数名。
这样，会导致我们预期的被装饰函数的一些系统变量（比如__name__）发生了变化。
对此，python提供了解决方案：
经过这个行为后，被装饰函数的系统变量问题被解决了
输出结果为
刚才的例子都比较简单，被装饰的函数是没有参数的。如果被装饰的函数有参数，只需要在定义装饰行为时（事实上，这个才更通用），增加(*args, **kwargs)描述即可
之前的描述中可以感受到，对于例子中的装饰行为(前后加打印)，函数被装饰后，本质上是调用了新的装饰函数wrap_func。
因此，如果原函数需要有输入参数传递，只需要在wrap_func（或其他任意名字的装饰函数）定义时，也增加参数输入(*args, **kwargs)，并将这些参数，原封不动地传给待装饰函数f。
这种定义装饰行为的方式更具有普遍性，忘记之前的定义方式吧
我们试一下
输出
这里需要注意的是，如果按照以下的方式定义装饰器
那么以下语句将不会执行
因为装饰后实际的函数wrap_func(虽然名字被改成了原函数，系统参数也改成了原函数)，运行到return f(*args, **kwargs) 的时候已经结束了
因为装饰器my_decorator本身也是可以输入的，因此，只需要在定义装饰器时，增加参数，并在后续函数中使用就可以了，比如
此时装饰器已经可以有输入参数了
输出
你可能发现，为什么不用简写版的方法了
因为以上代码会报错！！
究其原因，虽然
等价于
但是，
并不等价于
这本身和@语法有关，使用@my_decorator时，是系统在应用一个以单个函数作为参数的闭包函数。即，@是不能带参数的。
但是你应该发现了，之前的@wraps(f)不是带参数了吗？请仔细观察以下代码
通过一层嵌套，my_decorator_with_parma本质上是返回了一个参数仅为一个函数的函数(my_decorator)，但因为my_decorator对my_decorator_with_parma来说是一个闭包，my_decorator_with_parma是可以带参数的。（这句话真绕）
通过以上的定义，我们再来看
可以这么理解，my_decorator_with_parma(msg='yusheng')的结果是原来的my_decorator函数，同时，因为my_decorator_with_parma可以传参，参数实际上是参与了my_decorator的（因为my_decorator对my_decorator_with_parma是闭包）， my_decorator_with_parma(msg='yusheng') 全等于 一个有参数参加的my_decorator
因此，以上代码等价于有参数msg传递的
比较绕，需要理解一下，或者干脆强记这种范式：
以上范式包含函数的输入输出、装饰器的输入，可以应对大部分情况了。
实验一下：
输出
以上是一个log装饰器，利用datetime统计了函数的耗时，
并且，装饰器可以进行输出文件操作，如果给出了文件路径，则输出文件，否则就打印。
利用这个装饰器，可以灵活地进行耗时统计
不设置输出文件地址，则打印。运行结果为：
也可以输出到文件
输出结果为
同时在当前目录生成了一个test.log 文件，内容为：
以上的装饰器都是以函数形式出现的，但我们可以稍做改写，将装饰器以类的形式实现。
这个装饰器类Log 上个例子里的装饰器函数log功能是一样的，同时，这个装饰器类还可以作为基类被其他继承，进一步增加功能。
原文
装饰器其实一直是我的一个"老大难"。这个知识点就放在那，但是拖延症。。。
其实在平常写写脚本的过程中，这个知识点你可能用到不多
但在面试的时候，这可是一个高频问题。
所谓的装饰器，其实就是通过装饰器函数，来修改原函数的一些功能，使得原函数不需要修改。
这一句话理解起来可能没那么轻松，那先来看一个"傻瓜"函数。
放心，绝对不是"Hello World"！
怎么样，没骗你吧？ 哈哈，这个函数不用运行相信大家都知道输出结果： "你好，装饰器" 。
那如果我想让 hello() 函数再实现个其他功能，比如多打印一句话。
那么，可以这样"增强"一下：
运行结果：
很显然，这个"增强"没啥作用，但是可以帮助理解装饰器。
当运行最后的 hello() 函数时，调用过程是这样的：
那上述代码里的 my_decorator() 就是一个装饰器。
它改变了 hello() 的行为，但是并没有去真正的改变 hello()函数 的内部实现。
但是，python一直以"优雅"被人追捧，而上述的代码显然不够优雅。
所以，想让上述装饰器变得优雅，可以这样写：
这里的 @my_decorator 就相当于旧代码的 hello = my_decorator(hello) ， @ 符号称为语法糖。
那如果还有其他函数也需要加上类似的装饰，直接在函数的上方加上 @my_decorator 就可以，大大提高函数
的重复利用与可读性。
输出：
上面的只是一个非常简单的装饰器，但是实际场景中，很多函数都是要带有参数的，比如hello(people_name)。
其实也很简单，要什么我们就给什么呗，直接在对应装饰器的 wrapper() 上，加上对应的参数：
输出：
但是还没完，这样虽然简单，但是随之而来另一个问题：因为并不是所有函数参数都是一样的，
当其他要使用装饰器的函数参数不止这个一个肿么办？比如：
没关系，在python里， *args 和 **kwargs 表示接受任意数量和类型的参数，所以我们可以这样
写装饰器里的 wrapper() 函数：
同时运行下 hello("老王") ，和 hello3("张三", "李四") ，看结果：
上面2种，装饰器都是接收外来的参数，其实装饰器还可以接收自己的参数。
比如，我加个参数来控制下装饰器中打印信息的次数：
注意，这里 count 装饰函数中的2个 return .
运行下，应该会出现3次：
现在多做一步 探索 ，我们来打印下下面例子中的hello()函数的元信息：
输出：
这说明了，它不再是以前的那个 hello() 函数，而是被 wrapper() 函数取代了。
如果我们需要用到元函数信息，那怎么保留它呢？这时候可以用内置装饰器 @functools.wrap 。
运行下：
好记性不如烂笔头，写一下理解一下会好很多。
下面还分享类的装饰器，以及装饰器所用场景。
装饰器是通过装饰器函数修改原函数的一些功能而不需要修改原函数，在很多场景可以用到它，比如① 执行某个测试用例之前，判断是否需要登录或者执行某些特定操作；② 统计某个函数的执行时间；③ 判断输入合法性等。合理使用装饰器可以极大地提高程序的可读性以及运行效率。本文将介绍Python装饰器的使用方法。
python装饰器可以定义如下：
输出：
python解释器将test_decorator函数作为参数传递给my_decorator函数，并指向了内部函数 wrapper()，内部函数 wrapper() 又会调用原函数 test_decorator()，所以decorator()的执行会先打印'this is wrapper'，然后打印'hello world'， test_decorator()执行完成后，打印 'bye' ，*args和**kwargs，表示接受任意数量和类型的参数。
装饰器 my_decorator() 把真正需要执行的函数 test_decorator() 包裹在其中，并且改变了它的行为，但是原函数 test_decorator() 不变。
一般使用如下形式使用装饰器：
@my_decorator就相当于 decorator = my_decorator(test_decorator) 语句。
内置装饰器@functools.wrap可用于保留原函数的元信息（将原函数的元信息，拷贝到对应的装饰器函数里）。先来看看没有使用functools的情况：
输出：
从上面的输出可以看出test_decorator() 函数被装饰以后元信息被wrapper() 函数取代了，可以使用@functools.wrap装饰器保留原函数的元信息：
输出：
装饰器可以接受自定义参数。比如定义一个参数来设置装饰器内部函数的执行次数：
输出：
Python 支持多个装饰器嵌套：
装饰的过程：
顺序从里到外：
test_decorator('hello world') 执行顺序和装饰的过程相反。
输出：
类也可以作为装饰器，类装饰器主要依赖__call__()方法，是python中所有能被调用的对象具有的内置方法（python魔术方法），每当调用一个类的实例时，__call__()就会被执行一次。
下面的类装饰器实现统计函数执行次数：
输出：
下面介绍两种装饰器使用场景
统计函数执行所花费的时间
输出：
在使用某些web服务时，需要先判断用户是否登录，如果没有登录就跳转到登录页面或者提示用户登录：
--THE END--
1、 lru_cache
这个装饰器来自functools模块。该模块包含在标准库中，非常易于使用。它还包含比这个装饰器更酷的功能，但这个装饰器是非常受人喜欢的。此装饰器可用于使用缓存加速函数的连续运行。当然，这应该在使用时记住一些关于缓存的注意事项，但在通用使用情况下，大多数时候这个装饰器都是值得使用的。
2、JIT
JIT是即时编译的缩写。通常每当我们在Python中运行一些代码时，发生的第一件事就是编译。这种编译会产生一些开销，因为类型被分配了内存，并存储为未分配但已命名的别名，使用即时编译，我们在执行时才进行编译。
在很多方面，我们可以将其视为类似于并行计算的东西，其中Python解释器同时处理两件事以节省时间。Numba JTI编译器因将这一概念提到Python中而闻名，可以非常轻松地调用此装饰器，并立即提高代码的性能。Numba包提供了JIT装饰器，它使运行更密集的软件变得更加容易，而不必进入C。
3、do_twice
do_twice装饰器的功能与它的名字差不多。此装饰器可用于通过一次调用运行两次函数，对调试特别有用。它可以用于测量两个不同迭代的功能。
4、count_calls
count_calls装饰器可用于提供有关函数在软件中使用多少次的信息。与do_twice一样，对调试也特别有用。
5、dataclass
为了节省编写类的时间，推荐使用dataclass装饰器。这个装饰器可用于快速编写类中常见的标准方法，这些方法通常会在我们编写的类中找到。
6、singleton
singleton是一个单例装饰器。通常，单例装饰器是由用户自己编写的，实际上并不是导入的。
7、use_unit
在科学计算中经常派上用场的一种装饰器是use_unit装饰器。此装饰器可用于更改返回结果的表示单位。这对于那些不想在数据中添加度量单位但仍希望人们知道这些单位是什么的人很有用。这个装饰器可不是在任何模块中真正有用，但它是非常常见的，对科学应用程序非常有用。
装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能
