Python高阶（二）
Python的装饰器的英文名叫Decorator，要对一个已有的模块做一些“修饰工作”，所谓修饰工作就是想给现有的模块加上一些小装饰（一些小功能，这些小功能可能好多模块都会用到），但又不让这个小装饰（小功能）侵入到原有的模块中的代码里去。
1. 函数在python中，函数通过def关键字、函数名和可选的参数列表定义。通过return关键字返回值。我们举例来说明如何定义和调用一个简单的函数：
In [1]: def foo(): ...: return 1 ...: foo() ...:Out[1]: 1方法体（当然多行也是一样的）是必须的，通过缩进来表示，在方法名的后面加上双括号()就能够调用函数
2.作用域在python中，函数会创建一个新的作用域。python开发者可能会说函数有自己的命名空间，差不多一个意思。这意味着在函数内部碰到一个变量的时候函数会优先在自己的命名空间里面去寻找。让我们写一个简单的函数看一下本地作用域和全局作用域有什么不同：
In [2]: string="This is a global variable"In [3]: def foo(): ...: print locals() #1 ...:In [4]: foo(){}In [5]: print globals(){ 'string': 'Thisisaglobalvariable', '__builtins__': <module'__builtin__'(built-in)>, '__package__': None, '__name__': '__main__', 'foo': <functionfooat0x000000000267E908>, '__doc__': None}内置的函数globals返回一个包含所有python解释器知道的变量名称的字典。在In [3]: #1我调用了函数 foo 把函数内部本地作用域里面的内容打印出来。我们能够看到，函数foo有自己独立的命名空间，虽然暂时命名空间里面什么都还没有。
3.变量解析规则当然这并不是说我们在函数里面就不能访问外面的全局变量。在python的作用域规则里面，创建变量一定会一定会在当前作用域里创建一个变量，但是访问或者修改变量时会先在当前作用域查找变量，没有找到匹配变量的话会依次向上在闭合的作用域里面进行查看找。所以如果我们修改函数foo的实现让它打印全局的作用域里的变量也是可以的：
In [6]: string="This is a global variable"In [7]: def foo(): ...: print string #2 ...:In [8]: foo()This is a global variable在In [7] #2处，python解释器会尝试查找变量string，当然在函数的本地作用域里面是找不到的，所以接着会去上层的作用域里面去查找。但是另一方面，假如我们在函数内部给全局变量赋值，结果却和我们想的不一样：
In [9]: string="This is a global variable"In [10]: def foo(): ...: string="Test" #3 ...: print locals() ...:In [11]: foo(){'string': 'Test'}In [12]: string #4Out[12]: 'This is a global variable'我们能够看到，全局变量能够被访问到（如果是可变数据类型(像list,dict这些)甚至能够被更改）但是赋值不行。在函数内部的In [10] #3处，我们实际上新创建了一个局部变量，隐藏全局作用域中的同名变量。我们可以通过打印出局部命名空间中的内容得出这个结论。我们也能看到在In [12] #4处打印出来的变量string的值并没有改变。
4. 变量生存周期值得注意的一个点是，变量不仅是生存在一个个的命名空间内，他们都有自己的生存周期，请看下面这个例子：
In [13]: def foo(): ...: x=1 ...:In [14]: foo()In [15]: print x #5---------------------------------------------------------------------------NameError Traceback (most recent call last)<ipython-input-15-2d264e11d975> in <module>()----> 1 print xNameError: name 'x' is not definedIn [15] #5处发生的错误不仅仅是因为作用域规则导致的（尽管这是抛出了NameError的错误的原因）它还和python以及其它很多编程语言中函数调用实现的机制有关。在这个地方这个执行时间点并没有什么有效的语法让我们能够获取变量x的值，因为它这个时候压根不存在！函数foo的命名空间随着函数调用开始而开始，结束而销毁。
5.函数参数python允许我们向函数传递参数，参数会变成本地变量存在于函数内部。
In [16]: def foo(x): ...: print locals() ...:In [17]: foo(1){'x': 1}在Python里有很多的方式来定义和传递参数，完整版可以查看 python官方文档。我们这里简略的说明一下：函数的参数可以是必须的位置参数或者是可选的命名，默认参数。
In [18]: def foo(x, y=0): #6 ...: return x - y ...:In [19]: foo(3, 1) #7Out[19]: 2In [20]: foo(3) #8Out[20]: 3In [21]: foo() #9---------------------------------------------------------------------------TypeError Traceback (most recent call last)<ipython-input-21-8a2bd47ddbdf> in <module>()----> 1 foo() #9TypeError: foo() takes at least 1 argument (0 given)In [22]: foo(y=1, x=3) #10Out[22]: 2在In [18] #6处我们定义了函数foo,它有一个位置参数x和一个命名参数y。在In [19] #7处我们能够通过常规的方式来调用函数，尽管有一个命名参数，但参数依然可以通过位置传递给函数。在调用函数的时候，对于命名参数y我们也可以完全不管就像In [20] #8处所示的一样。如果命名参数没有接收到任何值的话，python会自动使用声明的默认值也就是0。需要注意的是我们不能省略第一个位置参数x, 否则的话就会像In [21] #9处所示发生错误。目前还算简洁清晰吧， 但是接下来可能会有点令人困惑。python支持函数调用时的命名参数（个人觉得应该是命名实参）。看看In [22] #10处的函数调用，我们传递的是两个命名实参，这个时候因为有名称标识，参数传递的顺序也就不用在意了。当然相反的情况也是正确的：函数的第二个形参是y，但是我们通过位置的方式传递值给它。在In [19] #7处的函数调用foo(3,1)，我们把3传递给了第一个参数，把1传递给了第二个参数，尽管第二个参数是一个命名参数。桑不起，感觉用了好大一段才说清楚这么一个简单的概念：函数的参数可以有名称和位置。这意味着在函数的定义和调用的时候会稍稍在理解上有点儿不同。我们可以给只定义了位置参数的函数传递命名参数（实参），反之亦然！如果觉得不够可以查看官方文档
6. 嵌套函数In [24]: def outer(): ...: x=1 ...: def inner(): ...: print x #11 ...: inner() #12 ...:In [25]: outer()1Python允许创建嵌套函数。这意味着我们可以在函数里面定义函数而且现有的作用域和变量生存周期依旧适用。这个例子有一点儿复杂，但是看起来也还行。想一想在In [24] #11发生了什么：python解释器需找一个叫x的本地变量，查找失败之后会继续在上层的作用域里面寻找，这个上层的作用域定义在另外一个函数里面。对函数outer来说，变量x是一个本地变量，但是如先前提到的一样，函数inner可以访问封闭的作用域（至少可以读和修改）。在In [24] #12处，我们调用函数inner，非常重要的一点是，inner也仅仅是一个遵循python变量解析规则的变量名，python解释器会优先在outer的作用域里面对变量名inner查找匹配的变量。
7.函数是python世界里的一级类对象显而易见，在python里函数和其他东西一样都是对象。（此处应该大声歌唱）啊！包含变量的函数，你也并不是那么特殊！
In [26]: issubclass(int, object) # all objects in Python inherit from a common baseclassOut[26]: TrueIn [27]: def foo(): ...: pass ...:In [28]: foo.__class__Out[28]: functionIn [29]: issubclass(foo.__class__, object)Out[29]: True你也许从没有想过，你定义的函数居然会有属性。没办法，函数在python里面就是对象，和其他的东西一样，也许这样描述会太学院派太官方了点：在python里，函数只是一些普通的值而已和其他的值一毛一样。这就是说你可以把函数想参数一样传递给其他的函数或者说从函数了里面返回函数！如果你从来没有这么想过，那看看下面这个例子：
In [30]: def add(x, y): ...: return x + y ...:In [31]: def sub(x, y): ...: return x - y ...:In [32]: def apply(func, x, y): #13 ...: return func(x, y) #14 ...:In [33]: apply(add, 2, 1) #15Out[33]: 3In [34]: apply(sub, 2, 1)Out[34]: 1这个例子对你来说应该不会很奇怪。add和sub是非常普通的两个python函数，接受两个值，返回一个计算后的结果值。在In [32] #13处你们能看到准备接收一个函数的变量只是一个普通的变量而已，和其他变量一样。在In [32] #14处我们调用传进来的函数：“()代表着调用的操作并且调用变量包含的值。在In [33] #15处，你们也能看到传递函数并没有什么特殊的语法。” 函数的名称只是很其他变量一样的表标识符而已。你们也许看到过这样的行为：“python把频繁要用的操作变成函数作为参数进行使用，像通过传递一个函数给内置排序函数的key参数从而来自定义排序规则。那把函数当做返回值回事这样的情况呢：
In [35]: def outer(): ...: def inner(): ...: print "Inside inner" ...: return inner #16 ...:In [36]: foo=outer() #17In [37]: print foo #18<function inner at 0x0000000004239208>In [38]: foo()Inside innerIn [39]: fooOut[39]: <function __main__.inner>这个例子看起来也许会更加的奇怪。在In [35] #16处我把恰好是函数标识符的变量inner作为返回值返回出来。这并没有什么特殊的语法：”把函数inner返回出来，否则它根本不可能会被调用到。“还记得变量的生存周期吗？每次函数outer被调用的时候，函数inner都会被重新定义，如果它不被当做变量返回的话，每次执行过后它将不复存在。在In [36] #17和In [37] #18处我们捕获住返回值 - 函数inner，将它存在一个新的变量foo里。我们能够看到，当对变量foo进行求值，它确实包含函数inner，而且我们能够对他进行调用。初次看起来可能会觉得有点奇怪，但是理解起来并不困难是吧。坚持住，因为奇怪的转折马上就要来了（嘿嘿嘿嘿，我笑的并不猥琐！）
8.闭包我们先不急着定义什么是闭包，先来看看一段代码，仅仅是把上一个例子简单的调整了一下：
In [40]: def outer(): ...: x=1 ...: def inner(): ...: print x ...: return inner ...:In [41]: foo=outer()In [42]: foo.func_closureOut[42]: (<cell at 0x000000000421F498: int object at 0x0000000001D77C68>,)在上一个例子中我们了解到，inner作为一个函数被outer返回，保存在一个变量foo，并且我们能够对它进行调用foo()。不过它会正常的运行吗？我们先来看看作用域规则。所有的东西都在python的作用域规则下进行工作：“x是函数outer里的一个局部变量。当函数inner在#1处打印x的时候，python解释器会在inner内部查找相应的变量，当然会找不到，所以接着会到封闭作用域里面查找，并且会找到匹配。但是从变量的生存周期来看，该怎么理解呢？我们的变量x是函数outer的一个本地变量，这意味着只有当函数outer正在运行的时候才会存在。根据我们已知的python运行模式，我们没法在函数outer返回之后继续调用函数inner，在函数inner被调用的时候，变量x早已不复存在，可能会发生一个运行时错误。万万没想到，返回的函数inner居然能够正常工作。Python支持一个叫做函数闭包的特性，用人话来讲就是，嵌套定义在非全局作用域里面的函数能够记住它在被定义的时候它所处的封闭命名空间。这能够通过查看函数的func_closure属性得出结论，这个属性里面包含封闭作用域里面的值（只会包含被捕捉到的值，比如x，如果在outer里面还定义了其他的值，封闭作用域里面是不会有的）记住，每次函数outer被调用的时候，函数inner都会被重新定义。现在变量x的值不会变化，所以每次返回的函数inner会是同样的逻辑，假如我们稍微改动一下呢？
In [43]: def outer(x): ...: def inner(): ...: print x #18 ...: return inner ...:In [44]: print1=outer(1)In [47]: print1()2In [46]: print2=outer(2)In [47]: print2()2从这个例子中你能够看到闭包 - 被函数记住的封闭作用域 - 能够被用来创建自定义的函数，本质上来说是一个硬编码的参数。事实上我们并不是传递参数1或者2给函数inner，我们实际上是创建了能够打印各种数字的各种自定义版本。闭包单独拿出来就是一个非常强大的功能， 在某些方面，你也许会把它当做一个类似于面向对象的技术：outer像是给inner服务的构造器，x像一个私有变量。使用闭包的方式也有很多：你如果熟悉python内置排序方法的参数key，你说不定已经写过一个lambda方法在排序一个列表的列表的时候基于第二个元素而不是第一个。现在你说不定也可以写一个itemgetter方法，接收一个索引值来返回一个完美的函数，传递给排序函数的参数key。不过，我们现在不会用闭包做这么low的事(⊙o⊙)…！相反，让我们再爽一次，写一个高大上的装饰器!
9.装饰器装饰器其实就是一个闭包，把一个函数当做参数然后返回一个替代版函数。我们一步步从简到繁来瞅瞅：
In [50]: def outer(some_func): ...: def inner(): ...: print "before some_func" ...: ret=some_func() #19 ...: return ret + 1 ...: return inner ...:In [51]: def foo(): ...: return 1 ...:In [52]: decorated=outer(foo) #20In [53]: decorated()before some_funcOut[53]: 2仔细看看上面这个装饰器的例子。们定义了一个函数outer，它只有一个some_func的参数，在他里面我们定义了一个嵌套的函数inner。inner会打印一串字符串，然后调用some_func，在In [50] #19处得到它的返回值。在outer每次调用的时候some_func的值可能会不一样，但是不管some_func的之如何，我们都会调用它。最后，inner返回some_func() + 1的值 - 我们通过调用在In [52] #20处存储在变量decorated里面的函数能够看到被打印出来的字符串以及返回值2，而不是期望中调用函数foo得到的返回值1。我们可以认为变量decorated是函数foo的一个装饰版本，一个加强版本。事实上如果打算写一个有用的装饰器的话，我们可能会想愿意用装饰版本完全取代原先的函数foo，这样我们总是会得到我们的”加强版“foo。想要达到这个效果，完全不需要学习新的语法，简单地赋值给变量foo就行了：
In [54]: foo=outer(foo)In [55]: fooOut[55]: <function __main__.inner>现在，任何怎么调用都不会牵扯到原先的函数foo，都会得到新的装饰版本的foo，现在我们还是来写一个有用的装饰器。想象我们有一个库，这个库能够提供类似坐标的对象，也许它们仅仅是一些x和y的坐标对。不过可惜的是这些坐标对象不支持数学运算符，而且我们也不能对源代码进行修改，因此也就不能直接加入运算符的支持。我们将会做一系列的数学运算，所以我们想要能够对两个坐标对象进行合适加减运算的函数，这些方法很容易就能写出：
In [57]: class Coordinate(object): ...: def __init__(self, x, y): ...: self.x=x ...: self.y=y ...: def __repr__(self): ...: return "Coord: " + str(self.__dict__) ...:In [58]: def add(a, b): ...: return Coordinate(a.x + b.x, a.y + b.y) ...:In [59]: def sub(a, b): ...: return Coordinate(a.x - b.x, a.y - b.y) ...:In [60]: one=Coordinate(100, 200)In [61]: two=Coordinate(300, 200)In [62]: add(one, two)Out[62]: Coord: {'y': 400, 'x': 400}如果不巧我们的加减函数同时也需要一些边界检查的行为那该怎么办呢？搞不好你只能够对正的坐标对象进行加减操作，任何返回的值也都应该是正的坐标。所以现在的期望是这样：
In [63]: one=Coordinate(100, 200)In [64]: two=Coordinate(300, 200)In [65]: three=Coordinate(-100, -100)In [66]: sub(one, two)Out[66]: Coord: {'y': 0, 'x': -200}In [67]: add(one, three)Out[67]: Coord: {'y': 100, 'x': 0}我们期望在不更改坐标对象one, two, three的前提下one减去two的值是{x: 0, y: 0}，one加上three的值是{x: 100, y: 200}。与其给每个方法都加上参数和返回值边界检查的逻辑，我们来写一个边界检查的装饰器！
In [70]: def wrapper(func): ...: def checker(a, b): # 1 ...: if a.x < 0 or a.y < 0: ...: a=Coordinate(a.x if a.x > 0 else 0, a.y if a.y > 0 else 0) ...: if b.x < 0 or b.y < 0: ...: b=Coordinate(b.x if b.x > 0 else 0, b.y if b.y > 0 else 0) ...: ret=func(a, b) ...: if ret.x < 0 or ret.y < 0: ...: ret=Coordinate(ret.x if ret.x > 0 else 0, ret.y if ret.y > 0 else 0) ...: return ret ...: return checker ...:In [71]: add=wrapper(add)In [72]: sub=wrapper(sub)In [73]: sub(one, two)Out[73]: Coord: {'y': 0, 'x': 0}In [74]: add(one, three)Out[74]: Coord: {'y': 200, 'x': 100}这个装饰器能想先前的装饰器例子一样进行工作，返回一个经过修改的函数，但是在这个例子中，它能够对函数的输入参数和返回值做一些非常有用的检查和格式化工作，将负值的x和 y替换成0。显而易见，通过这样的方式，我们的代码变得更加简洁：将边界检查的逻辑隔离到单独的方法中，然后通过装饰器包装的方式应用到我们需要进行检查的地方。另外一种方式通过在计算方法的开始处和返回值之前调用边界检查的方法也能够达到同样的目的。但是不可置否的是，使用装饰器能够让我们以最少的代码量达到坐标边界检查的目的。事实上，如果我们是在装饰自己定义的方法的话，我们能够让装饰器应用的更加有逼格。
10.使用 @ 标识符将装饰器应用到函数Python2.4支持使用标识符@将装饰器应用在函数上，只需要在函数的定义前加上@和装饰器的名称。在上一节的例子里我们是将原本的方法用装饰后的方法代替:
In [75]: add=wrapper(add)这种方式能够在任何时候对任意方法进行包装。但是如果我们自定义一个方法，我们可以使用@进行装饰：
In [76]: @wrapper ...: def add(a, b): ...: return Coordinate(a.x + b.x, a.y + b.y) ...:需要明白的是，这样的做法和先前简单的用包装方法替代原有方法是一毛一样的， python只是加了一些语法糖让装饰的行为更加的直接明确和优雅一点。
11.*args and **kwargs我们已经完成了一个有用的装饰器，但是由于硬编码的原因它只能应用在一类具体的方法上，这类方法接收两个参数，传递给闭包捕获的函数。如果我们想实现一个能够应用在任何方法上的装饰器要怎么做呢？再比如，如果我们要实现一个能应用在任何方法上的类似于计数器的装饰器，不需要改变原有方法的任何逻辑。这意味着装饰器能够接受拥有任何签名的函数作为自己的被装饰方法，同时能够用传递给它的参数对被装饰的方法进行调用。非常巧合的是Python正好有支持这个特性的语法。可以阅读 Python Tutorial 获取更多的细节。当定义函数的时候使用了，意味着那些通过位置传递的参数将会被放在带有前缀的变量中， 所以：
In [77]: def one(*args): ...: print args #21 ...:In [78]: one()()In [79]: one(1, 2, 3)(1, 2, 3)In [80]: def two(x, y, *args): #22 ...: print x, y, args ...:In [81]: two('a', 'b', 'c')a b ('c',)第一个函数one只是简单地讲任何传递过来的位置参数全部打印出来而已，你们能够看到，在代码In [77] #21处我们只是引用了函数内的变量args, *args仅仅只是用在函数定义的时候用来表示位置参数应该存储在变量args里面。Python允许我们制定一些参数并且通过args捕获其他所有剩余的未被捕捉的位置参数，就像In [80] #22处所示的那样。操作符在函数被调用的时候也能使用。意义基本是一样的。当调用一个函数的时候，一个用标志的变量意思是变量里面的内容需要被提取出来然后当做位置参数被使用。同样的，来看个例子：
In [82]: def add(x, y): ...: return x + y ...:In [83]: lst=[1,2]In [84]: add(lst[0], lst[1]) #23Out[84]: 3In [85]: add(*lst) #24Out[85]: 3In [84] #23处的代码和In [85] #24处的代码所做的事情其实是一样的，在In [85] #24处，python为我们所做的事其实也可以手动完成。这也不是什么坏事，args要么是表示调用方法大的时候额外的参数可以从一个可迭代列表中取得，要么就是定义方法的时候标志这个方法能够接受任意的位置参数。接下来提到的会稍多更复杂一点，代表着键值对的参数字典，和所代表的意义相差无几，也很简单对不对：
In [86]: def foo(**kwargs): ...: print kwargs ...:In [87]: foo(){}In [88]: foo(x=1, y=2){'y': 2, 'x': 1}当我们定义一个函数的时候，我们能够用kwargs来表明，所有未被捕获的关键字参数都应该存储在kwargs的字典中。如前所诉，argshe kwargs并不是python语法的一部分，但在定义函数的时候，使用这样的变量名算是一个不成文的约定。和一样，我们同样可以在定义或者调用函数的时候使用*。
In [89]: dct={'x': 1, 'y': 2}In [90]: def bar(x, y): ...: return x + y ...:In [91]: bar(**dct)Out[91]: 3有了这招新的技能，我们随随便便就可以写一个能够记录下传递给函数参数的装饰器了。先来个简单地把日志输出到界面的例子：
In [92]: def logger(func): ...: def inner(*args, **kwargs): ...: print "Arguments were: %s, %s" % (args, kwargs) ...: return func(*args, **kwargs) ...: return inner ...:请注意我们的函数inner，它能够接受任意数量和类型的参数并把它们传递给被包装的方法，这让我们能够用这个装饰器来装饰任何方法。
In [93]: @logger ...: def foo1(x, y=1): ...: return x * y ...:In [94]: @logger ...: def foo2(): ...: return 2 ...:In [95]: foo1(5, 4)Arguments were: (5, 4), {}Out[95]: 20In [96]: foo1(1)Arguments were: (1,), {}Out[96]: 1In [97]: foo2()Arguments were: (), {}Out[97]: 2随便调用我们定义的哪个方法，相应的日志也会打印到输出窗口，和我们预期的一样。
来源：早起Python
作者：刘早起
大家好，我是早起。
之前的文章中提到，很多人认为理解了装饰器的概念和用法后，会觉得自己的 Python 水平有一个明显的提高。
但很多教程在一上来就会给出装饰器的定义以及基本用法，例如你一定会在很多文章中看到例如代码运行时间计时器等相关常用装饰器。
直接从应用入手这样学习当然十分有效，但不是看过就忘就是似懂非懂的状态，因为装饰器从来就不是一个单独的概念，就像数学分析中求积分一样，你可以通过公式快速算出需要求的积分，但是若明白积分是由极限定义的，之后再看积分将会是不一样的视角。
本文我将尝试说清楚为什么需要现装饰器、什么是装饰器、以及如何写一个简单的装饰器，但要彻底理解装饰器还要从函数开始说起，下面是有关函数的四个重要的概念，希望大家可以明白。
一、有关函数的四个重要概念
相信你在大多数文章中，至少也能知道例如「装饰器是装饰函数」，「在不修改函数代码的情况下增加额外功能」等核心概念，但首先要知道为什么函数能够被装饰。
例如在《流畅的Python》一书中，讲到函数的一开始就提出了一个概念，函数是一等对象
正如书中所说，在Python中一个函数既可以作为参数被传递，也能作为另一个函数的返回值，这也是函数可以被装饰的关键，在介绍装饰器之前，下面有必要通过简单的代码对这段话做一个更直观的理解。
1.1 函数中传递函数
函数中传递函数意思就是可以将函数当作变量来使用，我们来看一个简单的示例。
在下面的代码中，func1是一个普通的函数，接受两个参数a,b并返回他们的和。func2不一样的地方在于多接收了一个func参数，这个func变量需要是一个函数
def func1(a,b): print(f"函数 {func1.__name__} 正在执行") return a + b def func2(func,c,d): print(f"函数 {func2.__name__} 正在执行") return func(c,d)现在让我们来执行func1
>>> func1(1,2)函数 func1 正在执行3下面func1作为参数执行func2
>>> func2(func1,3,4)函数 func2 正在执行函数 func1 正在执行7可以看到，先执行func2，在func2接收到fun1后，再次执行func1并返回。注意这里的func1没有括号，它只不过是和a，b一样的参数被使用，理解这点后我们继续看下一个知识点。
1.2 函数中定义函数
在定义一个函数后，可以继续在函数内部定义新的函数。为了理解这点，我们来看下面简单的示例。
我们先定义了一个函数func1，并在func1中定义了func2，并在func1的内部调用了func2
def func1(): print(f"函数 {func1.__name__} 正在执行") def func2(): print(f"内部函数 {func2.__name__} 正在执行") func2()现在执行func1与func2看看会发生什么
>>> func1()函数 func1 正在执行内部函数 func2 正在执行>>> func2()------------------------------------------------Traceback (most recent call last)----> 1 func2()NameError: name 'func2' is not defined可以看到，当执行func1时，会自动执行func2，但是如果单独执行func2，则提示未定义，说明func2只能在func1中被调用！
1.3 函数返回函数
最后是一个函数可以将另一个函数作为返回值返回的简单示例，在下面的代码中，我们先定义了一个外部函数func1（接受一个参数a），之后定义了一个内部函数func2（接受一个参数b）并返回a + b，最后将func2作为func1的返回值返回
def func1(a): print(f"函数 {func1.__name__} 正在执行") def func2(b): print(f"函数 {func2.__name__} 正在执行") return a + b return func2需要注意的是，这里返回的func2没有括号，代表返回的是func2的地址！
>>> func3=func1(1)>>> func3函数 func1 正在执行<function __main__.func1.<locals>.func2(b)>>>> func3(2)函数 func2 正在执行3从上面的运行结果可以看到，当执行func1(1)后，返回的是func2的地址，并赋给func3，之后执行func3(2)才真正执行了内部函数func2！
现在我们就解决了上一小节的问题「将内部函数func2单独拿出来用」！
1.4 函数内省
函数内省是相对来说比较好理解的一个概念，在Python中的意思就是我们可以访问函数的部分属性，例如print函数，可以使用dir函数来查看其全部属性
>>> dir(print)['__call__', '__class__', '__delattr__', ··· ··· '__subclasshook__', '__text_signature__']现在可以查看其对应的属性
>>> print.__name__'print'>>> print.__call__<method-wrapper '__call__' of builtin_function_or_method object at 0x7fddb8056b80>>>> print.__doc__"print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n\nPrints the values to a stream, or to sys.stdout by default.\nOptional keyword arguments:\nfile: a file-like object (stream); defaults to the current sys.stdout.\nsep: string inserted between values, default a space.\nend: string appended after the last value, default a newline.\nflush: whether to forcibly flush the stream."函数内省了解到这个程度即可，我们会在2.3节再次提到这里的知识！
至此，我已经将接触装饰器之前必须要吃透的知识点介绍完毕，如果你觉得我讲解的不够清晰，可以查看任何其他教程或者书籍弄懂后再继续阅读。
二、初识装饰器
现在终于可以来说说装饰器了，当然绝对不是直接告诉你一个写好的装饰器，而是我们一点一点去写一个简单的装饰器。
2.1 第一个装饰器
在下面的代码中，我们先定义了一个函数first_decorator，该函数接受函数为参数（如果不理解请查看本文 1.1 节），之后在内部定义了一个名为name_wrapper的内部函数（如果不理解请查看本文 1.2 节），最后返回以name_wrapper作为返回值（如果不理解请查看本文 1.3 节）
def first_decorator(func): def name_wrapper(): print(f"被装饰的函数 {func.__name__} 即将执行") func() print(f"被装饰的函数 {func.__name__} 执行完毕") return name_wrapper这个函数的功能是，在执行被接收函数前后分别打印一段话，所以我们要再定义一个函数来测试效果
def add(): print("函数 add 正在执行 ")这个fun1没有什么好说的，打印一段话。下面需要仔细看了，我们来执行这两段代码
>>> add=first_decorator(add)>>> add()被装饰的函数 add 即将执行函数 add 正在执行 被装饰的函数 add 执行完毕正如我们预料的一样，在执行add前后都有一段提示，但是如果每次使用first_decorator功能都需要先将add传递，之后再调用，来回写好几遍，实在太麻烦了！
因此这完全有更Pythonic的写法，也就是我们常见的装饰器形式，使用语法糖@，例如上面的例子和下面的写法等价
@first_decoratordef add(): print("函数 add 正在执行 ")用@+装饰器函数名字放在需要被装饰函数的上方即可，现在直接调用add即可实现装饰器的功能！
>>> add()被装饰的函数 add 即将执行函数 add 正在执行 被装饰的函数 add 执行完毕相信看到这里，你应该明白装饰器@如何工作的，至少你在未来看到@时需要想到类似等价于add=first_decorator(add)一样的作用！
2.2 装饰器传参
上面仅是最简单的装饰器示例，在实际使用时
很自然的想法那就是加上参数呗，改起来也不难
@first_decoratordef add(x,y): print("函数 add 正在执行 ") print(f"{x} + {y} 的结果为{x+y}")让我们来测试一下
>>> add(1,2)-----------------------------------------------Traceback (most recent call last)<ipython-input-144-944f4051a32c> in <module>----> 1 add(1,2)TypeError: name_wrapper() takes 0 positional arguments but 2 were given不出意外的报错了，虽然我们给被装饰的函数加上了参数，但是在装饰器的内部函数name_wrapper()执行时并没有参数！
因此我们之前的代码可以这么改，使用*args, **kwargs也是非常常见的用法
def first_decorator(func): def name_wrapper(*args, **kwargs): print(f"被装饰的函数 {func.__name__} 即将执行") func(*args, **kwargs) print(f"被装饰的函数 {func.__name__} 执行完毕") return name_wrapper现在我们再次使用这个装饰器即可返回我们预测的结果！
@first_decoratordef add(x,y): print("函数 add 正在执行 ") print(f"{x} + {y} 的结果为 {x+y}")>>> add(1,2)被装饰的函数 add 即将执行函数 add 正在执行 1 + 2 的结果为 3被装饰的函数 add 执行完毕三、functools
本文的最后，还需要简单介绍一下在写装饰器时常用的functools模块。
还记得1.4节的函数内省相关知识吗？我们可以打印一个函数指向的内存地址或者名字等其他属性。
还是上面用到的add函数，我们都知道虽然被装饰了，但是功能上没有任何变化，依旧是计算两个数字的和，但是真的没有任何变化吗？下面让我们来观察一下
def add(x,y): print("函数 add 正在执行 ") print(f"{x} + {y} 的结果为{x+y}") >>> print(add)<function add at 0x7fddb9dd41f0>>>>print(add.__name__)add@first_decoratordef add(x,y): print("函数 add 正在执行 ") print(f"{x} + {y} 的结果为{x+y}") >>> print(add)<function first_decorator.<locals>.name_wrapper at 0x7fddb9dd4e50>>>> print(add.__name__)name_wrapper可以看到，被装饰后，虽然功能上没有变化，但是它指向的是装饰器所定义的内部函数！这并不是我们希望看到的，比如若不同函数被两个装饰器装饰时则会出现一样的函数名！
幸运的是Python中的functools库可以轻松解决这个问题，只需要加上一行简单的代码就可以搞定！
import functoolsdef first_decorator(func): @functools.wraps(func) def name_wrapper(*args, **kwargs): print(f"被装饰的函数 {func.__name__} 即将执行") func(*args, **kwargs) print(f"被装饰的函数 {func.__name__} 执行完毕") return name_wrapper@first_decoratordef add(x,y): print("函数 add 正在执行 ") print(f"{x} + {y} 的结果为{x+y}") >>> print(add)<function add at 0x7fddb9dd4e50>>>> print(add.__name__)add可以看到此时函数名等函数属性均保留下来了，事实上@functools.wraps(func)通过functools.update_wrapper()将原函数中的部分内省属性固定，只传递部分关键参数来实现这个功能，感兴趣的读者可以自行进一步研究。
至此，我想你应该明白为什么需要现装饰器、什么是装饰器、以及如何写一个简单的装饰器，当你再次看到装饰器时，脑海中浮现的概念应该不仅仅是@。有关装饰器更高级的用法，以及一些常见、好用的装饰器，我将在装饰器的第二篇文章中进行介绍！
上一篇：西游记作者是哪个朝代
下一篇：dw装修淘宝店铺
发表评论