python中闭包和装饰器的理解（关于python中闭包和装饰器解释最好的文章）。

转载：http://python.jobbole.com/81683/

呵呵！做为一名教python的老师，我发现学生们基本上一开始很难搞定python的装饰器，也许由于装饰器确实很难懂。搞定装饰器须要你了解一些函数式编程的概念，固然还有理解在python中定义和调用函数相关语法的一些特色。

我无法让装饰器变得简单，可是经过一步步的剖析，我也许可以让你在理解装饰器的时候更自信一点。由于装饰器很复杂，这篇文章将会很长（本身都说很长，还敢这么多废话blablabla前戏就不继续翻译直接省略了)

1. 函数

在python中，函数经过def关键字、函数名和可选的参数列表定义。经过return关键字返回值。咱们举例来讲明如何定义和调用一个简单的函数：

def foo():
     return 1
foo()
1

方法体（固然多行也是同样的）是必须的，经过缩进来表示，在方法名的后面加上双括号()就可以调用函数

2. 做用域

在python中，函数会建立一个新的做用域。python开发者可能会说函数有本身的命名空间，差很少一个意思。这意味着在函数内部碰到一个变量的时候函数会优先在本身的命名空间里面去寻找。让咱们写一个简单的函数看一下 本地做用域 和 全局做用域有什么不一样：

1 a_string = "This is a global variable"
2 def foo():
3      print locals()
4 print globals() # doctest: +ELLIPSIS
5 {, 'a_string': 'This is a global variable'}
6 foo() # 2
7 {}

内置的函数globals返回一个包含全部python解释器知道的变量名称的字典（为了干净和洗的白白的，我省略了python自行建立的一些变量）。在#2我调用了函数 foo 把函数内部本地做用域里面的内容打印出来。咱们可以看到，函数foo有本身独立的命名空间，虽然暂时命名空间里面什么都尚未。

3. 变量解析规则

固然这并非说咱们在函数里面就不能访问外面的全局变量。在python的做用域规则里面，建立变量必定会必定会在当前做用域里建立一个变量，可是访问或者修改变量时会先在当前做用域查找变量，没有找到匹配变量的话会依次向上在闭合的做用域里面进行查看找。因此若是咱们修改函数foo的实现让它打印全局的做用域里的变量也是能够的：

1 a_string = "This is a global variable"
2 def foo():
3      print a_string # 1
4 foo()
5 This is a global variable

在#1处，python解释器会尝试查找变量a_string，固然在函数的本地做用域里面是找不到的，因此接着会去上层的做用域里面去查找。
可是另外一方面，假如咱们在函数内部给全局变量赋值，结果却和咱们想的不同：

1 a_string = "This is a global variable"
2 def foo():
3      a_string = "test" # 1
4      print locals()
5 foo()
6 {'a_string': 'test'}
7 a_string # 2
8 'This is a global variable'

咱们可以看到，全局变量可以被访问到（若是是可变数据类型(像list,dict这些)甚至可以被更改）可是赋值不行。在函数内部的#1处，咱们实际上新建立了一个局部变量，隐藏全局做用域中的同名变量。咱们能够经过打印出局部命名空间中的内容得出这个结论。咱们也能看到在#2处打印出来的变量a_string的值并无改变。

4. 变量生存周期

值得注意的一个点是，变量不只是生存在一个个的命名空间内，他们都有本身的生存周期，请看下面这个例子：

1 def foo():
2      x = 1
3 foo()
4 print x # 1
5 Traceback (most recent call last):
6 
7 NameError: name 'x' is not defined

#1处发生的错误不只仅是由于做用域规则致使的（尽管这是抛出了NameError的错误的缘由）它还和python以及其它不少编程语言中函数调用实现的机制有关。在这个地方这个执行时间点并无什么有效的语法让咱们可以获取变量x的值，由于它这个时候压根不存在！函数foo的命名空间随着函数调用开始而开始，结束而销毁。

5. 函数参数

python容许咱们向函数传递参数，参数会变成本地变量存在于函数内部

1 def foo(x):
2      print locals()
3 foo(1)
4 {'x': 1}

