python-大话装饰器
装饰器
装饰器是个什么玩意呢?是个会了不难,装逼神器。但是如果不了解理解起来还是很抽象,让我们试试这个装逼神器吧!
1.什么是装饰器
装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。
2.需求是怎么来的
装饰器的定义很是抽象,先写一个无聊的小程序
def foo():
print 'in foo()' foo()#我擦这是什么鬼,谁不会啊,装13呢吧?
是不是觉得写这个程序很二,简单的不能再简单了?但是突然又来了一个更无聊的人B君,说我要看看执行这个函数用了多少时间,让你来满足B君的需求,你是不是觉得太简单,showtime。。。。
import time
def foo():
startTime = time.clock()
print 'in foo()'
endTime = time.clock()
print 'usedtime:',endTime - startTime foo()
ok,你可以傲娇的告诉B君,自己看吧,但是B君说,小伙子干的不错,我又想看看foo1和foo2这两函数的执行时间,这时候你怎么办?和刚才一样把你在foo上加的代码全部加到foo1和foo2上?但是如果B君说,我后边还有3,4,5.。。。等1w+个函数我都要看,你这时候怎么搞?全部复制一遍?还是直接干他丫的?
先来点小常识:
def home():
print 'this is the home page!' home()
print home
a = home
a() #输出:
this is the home page!
<function home at 0x0000000002C890B8>
this is the home page!
这个地方我们定义了一个函数,大家都知道:
1.home(),python 就会执行了这个函数,输出了‘this is the home page!’,
2.你看到了实例的地方,如果我不加()这个地方就是一个home函数在内存的存储地址。
3.如果我把这个地址赋值给另一个变量a,之后我a()函数同样执行了,结果输出和home()一样。函数地址可以作为函数的参数
解决问题1:
import time def foo():
print 'in foo()' def timeit(func): #你定义了一个函数专门干计算执行时间这个事情
start = time.clock()
func()#上面讲到了函数是可以当参数传过来的,在加上()是可以执行
end =time.clock()
print 'used:', end - start timeit(foo) #通过这个方法似乎不管是多少个函数你只要把它当参数都可以解决了
似乎逻辑上解决了B君的需求,一切都是很美好的运行着!。。。等等,突然B君发现我们现在的调用方式似乎发生了变化,之前我们是foo(),现在我们变成了timeit(foo),B君说:你这不还是得需要添加这行代码么,我现在更变态了,我有100w+个函数要看,而且我还在不同的模块内放着,涉及到了10w+个文件,你去改吧!无耻的奸笑声。。。。我似乎听到B君小声叨咕:我弄不死你小样的。
解决问题2:
人活着就是为了争一口气,不争馒头争口气,我们只能想办法在不修改调用的代码情况下解决问题,如果不修改代码,也就是意味着调用的时候仍然为foo(),但是我们还需要达到第类似timeit(foo)的效果。根据上面小常识中提到的如果我吧timeit赋值给foo,是不是执行foo()的效果和timeit()的效果一样?等等,这个地方似乎timeit()里面还传递了一个参数,我们得想办法把参数统一吧,如果timeit(foo)不是直接产生调用效果,而是返回一个和foo参数列表一致的函数的话就解决问题了,将timeit(foo)的返回赋值给foo,然后调用foo()的代码完全不用修改。
#-*- coding: UTF-8 -*-
import time def foo():
print 'in foo()' # 定义一个计时器,传入一个,并返回另一个附加了计时功能的方法
def timeit(func): # 定义一个内嵌的包装函数,给传入的函数加上计时功能的包装
def wrapper():
start = time.clock()
func()
end =time.clock()
print 'used:', end - start # 将包装后的函数返回
return wrapper #返回一个可调用的内存地址这样就可以被调用了 foo = timeit(foo)
foo()
这样,一个简易的计时器就做好了!我们只需要在定义foo以后调用foo之前,加上foo = timeit(foo),就可以达到计时的目的,这也就是装饰器的概念。上面这段代码看起来似乎已经不能再精简了,Python于是提供了一个语法糖来降低字符输入量。
import time def timeit(func):
def wrapper():
start = time.clock()
func()
end =time.clock()
print 'used:', end - start
return wrapper @timeit
def foo():
print 'in foo()' foo()
到这个地方你已经完美的解决了问题,同时你也在不知不觉中明白了装饰器了如果现在这个函数中待上参数怎么办?
解决函数中带参数的问题3:
现在foo(avg)中带参数了改怎解决呢,因为我们已经知道了foo其实已经不是之前的foo了,之前的foo已经当参数传给了timeit函数了,func=之前的foo,而现在是foo是wrapper
因此foo()中有多少个参数,我们响应在wrapper()中对应加上就可以了!
执行顺序解析:
aaarticlea/png;base64,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" alt="" />
解析分解
aaarticlea/png;base64,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" alt="" />
似乎又出现了这种多变的问题了额,还好python已经帮我们想到了
import time
###############一个参数########################
def timeit(func):
def wrapper(arg):
start = time.clock()
func(arg)
end =time.clock()
print 'used:', end - start
return wrapper @timeit
def foo(arg):
print 'in foo()' foo('sdasd') ##############二两参数#########################
def timeit(func):
def wrapper(arg1,arg2):
start = time.clock()
func(arg1,arg2)
end =time.clock()
print 'used:', end - start
return wrapper
@timeit
def foo(arg1,arg2):
print 'in foo()' foo('a','b') #############三两参数######################### def timeit(func):
def wrapper(arg1,arg2,arg3):
start = time.clock()
func(arg1,arg2)
end =time.clock()
print 'used:', end - start
return wrapper
@timeit
def foo(arg1,arg2,arg3):
print 'in foo()' foo('a','b','c')
动态参数一步搞定,以后你可以直接用这种情况就行了,不用再考虑参数的个数,相当于万能的吧!
def timeit(func):
def wrapper(*args,**kwargs):
start = time.clock()
func(*args,**kwargs)
end =time.clock()
print 'used:', end - start
return wrapper
@timeit
def foo(arg1,arg2,arg3):
print 'in foo()' foo('a','b','c','d')
多个装饰器共用问题4:
多个装饰器的情况下,你可以理解成这个一个俄罗斯套娃,是一层一层的,代码从上到下,套娃是从外到里。注意一定要明白执行顺序。
def wrapper2(func):
def inner():
print 'w2,before'
func()
print 'w2,after'
return inner def wrapper1(func):
def inner():
print 'w1,before'
func()
print 'w1,after'
return inner def wrapper0(func):
def inner():
print 'w0,before'
func()
print 'w0,after'
return inner @wrapper2
@wrapper1
@wrapper0 def foo():
print 'foo' foo()
带有参数的装饰器5:
#!/usr/bin/env python
#-*- coding:utf-8 -*- def Filter(a1,a2):
def outer(main_func):
print 'main_func=',main_func
def wrapper(request,kargs):
print a1
main_result = main_func(request,kargs)
print a2
return main_result
return wrapper
return outer
f5 = 123
f6=123
@Filter(f5, f6)
def Index(request,kargs):
print 'index'
print dir(Filter)
Index(1,2)
1.执行最外层的函数Filter,同时将两个参数传入进去,并得到返回值,outer函数地址。
2.创建装饰器,@+outer组合成@outer装饰器,这就和没有参数的装饰器一样了。
3.执行outer函数。
4.将outer函数的返回值赋值给被装饰的函数的函数名。
python-大话装饰器的更多相关文章
- Python各式装饰器
Python装饰器,分两部分,一是装饰器本身的定义,一是被装饰器对象的定义. 一.函数式装饰器:装饰器本身是一个函数. 1.装饰函数:被装饰对象是一个函数 [1]装饰器无参数: a.被装饰对象无参数: ...
- Python札记 -- 装饰器补充
本随笔是对Python札记 -- 装饰器的一些补充. 使用装饰器的时候,被装饰函数的一些属性会丢失,比如如下代码: #!/usr/bin/env python def deco(func): def ...
- python基础——装饰器
python基础——装饰器 由于函数也是一个对象,而且函数对象可以被赋值给变量,所以,通过变量也能调用该函数. >>> def now(): ... print('2015-3-25 ...
- 【转】详解Python的装饰器
原文链接:http://python.jobbole.com/86717/ Python中的装饰器是你进入Python大门的一道坎,不管你跨不跨过去它都在那里. 为什么需要装饰器 我们假设你的程序实现 ...
- 两个实用的Python的装饰器
两个实用的Python的装饰器 超时函数 这个函数的作用在于可以给任意可能会hang住的函数添加超时功能,这个功能在编写外部API调用 .网络爬虫.数据库查询的时候特别有用 timeout装饰器的代码 ...
- python 基础——装饰器
python 的装饰器,其实用到了以下几个语言特点: 1. 一切皆对象 2. 函数可以嵌套定义 3. 闭包,可以延长变量作用域 4. *args 和 **kwargs 可变参数 第1点,一切皆对象,包 ...
- 理解Python中的装饰器//这篇文章将python的装饰器来龙去脉说的很清楚,故转过来存档
转自:http://www.cnblogs.com/rollenholt/archive/2012/05/02/2479833.html 这篇文章将python的装饰器来龙去脉说的很清楚,故转过来存档 ...
- python基础—装饰器
python基础-装饰器 定义:一个函数,可以接受一个函数作为参数,对该函数进行一些包装,不改变函数的本身. def foo(): return 123 a=foo(); b=foo; print(a ...
- 详解Python的装饰器
Python中的装饰器是你进入Python大门的一道坎,不管你跨不跨过去它都在那里. 为什么需要装饰器 我们假设你的程序实现了say_hello()和say_goodbye()两个函数. def sa ...
- 关于python的装饰器(初解)
在python中,装饰器(decorator)是一个主要的函数,在工作中,有了装饰器简直如虎添翼,许多公司面试题也会考装饰器,而装饰器的意思又很难让人理解. python中,装饰器是一个帮函数动态增加 ...
随机推荐
- 001OC的结构解析
Xcode通过.m扩展名来表示文件使用的是OC代码,C编译器处理.c文件,c++编译器处理cpp文件.所有编译工作默认由LLVM处理,这个编译器能够理解C语言的全部3个变体. #import<F ...
- 翻书的效果:FMX.TSwipeTransitionEffect Animation
This example shows how to use a TSwipeTransitionEffect transition and a TPathAnimation to simulate t ...
- Android混淆、反编译以及反破解的简单回顾
=========================================================================虽然反编译很简单,也没下面说的那么复杂,不过还是转了过 ...
- AndroidUI 视图动画-透明动画效果 (AlphaAnimation)
1.新建一个Android项目,Activity添加一个按钮如下代码: <Button android:id="@+id/btnAiphaAnimation" android ...
- Android系统原理与源码分析(1):利用Java反射技术阻止通过按钮关闭对话框
原文出处:博主宇宙的极客http://www.cnblogs.com/nokiaguy/archive/2010/07/27/1786482.html 众所周知,AlertDialog类用于显示对话框 ...
- 一个很好的用C#导出数据到Excel模板的方法
/// <summary> /// 导数据到Excel模板 /// </summary> /// <param name="tab">要输出内容 ...
- javascript高级程序设计一(1-80)
源代码研究,实例:http://fgm.cc/learn/ js面试知识点: 1:原生.闭包.上下文.call.apply.prototype. 2:jsonp:用script标签实现跨域.xss:j ...
- FAQ:win7和win8 64位注册ocx控件方法
win7/win8 问题所在: 64位的系统一般都是可以安装32位程序的, 执行 C:\Windows\SysWOW64\regsvr32.exe 而不是 C:\Windows\Sys ...
- eclipse中输入的中文为繁体的问题
今天在eclipse中编写注释的时候发现,输入的中文都为繁体,且只在eclipse编辑器中为繁体,切换到网页中则为正常. 最后发现,竟然是输入法的shift+ctrl+F快捷键和eclipse的冲突. ...
- [多线程同步练习]PV操作
看一个较为复杂的生产者-消费者问题: 问题描述 桌子上有一只盘子,每次只能向其中放入一个水果.爸爸专向盘子中放苹果,妈妈专向盘子中放橘子,儿子专等吃盘子中的橘子,女儿专等吃盘子中的苹果.只有盘子为空时 ...