作为一名教python的老师,我发现学生们基本上一开始很难搞定python的装饰器,也许因为装饰器确实很难懂。搞定装饰器需要你了解一些函数式编程的概念,当然还有理解在python中定义和调用函数相关语法的一些特点。
我没法让装饰器变得简单,但是通过一步步的剖析,我也许能够让你在理解装饰器的时候更自信一点。因为装饰器很复杂,这篇文章将会很长(自己都说很长,还敢这么多废话blablabla...前戏就不继续翻译直接省略了)。
1.函数
在python中,函数通过def
关键字、函数名和可选的参数列表定义。通过return
关键字返回值。我们举例来说明如何定义和调用一个简单的函数:
>>> def foo():
... return 1
>>> foo()
1
方法体(当然多行也是一样的)是必须的,通过缩进来表示,在方法名的后面加上双括号()
就能够调用函数
2.作用域
在python中,函数会创建一个新的作用域。python开发者可能会说函数有自己的命名空间,差不多一个意思。这意味着在函数内部碰到一个变量的时候函数会优先在自己的命名空间里面去寻找。让我们写一个简单的函数看一下本地作用域和 全局作用域有什么不同:
>>> a_string = "This is a global variable"
>>> def foo():
... print locals()
>>> print globals()
{..., 'a_string': 'This is a global variable'}
>>> foo() # 2
{}
内置的函数globals
返回一个包含所有python解释器知道的变量名称的字典(为了干净和洗的白白的,我省略了python自行创建的一些变量)。在#2
我调用了函数 foo
把函数内部本地作用域里面的内容打印出来。我们能够看到,函数foo
有自己独立的命名空间,虽然暂时命名空间里面什么都还没有。
3.变量解析规则
当然这并不是说我们在函数里面就不能访问外面的全局变量。在python的作用域规则里面,创建变量一定会一定会在当前作用域里创建一个变量,但是访问或者修改变量时会先在当前作用域查找变量,没有找到匹配变量的话会依次向上在闭合的作用域里面进行查看找。所以如果我们修改函数foo
的实现让它打印全局的作用域里的变量也是可以的:
>>> a_string = "This is a global variable"
>>> def foo():
... print a_string # 1
>>> foo()
This is a global variable
在#1
处,python解释器会尝试查找变量a_string
,当然在函数的本地作用域
里面是找不到的,所以接着会去上层的作用域里面去查找。
但是另一方面,假如我们在函数内部给全局变量赋值,结果却和我们想的不一样:
>>> a_string = "This is a global variable"
>>> def foo():
... a_string = "test" # 1
... print locals()
>>> foo()
{'a_string': 'test'}
>>> a_string # 2
'This is a global variable'
我们能够看到,全局变量能够被访问到(如果是可变数据类型(像list
,dict
这些)甚至能够被更改)但是赋值不行。在函数内部的#1
处,我们实际上新创建了一个局部变量,隐藏全局作用域中的同名变量。我们可以通过打印出局部命名空间中的内容得出这个结论。我们也能看到在#2
处打印出来的变量a_string
的值并没有改变。
4.变量生存周期
值得注意的一个点是,变量不仅是生存在一个个的命名空间内,他们都有自己的生存周期,请看下面这个例子:
>>> def foo():
... x = 1
>>> foo()
>>> print x # 1
Traceback (most recent call last):
...
NameError: name 'x' is not defined
#1
处发生的错误不仅仅是因为作用域规则导致的(尽管这是抛出了NameError
的错误的原因)它还和python以及其它很多编程语言中函数调用实现的机制有关。在这个地方这个执行时间点并没有什么有效的语法让我们能够获取变量x
的值,因为它这个时候压根不存在!函数foo
的命名空间随着函数调用开始而开始,结束而销毁。
5.函数参数
python允许我们向函数传递参数,参数会变成本地变量存在于函数内部。
>>> def foo(x):
... print locals()
>>> foo(1)
{'x': 1}
在Python里有很多的方式来定义和传递参数,完整版可以查看 python官方文档。我们这里简略的说明一下:函数的参数可以是必须的位置参数
或者是可选的命名
,默认参数。
>>> def foo(x, y=0): # 1
... return x - y
>>> foo(3, 1) # 2
2
>>> foo(3) # 3
3
>>> foo() # 4
Traceback (most recent call last):
...
TypeError: foo() takes at least 1 argument (0 given)
>>> foo(y=1, x=3) # 5
2
在#1
处我们定义了函数foo
,它有一个位置参数x
和一个命名参数y
。在#2
处我们能够通过常规的方式来调用函数,尽管有一个命名参数,但参数依然可以通过位置传递给函数。在调用函数的时候,对于命名参数y
我们也可以完全不管就像#3
处所示的一样。如果命名参数没有接收到任何值的话,python会自动使用声明的默认值也就是0
。需要注意的是我们不能省略第一个位置参数x
, 否则的话就会像#5
处所示发生错误。
目前还算简洁清晰吧, 但是接下来可能会有点令人困惑。python支持函数调用时的命名参数(个人觉得应该是命名实参)。看看#5
处的函数调用,我们传递的是两个命名实参,这个时候因为有名称标识,参数传递的顺序也就不用在意了。
当然相反的情况也是正确的:函数的第二个形参是y
,但是我们通过位置的方式传递值给它。在#2
处的函数调用foo(3,1)
,我们把3传递给了第一个参数,把1
传递给了第二个参数,尽管第二个参数是一个命名参数。
桑不起,感觉用了好大一段才说清楚这么一个简单的概念:函数的参数可以有名称 和 位置 。这意味着在函数的定义和调用的时候会稍稍在理解上有点儿不同。我们可以给只定义了位置参数的函数传递命名参数(实参),反之亦然!如果觉得不够可以查看官方文档
6.嵌套函数
Python允许创建嵌套函数。这意味着我们可以在函数里面定义函数而且现有的作用域和变量生存周期依旧适用。
>>> def outer():
... x = 1
... def inner():
... print x # 1
... inner() # 2
...
>>> outer()
1
这个例子有一点儿复杂,但是看起来也还行。想一想在#1发生了什么:python解释器需找一个叫x
的本地变量,查找失败之后会继续在上层的作用域里面寻找,这个上层的作用域定义在另外一个函数里面。对函数outer
来说,变量x
是一个本地变量,但是如先前提到的一样,函数inner
可以访问封闭的作用域(至少可以读和修改)。在#2
处,我们调用函数inner
,非常重要的一点是,inner
也仅仅是一个遵循python变量解析规则的变量名,python解释器会优先在outer
的作用域里面对变量名inner
查找匹配的变量.
7.函数是python世界里的一级类对象
显而易见,在python里函数和其他东西一样都是对象。(此处应该大声歌唱)啊!包含变量的函数,你也并不是那么特殊!
>>> issubclass(int, object) # all objects in Python inherit from a common baseclass
True
>>> def foo():
... pass
>>> foo.__class__ # 1
<type 'function'>
>>> issubclass(foo.__class__, object)
True
你也许从没有想过,你定义的函数居然会有属性。没办法,函数在python里面就是对象,和其他的东西一样,也许这样描述会太学院派太官方了点:在python里,函数只是一些普通的值而已和其他的值一毛一样。这就是说你尅一把函数想参数一样传递给其他的函数或者说从函数了里面返回函数!如果你从来没有这么想过,那看看下面这个例子:
>>> def add(x, y):
... return x + y
>>> def sub(x, y):
... return x - y
>>> def apply(func, x, y): # 1
... return func(x, y) # 2
>>> apply(add, 2, 1) # 3
3
>>> apply(sub, 2, 1)
1
这个例子对你来说应该不会很奇怪。add
和sub
是非常普通的两个python函数,接受两个值,返回一个计算后的结果值。在#1处你们能看到准备接收一个函数的变量只是一个普通的变量而已,和其他变量一样。在#2
处我们调用传进来的函数:“()
代表着调用的操作并且调用变量包含的值。在#3
处,你们也能看到传递函数并没有什么特殊的语法。” 函数的名称只是很其他变量一样的表标识符而已。
你们也许看到过这样的行为:“python把频繁要用的操作变成函数作为参数进行使用,像通过传递一个函数给内置排序函数的key
参数从而来自定义排序规则。那把函数当做返回值回事这样的情况呢:
>>> def outer():
... def inner():
... print "Inside inner"
... return inner # 1
...
>>> foo = outer() #2
>>> foo
<function inner at 0x...>
>>> foo()
Inside inner
这个例子看起来也许会更加的奇怪。在#1
处我把恰好是函数标识符的变量inner
作为返回值返回出来。这并没有什么特殊的语法:”把函数inner
返回出来,否则它根本不可能会被调用到。“还记得变量的生存周期吗?每次函数outer
被调用的时候,函数inner
都会被重新定义,如果它不被当做变量返回的话,每次执行过后它将不复存在。
在#2
处我们捕获住返回值 - 函数inner
,将它存在一个新的变量foo
里。我们能够看到,当对变量foo
进行求值,它确实包含函数inner
,而且我们能够对他进行调用。初次看起来可能会觉得有点奇怪,但是理解起来并不困难是吧。坚持住,因为奇怪的转折马上就要来了(嘿嘿嘿嘿,我笑的并不猥琐!)
8.闭包
我们先不急着定义什么是闭包,先来看看一段代码,仅仅是把上一个例子简单的调整了一下:
>>> def outer():
... x = 1
... def inner():
... print x # 1
... return inner
>>> foo = outer()
>>> foo.func_closure
(<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
会是同样的逻辑,假如我们稍微改动一下呢?
>>> def outer(x):
... def inner():
... print x # 1
... return inner
>>> print1 = outer(1)
>>> print2 = outer(2)
>>> print1()
1
>>> print2()
2
从这个例子中你能够看到闭包 - 被函数记住的封闭作用域 - 能够被用来创建自定义的函数,本质上来说是一个硬编码的参数。事实上我们并不是传递参数1
或者2
给函数inner
,我们实际上是创建了能够打印各种数字的各种自定义版本。
闭包单独拿出来就是一个非常强大的功能, 在某些方面,你也许会把它当做一个类似于面向对象的技术:outer
像是给inner
服务的构造器,x
像一个私有变量。使用闭包的方式也有很多:你如果熟悉python内置排序方法的参数key
,你说不定已经写过一个lambda
方法在排序一个列表的列表的时候基于第二个元素而不是第一个。现在你说不定也可以写一个itemgetter
方法,接收一个索引值来返回一个完美的函数,传递给排序函数的参数key
。
不过,我们现在不会用闭包做这么low的事(⊙o⊙)…!相反,让我们再爽一次,写一个高大上的装饰器!
9.装饰器
装饰器其实就是一个闭包,把一个函数当做参数然后返回一个替代版函数。我们一步步从简到繁来瞅瞅:
>>> def outer(some_func):
... def inner():
... print "before some_func"
... ret = some_func() # 1
... return ret + 1
... return inner
>>> def foo():
... return 1
>>> decorated = outer(foo) # 2
>>> decorated()
before some_func
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
就行了:
>>> foo = outer(foo)
>>> foo # doctest: +ELLIPSIS
<function inner at 0x...>
现在,任何怎么调用都不会牵扯到原先的函数foo
,都会得到新的装饰版本的foo
,现在我们还是来写一个有用的装饰器。
想象我们有一个库,这个库能够提供类似坐标的对象,也许它们仅仅是一些x和y的坐标对。不过可惜的是这些坐标对象不支持数学运算符,而且我们也不能对源代码进行修改,因此也就不能直接加入运算符的支持。我们将会做一系列的数学运算,所以我们想要能够对两个坐标对象进行合适加减运算的函数,这些方法很容易就能写出:
>>> class Coordinate(object):
... def __init__(self, x, y):
... self.x = x
... self.y = y
... def __repr__(self):
... return "Coord: " + str(self.__dict__)
>>> def add(a, b):
... return Coordinate(a.x + b.x, a.y + b.y)
>>> def sub(a, b):
... return Coordinate(a.x - b.x, a.y - b.y)
>>> one = Coordinate(100, 200)
>>> two = Coordinate(300, 200)
>>> add(one, two)
Coord: {'y': 400, 'x': 400}
如果不巧我们的加减函数同时也需要一些边界检查的行为那该怎么办呢?搞不好你只能够对正的坐标对象进行加减操作,任何返回的值也都应该是正的坐标。所以现在的期望是这样:
>>> one = Coordinate(100, 200)
>>> two = Coordinate(300, 200)
>>> three = Coordinate(-100, -100)
>>> sub(one, two)
Coord: {'y': 0, 'x': -200}
>>> add(one, three)
Coord: {'y': 100, 'x': 0}
我们期望在不更改坐标对象one, two, three
的前提下one
减去two
的值是{x: 0, y: 0}
,one
加上three
的值是{x: 100, y: 200}
。与其给每个方法都加上参数和返回值边界检查的逻辑,我们来写一个边界检查的装饰器!
>>> 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
>>> add = wrapper(add)
>>> sub = wrapper(sub)
>>> sub(one, two)
Coord: {'y': 0, 'x':