在Python里有不少的方式来定义和传递参数，完整版能够查看 python官方文档。咱们这里简略的说明一下：函数的参数能够是必须的位置参数或者是可选的命名，默认参数。

 1 def foo(x, y=0): # 1
 2      return x - y
 3 foo(3, 1) # 2
 4 2
 5 foo(3) # 3
 6 3
 7 foo() # 4
 8 Traceback (most recent call last):
 9 
10 TypeError: foo() takes at least 1 argument (0 given)
11 foo(y=1, x=3) # 5
12 2

在#1处咱们定义了函数foo,它有一个位置参数x和一个命名参数y。在#2处咱们可以经过常规的方式来调用函数，尽管有一个命名参数，但参数依然能够经过位置传递给函数。在调用函数的时候，对于命名参数y咱们也能够彻底无论就像#3处所示的同样。若是命名参数没有接收到任何值的话，python会自动使用声明的默认值也就是0。须要注意的是咱们不能省略第一个位置参数x, 不然的话就会像#5处所示发生错误。

目前还算简洁清晰吧， 可是接下来可能会有点使人困惑。python支持函数调用时的命名参数（我的以为应该是命名实参）。看看#5处的函数调用，咱们传递的是两个命名实参，这个时候由于有名称标识，参数传递的顺序也就不用在乎了。

固然相反的状况也是正确的：函数的第二个形参是y，可是咱们经过位置的方式传递值给它。在#2处的函数调用foo(3,1)，咱们把3传递给了第一个参数，把1传递给了第二个参数，尽管第二个参数是一个命名参数。

桑不起，感受用了好大一段才说清楚这么一个简单的概念：函数的参数能够有名称和位置。这意味着在函数的定义和调用的时候会稍稍在理解上有点儿不一样。咱们能够给只定义了位置参数的函数传递命名参数（实参），反之亦然！若是以为不够能够查看官方文档

6. 嵌套函数

Python容许建立嵌套函数。这意味着咱们能够在函数里面定义函数并且现有的做用域和变量生存周期依旧适用。

1 def outer():
2      x = 1
3      def inner():
4          print x # 1
5      inner() # 2
6 
7 outer()
8 1

这个例子有一点儿复杂，可是看起来也还行。想想在#1发生了什么：python解释器需找一个叫x的本地变量，查找失败以后会继续在上层的做用域里面寻找，这个上层的做用域定义在另一个函数里面。对函数outer来讲，变量x是一个本地变量，可是如先前提到的同样，函数inner能够访问封闭的做用域（至少能够读和修改）。在#2处，咱们调用函数inner，很是重要的一点是，inner也仅仅是一个遵循python变量解析规则的变量名，python解释器会优先在outer的做用域里面对变量名inner查找匹配的变量.

7. 函数是python世界里的一级类对象

显而易见，在python里函数和其余东西同样都是对象。（此处应该大声歌唱）啊！包含变量的函数，你也并非那么特殊！

1 issubclass(int, object) # all objects in Python inherit from a common baseclass
2 True
3 def foo():
4      pass
5 foo.__class__ # 1
6 <type 'function'>
7 issubclass(foo.__class__, object)
8 True

你也许从没有想过，你定义的函数竟然会有属性。没办法，函数在python里面就是对象，和其余的东西同样，也许这样描述会太学院派太官方了点：在python里，函数只是一些普通的值而已和其余的值一毛同样。这就是说你尅一把函数想参数同样传递给其余的函数或者说从函数了里面返回函数！若是你历来没有这么想过，那看看下面这个例子：

 1 def add(x, y):
 2      return x + y
 3 def sub(x, y):
 4      return x - y
 5 def apply(func, x, y): # 1
 6      return func(x, y) # 2
 7 apply(add, 2, 1) # 3
 8 3
 9 apply(sub, 2, 1)
10 1

这个例子对你来讲应该不会很奇怪。add和sub是很是普通的两个python函数，接受两个值，返回一个计算后的结果值。在#1处大家能看到准备接收一个函数的变量只是一个普通的变量而已，和其余变量同样。在#2处咱们调用传进来的函数：“()表明着调用的操做而且调用变量包含的值。在#3处，大家也能看到传递函数并无什么特殊的语法。” 函数的名称只是很其余变量同样的表标识符而已。

