Python装饰器入门_Python编程学习

Python允许你&＃xff0c;作为程序员&＃xff0c;使用函数完成一些很酷的事情。在Python编程学习中&＃xff0c;函数是一等对象(first-class object)&＃xff0c;这就意味着你可以像使用字符串&＃xff0c;整数&＃xff0c;或者任何其他对象一样使用函数。

例如&＃xff0c;你可以将函数赋值给变量&＃xff1a;

>>> def square(n):
... return n * n;
>>> square(4)
16
>>> alias &＃61; square
>>> alias(4)
16


然而&＃xff0c;一等函数的真正威力在于你可以把函数传给其他函数&＃xff0c;或者从其他函数中返回函数。Python的内置函数map利用了这种能力&＃xff1a;给map传个函数以及一个列表&＃xff0c;它会依次以列表中每个元素为参数调用你传给它的那个函数&＃xff0c;从而生成一个新的列表。如下所示的例子中应用了上面的那个square函数:

>>> number &＃61; [1, 2, 3, 4, 5]
>>> map(square, numbers)
[1, 4, 9, 16, 25]


如果一个函数接受其他函数作为参数&＃xff0c;以及/或者返回一个函数&＃xff0c;那么它就被称为高阶函数 。虽然map函数只是简单地使用了我们传给它的函数&＃xff0c;而没有改变这个函数&＃xff0c;但我们也可以使用高阶函数去改变其他函数的行为。

例如&＃xff0c;假设有这样一个函数&＃xff0c;会被调用很多次&＃xff0c;以致运行代价非常昂贵:

>>> def fib(n):
... "Recursively (i.e., dreadfully) calculate the nth Fibonacci number."
... return n if n in [0, 1] else fib(n - 2) &＃43; fib(n - 1)


我们一般会保存计算过程中每次递归调用的结果&＃xff0c;这样&＃xff0c;对于函数调用树中经常出现某个n&＃xff0c;当需要计算n对应的结果时&＃xff0c;就不需要重复计算了。有多种方式可以做到这点。例如&＃xff0c;我们可以将这些结果存在一个字典中&＃xff0c;当以某个值为参数调用fib函数时&＃xff0c;就先到这个字典去查一下其结果是否已经计算出来了。

但这样的话&＃xff0c;每次我们想要调用fib函数&＃xff0c;都需要重复那段相同的字典检查样板式代码。相反&＃xff0c;如果让fib函数自己在内部负责存储其结果&＃xff0c;那么在其他代码中调用fib&＃xff0c;就非常方便&＃xff0c;只要简单地调用它就行了。这样一种技术被称为memoization(注意没有字母r的哦)。

我们可以把这种memoization代码直接放入fib函数&＃xff0c;但是Python为我们提供了另外一种更加优雅的选择。因为可以编写修改其他函数的函数&＃xff0c;那么我们可以编写一个通用的memoization函数&＃xff0c;以一个函数作为参数&＃xff0c;并返回这个函数的memoization版本:

def memoize(fn):stored_results &＃61; {}def memoized(*args):try:# try to get the cached resultreturn stored_results[args]except KeyError:# nothing was cached for those args. let&＃39;s fix that.result &＃61; stored_results[args] &＃61; fn(*args)return resultreturn memoized如果你依然在编程的世界里迷茫&＃xff0c;
不知道自己的未来规划&＃xff0c;
对python感兴趣&＃xff0c;
这里推荐一下我的学习交流圈QQ群&＃xff1a;895 797 751&＃xff0c;
里面都是学习python的&＃xff0c;


如上&＃xff0c; memoize 函数以另一个函数作为参数&＃xff0c;函数体中创建了一个字典对象用来存储函数调用的结果&＃xff1a;键为被memoized包装后的函数的参数&＃xff0c;值为以键为参数调用函数的返回值。 memoize 函数返回一个新的函数&＃xff0c;这个函数会首先检查在 stored_results 字典中是否存在与当前参数对应的条目&＃xff1b;如果有&＃xff0c;对应的存储值会被返回&＃xff1b;否则&＃xff0c;就调用经过包装的函数&＃xff0c;存储其返回值&＃xff0c;并且返回给调用者。memoize返回的这种新函数常被称为"包装器"函数&＃xff0c;因为它只是另外一个真正起作用的函数外面的一个薄层。

很好&＃xff0c;现在有了一个memoization函数&＃xff0c;我们可以把fib函数传给它&＃xff0c;从而得到一个经过包装的fib&＃xff0c;这个版本的fib函数不需要重复以前那样的繁重工作:

def fib(n):return n if n in [0, 1] else fib(n - 2) &＃43; fib(n - 1)
fib &＃61; memoize(fib)


