【转】【Python】装饰器
1、闭包
>>> def outer(): ... x = 1 ... def inner(): ... print x # 1 ... return inner >>> foo = outer() >>> foo.func_closure # doctest: +ELLIPSIS (<cell at 0x...: int object at 0x...>,)
从上一个示例可以看到,inner
是 outer
返回的一个函数,存储在变量 foo
里然后用 foo()
来调用。但是它能运行吗?先来思考一下作用域规则。
Python 中一切都按作用域规则运行—— x
是函数 outer
中的一个局部变量,当函数 inner
在 #1
处打印 x
时,Python 在 inner
中搜索局部变量但是没有找到,然后在外层作用域即函数 outer
中搜索找到了变量 x
。
但如果从变量的生命周期角度来看应该如何呢?变量 x
对函数 outer
来说是局部变量,即只有当 outer
运行时它才存在。只有当 outer
返回后才能调用 inner
,所以依据 Python 运行机制,在调用 inner
时 x
就应该不存在了,那么这里应该有某种运行错误出现。
结果并不是如此,返回的 inner
函数正常运行。Python 支持一种名为函数闭包的特性,意味着 在非全局作用域定义的 inner
函数在定义时记得外层命名空间是怎样的。inner
函数包含了外层作用域变量,通过查看它的 func_closure
属性可以看出这种函数闭包特性。
记住——每次调用函数 outer
时,函数 inner
都会被重新定义。此时 x
的值没有变化,所以返回的每个 inner
函数和其它的 inner
函数运行结果相同,但是如果稍做一点修改呢?
>>> def outer(x): ... def inner(): ... print x # 1 ... return inner >>> print1 = outer(1) >>> print2 = outer(2) >>> print1() 1 >>> print2() 2
从这个示例可以看到闭包——函数记住其外层作用域的事实——可以用来构建本质上有一个硬编码参数的自定义函数。虽然没有直接给 inner
函数传参 1 或 2,但构建了能“记住”该打印什么数的 inner
函数自定义版本。
闭包是强大的技术——在某些方面来看可能感觉它有点像面向对象技术:outer
作为 inner
的构造函数,有一个类似私有变量的 x
。闭包的作用不胜枚举——如果你熟悉 Python中 sorted
函数的参数 key
,也许你已经写过 lambda
函数通过第二项而非第一项来排序一些列表。也可以写一个 itemgetter
函数,接收一个用于检索的索引并返回一个函数,然后就能恰当的传递给 key
参数了。
但是这么用闭包太没意思了!让我们再次从头开始,写一个装饰器。
2、 装饰器
装饰器其实就是一个以函数作为参数并返回一个替换函数的可执行函数。让我们从简单的开始,直到能写出实用的装饰器。
>>> 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
请仔细看这个装饰器示例。首先,定义了一个带单个参数 some_func
的名为 outer
的函数。然后在 outer
内部定义了一个内嵌函数 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
坐标组成。遗憾的是坐标对象不支持数学运算,并且我们也无法修改源码。然而我们需要做很多数学运算,所以要构造能够接收两个坐标对象的 add
和 sub
函数,并且做适当的数学运算。这些函数很容易实现(为方便演示,提供一个简单的 Coordinate
类)。
>>> 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}
但是如果 add
和 sub
函数必须有边界检测功能呢?也许只能对正坐标进行加或减,并且返回值也限制为正坐标。如下:
>>> 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': 0} >>> add(one, three) Coord: {'y': 200, 'x': 100}
装饰器和之前一样正常运行——返回了一个修改版函数,但在这次示例中通过检测和修正输入参数和返回值,将任何负值的 x
或 y
用 0
来代替,实现了上面的需求。
是否这么做是见仁见智的,它让代码更加简洁:通过将边界检测从函数本身分离,使用装饰器包装它们,并应用到所有需要的函数。可替换的方案是:在每个数学运算函数返回前,对每个输入参数和输出结果调用一个函数,不可否认,就对函数应用边界检测的代码量而言,使用装饰器至少是较少重复的。事实上,如果要装饰的函数是我们自己实现的,可以使装饰器应用得更明确一点。
3、 函数装饰器 @ 符号的应用
Python 2.4 通过在函数定义前添加一个装饰器名和 @ 符号,来实现对函数的包装。在上面代码示例中,用了一个包装的函数来替换包含函数的变量来实现了装饰函数。
>>> add = wrapper(add)
这种模式可以随时用来包装任意函数。但是如果定义了一个函数,可以用 @ 符号来装饰函数,如下:
>>> @ wrapper ... def add(a, b): ... return Coordinate(a.x + b.x, a.y + b.y)
值得注意的是,这种方式和简单的使用 wrapper
函数的返回值来替换原始变量的做法没有什么不同—— Python 只是添加了一些语法糖来使之看起来更加明确。
使用装饰器很简单!虽说写类似 staticmethod
或者 classmethod
的实用装饰器比较难,但用起来仅仅需要在函数前添加 @装饰器名
即可!
4、 args 和 *kwargs
上面我们写了一个实用的装饰器,但它是硬编码的,只适用于特定类型的函数——带有两个参数的函数。内部函数 checker
接收两个参数,然后继续将参数传给闭包中的函数。如果我们想要一个能适用任何函数的装饰器呢?让我们来实现一个为每次被装饰函数的调用添加一个计数器的装饰器,但不改变被装饰函数。这意味着这个装饰器必须接收它所装饰的任何函数的调用信息,并且在调用这些函数时将传递给该装饰器的任何参数都传递给它们。
碰巧,Python 对这种特性提供了语法支持。请务必阅读 Python Tutorial 以了解更多,但在定义函数时使用 *
的用法意味着任何传递给函数的额外位置参数都是以 *
开头的。如下:
>>> def one(*args): ... print args # 1 >>> one() () >>> one(1, 2, 3) (1, 2, 3) >>> def two(x, y, *args): # 2 ... print x, y, args >>> two('a', 'b', 'c') a b ('c',)
第一个函数 one
简单的打印了传给它的任何位置参数(如果有)。在 #1
处可以看到,在函数内部只是简单的用到了变量 args
—— *args
只在定义函数时用来表示位置参数将会保存在变量 args
中。Python 也允许指定一些变量,并捕获任何在 args
里的额外参数,如 #2
处所示。
*
符号也可以用在函数调用时,在这里它也有类似的意义。在调用函数时,以 *
开头的变量表示该变量内容需被取出用做位置参数。再举例如下:
>>> def add(x, y): ... return x + y >>> lst = [1,2] >>> add(lst[0], lst[1]) # 1 3 >>> add(*lst) # 2 3
在 #1 处的代码和 #2 处的作用相同——可以手动做的事情,在 #2 处 Python 帮我们自动处理了。这看起来不错,*args
可以表示在调用函数时从迭代器中取出位置参数, 也可以表示在定义函数时接收额外的位置参数。
接下来介绍稍微复杂一点的用来表示字典和键值对的 **
,就像 *
用来表示迭代器和位置参数。很简单吧?
>>> def foo(**kwargs): ... print kwargs >>> foo() {} >>> foo(x=1, y=2) {'y': 2, 'x': 1}
当定义一个函数时,使用 **kwargs
来表示所有未捕获的关键字参数将会被存储在字典 kwargs
中。此前 args
和 kwargs
都不是 Python 中语法的一部分,但在函数定义时使用这两个变量名是一种惯例。和 *
的使用一样,可以在函数调用和定义时使用 **
。
>>> dct = {'x': 1, 'y': 2} >>> def bar(x, y): ... return x + y >>> bar(**dct) 3
5、 更通用的装饰器
用学到的新知识,可以写一个记录函数参数的装饰器。为简单起见,仅打印到标准输出:
>>> def logger(func): ... def inner(*args, **kwargs): #1 ... print "Arguments were: %s, %s" % (args, kwargs) ... return func(*args, **kwargs) #2 ... return inner
注意在 #1
处函数 inner
接收任意数量和任意类型的参数,然后在 #2
处将他们传递给被包装的函数。这样一来我们可以包装或装饰任意函数,而不用管它的签名。
>>> @logger ... def foo1(x, y=1): ... return x * y >>> @logger ... def foo2(): ... return 2 >>> foo1(5, 4) Arguments were: (5, 4), {} 20 >>> foo1(1) Arguments were: (1,), {} 1 >>> foo2() Arguments were: (), {} 2
每一个函数的调用会有一行日志输出和预期的返回值。
再聊装饰器
如果你一直看到了最后一个实例,祝贺你,你已经理解了装饰器!你可以用新掌握的知识做更多的事了。
你也许考虑需要进一步的学习:Bruce Eckel 有一篇很赞的关于装饰器文章,他使用了对象而非函数来实现了装饰器。你会发现 OOP 代码比纯函数版的可读性更好。Bruce 还有一篇后续文章 providing arguments to decorators,用对象实现装饰器也许比用函数实现更简单。最后,你可以去研究一下内建包装函数 functools,它是一个在装饰器中用来修改替换函数签名的装饰器,使得这些函数更像是被装饰的函数。
【转】【Python】装饰器相关推荐
- python简单装饰器_简单介绍Python装饰器(一)
装饰器的作用 相信大家在 探索过程中已经了解装饰器的作用,也有很多花里胡哨的介绍. 这次小冰也来讲解一下关于Python装饰器的一些小知识. 它的作用: 性能测试 日志 安全验证 ...... 相信大 ...
- Python装饰器的神奇功能:自动打印每个方法耗时
问题: 运行代码时,尤其对于大型项目需要分析每个环节方法耗时的.每个方法前后都写计算耗时及日志打印太繁琐了,而且代码不精简. 解决: Python装饰器类似于Spring的 AOP(Aspect Or ...
- python装饰器教学_Python装饰器学习(九步入门)
这是在Python学习小组上介绍的内容,现学现卖.多练习是好的学习方式. 第一步:最简单的函数,准备附加额外功能 # -*- coding:gbk -*- '''示例1: 最简单的函数,表示调用了两次 ...
- 简单介绍python装饰器
这篇文章简单介绍一下python装饰器,希望对你们有所帮助. 简单正常python例子: def up(text):return text.upper() #转成大写 def lo(text):ret ...
- Python装饰器是什么?使用Python装饰器实现计算程序(函数)运行时间的功能
Python装饰器是什么?使用Python装饰器实现计算程序(函数)运行时间的功能 目录
- python 装饰器示例
python 装饰器示例 import timedef decorator(func): # 传函数def wrapper(*args, **kwargs): # 传参数(也可以传固定参数)start ...
- [转]python 装饰器
以前你有没有这样一段经历:很久之前你写过一个函数,现在你突然有了个想法就是你想看看,以前那个函数在你数据集上的运行时间是多少,这时候你可以修改之前代码为它加上计时的功能,但是这样的话是不是还要大体读读 ...
- python装饰器与闭包_Python 装饰器和闭包
Python 装饰器和闭包 装饰器是 Python 中常见的语法糖,这篇文章讲了闭包和装饰器的原理,并且分析了函数中变量的作用域,以及尝试总结了常见的坑. 装饰器基础 首先来看看装饰器的定义:装饰器本 ...
- 利用世界杯,读懂 Python 装饰器
Python 装饰器是在面试过程高频被问到的问题,装饰器也是一个非常好用的特性, 熟练掌握装饰器会让你的编程思路更加宽广,程序也更加 pythonic. 今天就结合最近的世界杯带大家理解下装饰器. 德 ...
- Python 装饰器记录总结 (终极版)
Python 装饰器记录总结 (终极版) 原文链接:http://magicroc.com/2017/04/10/Python装饰器记录总结/ 装饰器是一个函数,一个用来包装函数的函数,装饰器在函数申 ...
最新文章
- 使用Keras计算余弦相似度(Cosine Similarity)
- linux下vi命令修改文件及保存的使用方法
- Visual Studio 快捷键 转载
- 作为Web开发人员,我为什么喜欢Google Chrome浏览器
- C++学习笔记之——引用 内联函数
- php7.0 cli,PHP-7.1 源代码学习:php-cli 启动流程
- oracle数据库swap占用率高,Oracle数据库所在服务器swap严重
- STL学习笔记-set的基本原理以及插入、遍历
- 蒙特卡洛模拟(Monte Carlo simulation)
- 解决MySQL无法正常启动的问题 Can't connect to MySQL server on 'localhost'(10061)
- 如何实现一个简单的熔断以及Hystrix原理分析
- java 运行注释_Java中的可执行注释
- GNS3安装和使用教程
- 如何阅读源码,阅读源码的难点和方法分析
- 计算机CPU高端产品,英特尔酷睿处理器哪个型号好?电脑CPU性能排名
- 几百字道尽华夏无千年。
- TWS耳机哪个牌子音质好?TWS耳机推荐!
- linux系统虚拟鼠标的实现
- vue 浏览器调试 样式如何定位样式_Vue项目骨架屏注入实践和方法总结
- python 异常及处理