大家也许看到过这样的行为：“python把频繁要用的操做变成函数做为参数进行使用，像经过传递一个函数给内置排序函数的key参数从而来自定义排序规则。那把函数当作返回值回事这样的状况呢：

 1 def outer():
 2      def inner():
 3          print "Inside inner"
 4      return inner # 1
 5 
 6 foo = outer() #2
 7 foo # doctest:+ELLIPSIS
 8 <function inner at 0x>
 9 foo()
10 Inside inner

这个例子看起来也许会更加的奇怪。在#1处我把刚好是函数标识符的变量inner做为返回值返回出来。这并无什么特殊的语法：”把函数inner返回出来，不然它根本不可能会被调用到。“还记得变量的生存周期吗？每次函数outer被调用的时候，函数inner都会被从新定义，若是它不被当作变量返回的话，每次执行事后它将不复存在。

在#2处咱们捕获住返回值 – 函数inner，将它存在一个新的变量foo里。咱们可以看到，当对变量foo进行求值，它确实包含函数inner，并且咱们可以对他进行调用。初次看起来可能会以为有点奇怪，可是理解起来并不困难是吧。坚持住，由于奇怪的转折立刻就要来了（嘿嘿嘿嘿，我笑的并不猥琐！）

8. 闭包

咱们先不急着定义什么是闭包，先来看看一段代码，仅仅是把上一个例子简单的调整了一下：

1 def outer():
2      x = 1
3      def inner():
4          print x # 1
5      return inner
6 foo = outer()
7 foo.func_closure # doctest: +ELLIPSIS
8 (<cell at 0x: int object at 0x>,)

在上一个例子中咱们了解到，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会是一样的逻辑，假如咱们稍微改动一下呢？

 1 def outer(x):
 2      def inner():
 3          print x # 1
 4      return inner
 5 print1 = outer(1)
 6 print2 = outer(2)
 7 print1()
 8 1
 9 print2()
10 2

从这个例子中你可以看到闭包 – 被函数记住的封闭做用域 – 可以被用来建立自定义的函数，本质上来讲是一个硬编码的参数。事实上咱们并非传递参数1或者2给函数inner，咱们其实是建立了可以打印各类数字的各类自定义版本。

闭包单独拿出来就是一个很是强大的功能， 在某些方面，你也许会把它当作一个相似于面向对象的技术：outer像是给inner服务的构造器，x像一个私有变量。使用闭包的方式也有不少：你若是熟悉python内置排序方法的参数key，你说不定已经写过一个lambda方法在排序一个列表的列表的时候基于第二个元素而不是第一个。如今你说不定也能够写一个itemgetter方法，接收一个索引值来返回一个完美的函数，传递给排序函数的参数key。

不过，咱们如今不会用闭包作这么low的事(⊙o⊙)…！相反，让咱们再爽一次，写一个高大上的装饰器!

 

9. 装饰器

装饰器其实就是一个闭包，把一个函数当作参数而后返回一个替代版函数。咱们一步步从简到繁来瞅瞅：

 1 def outer(some_func):
 2      def inner():
 3          print "before some_func"
 4          ret = some_func() # 1
 5          return ret + 1
 6      return inner
 7 def foo():
 8      return 1
 9 decorated = outer(foo) # 2
10 decorated()
11 before some_func
12 2

仔细看看上面这个装饰器的例子。们定义了一个函数outer，它只有一个some_func的参数，在他里面咱们定义了一个嵌套的函数inner。inner会打印一串字符串，而后调用some_func，在#1处获得它的返回值。在outer每次调用的时候some_func的值可能会不同，可是无论some_func的之如何，咱们都会调用它。最后，inner返回some_func() + 1的值 – 咱们经过调用在#2处存储在变量decorated里面的函数可以看到被打印出来的字符串以及返回值2，而不是指望中调用函数foo获得的返回值1。

咱们能够认为变量decorated是函数foo的一个装饰版本，一个增强版本。事实上若是打算写一个有用的装饰器的话，咱们可能会想愿意用装饰版本彻底取代原先的函数foo，这样咱们老是会获得咱们的”增强版“foo。想要达到这个效果，彻底不须要学习新的语法，简单地赋值给变量foo就好了：