通过高阶函数memoize&＃xff0c;我们获得了memoization带来的好处&＃xff0c;并且不需要对fib函数自己做出任何改变&＃xff0c;以免夹杂着memoization的代码而模糊了函数的实质工作。但是&＃xff0c;你也许注意到上面的代码还算有点别扭&＃xff0c;因为我们必须写3遍fib。由于这种模式-传递一个函数给另一个函数&＃xff0c;然后将结果返回给与原来那个函数同名的函数变量-在使用包装器函数的代码中极为常见&＃xff0c;Python为其提供了一种特殊的语法&＃xff1a;装饰器:

&＃64;memoize
def fib(n):return n if n in [0, 1] else fib(n - 2) &＃43; fib(n -1)


这里&＃xff0c;我们说memoize函数装饰了fib函数。需要注意的是这仅是一种语法上的简便写法(译注&＃xff1a;就是我们常说的"语法糖")。这段代码与前面的代码片段做的是同样的事情&＃xff1a;定义一个名为fib的函数&＃xff0c;把它传给memoize函数&＃xff0c;将返回结果存为名为fib的函数变量。特殊的(看起来有点奇怪的)&＃64;语法只是减少了冗余。

你可以将多个装饰器堆叠起来使用&＃xff0c;它们会自底向上地逐个起作用。例如&＃xff0c;假设我们还有另一个用来帮助调试的高阶函数:

def make_verbose(fn):def verbose(*args):# will print (e.g.) fib(5)print &＃39;%s(%s)&＃39; % (fb.__name__, &＃39;, &＃39;.join(repr(arg) for arg in args))return fn(*args) # actually call the decorated functionreturn verbose


下面的两个代码片段做的是同样的事情:

&＃64;memoize
&＃64;make_verbose
def fib(n):
return n if n in [0, 1] else fib(n - 2) &＃43; fib(n - 1)
def fib(n):
return n if n in [0, 1] else fib(n - 2) &＃43; fib(n - 1)
fib &＃61; memoize(make_verbose(fib))

有趣的是&＃xff0c;Python并没有限制你在&＃64;符号后只能写一个函数名&＃xff1a;你也可以调用一个函数&＃xff0c;从而能够高效地传递参数给装饰器。假设我们并不满足于简单的memoization&＃xff0c;还想将函数的结果存储到memcached中。如果你已经写了一个 memcached 装饰器函数&＃xff0c;那么可以(例如)传递一个服务器地址给它:

&＃64;memcached(&＃39;127.0.0.1:11211&＃39;)
def fib(n):return n if n in [0, 1] else fib(n - 2) &＃43; fib(n - 1)

非装饰器语法的写法会如下展开:

fib &＃61; memcached(‘127.0.0.1:11211’)(fib)

Python配备有一些作为装饰器使用的非常有用的函数。例如&＃xff0c;Python有一个 classmethod 函数&＃xff0c;可以创建大致类似于java的静态方法:

class Foo(object):
SOME_CLASS_CONSTANT &＃61; 42
&＃64;classmethod
def add_to_my_constant(cls, value):
# Here, &＃96;cls&＃96; will just be Foo, buf if you called this method on a
# subclass of Foo, &＃96;cls&＃96; would be that subclass instead.
return cls.SOME_CLASS_CONSTANT &＃43; value
Foo.add_to_my_constant(10) # &＃61;> 52
# unlike in Java, you can also call a classmethod on an instance
f &＃61; Foo()
f.add_to_my_constant(10) # &＃61;> 52


旁注&＃xff1a;文档字符串

Python函数可以包含更多的信息&＃xff0c;而不仅仅是代码&＃xff1a;它们也包含有用的帮助信息&＃xff0c;比如函数名称&＃xff0c;文档字符串:

>>> def fib(n):
... "Recursively (i.e., dreadfully) calculate the nth Fibonacci number."
... return n if n in [0, 1] else fib(n - 2) &＃43; fib(n - 1)
...
>>> fib.__name__
&＃39;fib&＃39;
>>> fib.__doc__
&＃39;Recursively (i.e., dreadfully) calculate the nth Fibonacci number.&＃39;

Python内置函数help输出的就是这些信息。但是&＃xff0c;当函数被包装之后&＃xff0c;我们看到就是包装器函数的名称和文档字符串了:

>>> fib &＃61; memoized(fib)
>>> fib.__name__
&＃39;memoized&＃39;
>>> fib.__doc__
>


那样的信息并没有什么用处。幸运的是&＃xff0c;Python包含一个名为 functools.wraps 的助手函数&＃xff0c;能够把函数的帮助信息拷贝到其包装器函数:

import functools
def memoize(fn):stored_results &＃61; {}&＃64;functools.wraps(fn)def memoized(*args):# (as before)return memoized

使用装饰器帮助你编写装饰器会使很多事情令人非常满意。现在&＃xff0c;如果使用更新过的memoize函数重试前面的代码&＃xff0c;我们将会看到得到保留的文档&＃xff1a;

>>> fib &＃61; memoized(fib)
>>> fib.__name__
&＃39;fib&＃39;
>>> fib.__doc__
&＃39;Recursively (i.e., dreadfully) calculate the nth Fibonacci number.&＃39;


更多的Python编程学习教程下期继续为大家更新&＃xff01;