1 foo = outer(foo)
2 foo # doctest: +ELLIPSIS
3 <function inner at 0x>

如今，任何怎么调用都不会牵扯到原先的函数foo，都会获得新的装饰版本的foo，如今咱们仍是来写一个有用的装饰器。

想象咱们有一个库，这个库可以提供相似坐标的对象，也许它们仅仅是一些x和y的坐标对。不过惋惜的是这些坐标对象不支持数学运算符，并且咱们也不能对源代码进行修改，所以也就不能直接加入运算符的支持。咱们将会作一系列的数学运算，因此咱们想要可以对两个坐标对象进行合适加减运算的函数，这些方法很容易就能写出：

 1 class Coordinate(object):
 2      def __init__(self, x, y):
 3          self.x = x
 4          self.y = y
 5      def __repr__(self):
 6          return "Coord: " + str(self.__dict__)
 7 def add(a, b):
 8      return Coordinate(a.x + b.x, a.y + b.y)
 9 def sub(a, b):
10      return Coordinate(a.x - b.x, a.y - b.y)
11 one = Coordinate(100, 200)
12 two = Coordinate(300, 200)
13 add(one, two)
14 Coord: {'y': 400, 'x': 400}

若是不巧咱们的加减函数同时也须要一些边界检查的行为那该怎么办呢？搞很差你只可以对正的坐标对象进行加减操做，任何返回的值也都应该是正的坐标。因此如今的指望是这样：

1 one = Coordinate(100, 200)
2 two = Coordinate(300, 200)
3 three = Coordinate(-100, -100)
4 sub(one, two)
5 Coord: {'y': 0, 'x': -200}
6 add(one, three)
7 Coord: {'y': 100, 'x': 0}

咱们指望在不更改坐标对象one, two, three的前提下one减去two的值是{x: 0, y: 0}，one加上three的值是{x: 100, y: 200}。与其给每一个方法都加上参数和返回值边界检查的逻辑，咱们来写一个边界检查的装饰器！

 1 def wrapper(func):
 2      def checker(a, b): # 1
 3          if a.x < 0 or a.y < 0:
 4              a = Coordinate(a.x if a.x > 0 else 0, a.y if a.y > 0 else 0)
 5          if b.x < 0 or b.y < 0:
 6              b = Coordinate(b.x if b.x > 0 else 0, b.y if b.y > 0 else 0)
 7          ret = func(a, b)
 8          if ret.x < 0 or ret.y < 0:
 9              ret = Coordinate(ret.x if ret.x > 0 else 0, ret.y if ret.y > 0 else 0)
10          return ret
11      return checker
12 add = wrapper(add)
13 sub = wrapper(sub)
14 sub(one, two)
15 Coord: {'y': 0, 'x': 0}
16 add(one, three)
17 Coord: {'y': 200, 'x': 100}

这个装饰器能想先前的装饰器例子同样进行工做，返回一个通过修改的函数，可是在这个例子中，它可以对函数的输入参数和返回值作一些很是有用的检查和格式化工做，将负值的x和 y替换成0。

显而易见，经过这样的方式，咱们的代码变得更加简洁：将边界检查的逻辑隔离到单独的方法中，而后经过装饰器包装的方式应用到咱们须要进行检查的地方。另一种方式经过在计算方法的开始处和返回值以前调用边界检查的方法也可以达到一样的目的。可是不可置否的是，使用装饰器可以让咱们以最少的代码量达到坐标边界检查的目的。事实上，若是咱们是在装饰本身定义的方法的话，咱们可以让装饰器应用的更加有逼格。

10. 使用 @ 标识符将装饰器应用到函数

Python2.4支持使用标识符@将装饰器应用在函数上，只须要在函数的定义前加上@和装饰器的名称。在上一节的例子里咱们是将本来的方法用装饰后的方法代替:

1 add = wrapper(add)

这种方式可以在任什么时候候对任意方法进行包装。可是若是咱们自定义一个方法，咱们可使用@进行装饰：

1 @wrapper
2  def add(a, b):
3      return Coordinate(a.x + b.x, a.y + b.y)

须要明白的是，这样的作法和先前简单的用包装方法替代原有方法是一毛同样的， python只是加了一些语法糖让装饰的行为更加的直接明确和优雅一点。

11. *args and **kwargs

咱们已经完成了一个有用的装饰器，可是因为硬编码的缘由它只能应用在一类具体的方法上，这类方法接收两个参数，传递给闭包捕获的函数。若是咱们想实现一个可以应用在任何方法上的装饰器要怎么作呢？再好比，若是咱们要实现一个能应用在任何方法上的相似于计数器的装饰器，不须要改变原有方法的任何逻辑。这意味着装饰器可以接受拥有任何签名的函数做为本身的被装饰方法，同时可以用传递给它的参数对被装饰的方法进行调用。

很是巧合的是Python正好有支持这个特性的语法。能够阅读 Python Tutorial 获取更多的细节。当定义函数的时候使用了*，意味着那些经过位置传递的参数将会被放在带有*前缀的变量中， 因此：

 1 def one(*args):
 2      print args # 1
 3 one()
 4 ()
 5 one(1, 2, 3)
 6 (1, 2, 3)
 7 def two(x, y, *args): # 2
 8      print x, y, args
 9 two('a', 'b', 'c')
10 a b ('c',)

第一个函数one只是简单地讲任何传递过来的位置参数所有打印出来而已，大家可以看到，在代码#1处咱们只是引用了函数内的变量args, *args仅仅只是用在函数定义的时候用来表示位置参数应该存储在变量args里面。Python容许咱们制定一些参数而且经过args捕获其余全部剩余的未被捕捉的位置参数，就像#2处所示的那样。
*操做符在函数被调用的时候也能使用。意义基本是同样的。当调用一个函数的时候，一个用*标志的变量意思是变量里面的内容须要被提取出来而后当作位置参数被使用。一样的，来看个例子：

1 def add(x, y):
2      return x + y
3 lst = [1,2]
4 add(lst[0], lst[1]) # 1
5 3
6 add(*lst) # 2
7 3

#1处的代码和#2处的代码所作的事情实际上是同样的，在#2处，python为咱们所作的事其实也能够手动完成。这也不是什么坏事，*args要么是表示调用方法大的时候额外的参数能够从一个可迭代列表中取得，要么就是定义方法的时候标志这个方法可以接受任意的位置参数。
接下来提到的**会稍多更复杂一点，**表明着键值对的餐宿字典，和*所表明的意义相差无几，也很简单对不对：

1 def foo(**kwargs):
2      print kwargs
3 foo()
4 {}
5 foo(x=1, y=2)
6 {'y': 2, 'x': 1}

当咱们定义一个函数的时候，咱们可以用**kwargs来代表，全部未被捕获的关键字参数都应该存储在kwargs的字典中。如前所诉，argshe kwargs并非python语法的一部分，但在定义函数的时候，使用这样的变量名算是一个不成文的约定。和*同样，咱们一样能够在定义或者调用函数的时候使用**。

1 dct = {'x': 1, 'y': 2}
2 def bar(x, y):
3      return x + y
4 bar(**dct)
5 3

12. 更通用的装饰器

有了这招新的技能，咱们随随便便就能够写一个可以记录下传递给函数参数的装饰器了。先来个简单地把日志输出到界面的例子：

1 def logger(func):
2      def inner(*args, **kwargs): #1
3          print "Arguments were: %s, %s" % (args, kwargs)
4          return func(*args, **kwargs) #2
5      return inner

请注意咱们的函数inner，它可以接受任意数量和类型的参数并把它们传递给被包装的方法，这让咱们可以用这个装饰器来装饰任何方法。

 1 @logger
 2  def foo1(x, y=1):
 3      return x * y
 4 @logger
 5  def foo2():
 6      return 2
 7 foo1(5, 4)
 8 Arguments were: (5, 4), {}
 9 20
10 foo1(1)
11 Arguments were: (1,), {}
12 1
13 foo2()
14 Arguments were: (), {}
15 2

随便调用咱们定义的哪一个方法，相应的日志也会打印到输出窗口，和咱们预期的同样。