在python的世界里,函数和我们之前的[1,2,3],'abc',8等一样都是对象,而且函数是最高级的对象(对象是类的实例化,可以调用相应的方法,函数是包含变量对象的对象,牛逼!)。
1
2
3
4
5
6
7
8
9
10
|
def foo(): print ( 'i am the foo' ) bar() def bar(): print ( 'i am the bar' ) foo() # def bar(): #报错 # print('i am the bar') |
带着这个问题,我们聊一聊函数在内存的存储情况:
图1
函数对象的调用仅仅比其它对象多了一个()而已!foo,bar与a,b一样都是个变量名。
那上面的问题也就解决了,只有函数加载到内存才可以被调用。
既然函数是对象,那么自然满足下面两个条件:
1. 其可以被赋给其他变量
1
2
3
4
5
6
|
def foo(): print ( 'foo' ) bar = foo bar() foo() print ( id (foo), id (bar)) #4321123592 4321123592 |
2. 其可以被定义在另外一个函数内(作为参数&作为返回值),类似于整形,字符串等对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#*******函数名作为参数********** def foo(func): print ( 'foo' ) func() def bar(): print ( 'bar' ) foo(bar) #*******函数名作为返回值********* def foo(): print ( 'foo' ) return bar def bar(): print ( 'bar' ) b = foo() b() |
注意:这里说的函数都是指函数名,比如foo;而foo()已经执行函数了,foo()是什么类型取决于return的内容是什么类型!!!
另外,如果大家理解不了对象,那么就将函数理解成变量,因为函数对象总会由一个或多个变量引用,比如foo,bar。
法宝三(函数的嵌套以及闭包):
抛一个小问题:
1
2
3
4
5
6
|
def foo(): print ( 'foo' ) def bar(): print ( 'bar' ) # bar() bar() |
是的,bar就是一个变量名,有自己的作用域的。
Python允许创建嵌套函数。通过在函数内部def的关键字再声明一个函数即为嵌套:
1
2
3
4
5
6
7
8
9
10
11
|
#想执行inner函数,两种方法 def outer(): x = 1 def inner(): print (x) # 1 # inner() # 2 return inner # outer() in_func = outer() in_func() |
在这里,你有没有什么疑问?如果没有,那我问你:
1 两种调用方式有区别吗,不都是在外面调用inner吗?
1
2
3
4
|
in_func = outer() in_func() ########### inner()(已经加载到内存啦) |
2
1
2
3
|
def outer(): x = 1 #函数outer执行完毕即被销毁 print (x) |
既然这样,i()执行的时候outer函数已经执行完了,为什么inner还可以调用outer里的变量x呢?
哈,这就涉及到我们叫讲的闭包啦!
因为:outer里return的inner是一个闭包函数,有x这个环境变量。
OK,那么什么是闭包呢?
闭包(closure)是函数式编程的重要的语法结构。
定义:如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure).
如上实例,inner就是内部函数,inner里引用了外部作用域的变量x(x在外部作用域outer里面,不是全局作用域),
则这个内部函数inner就是一个闭包。
再稍微讲究一点的解释是,闭包=函数块+定义函数时的环境,inner就是函数块,x就是环境,当然这个环境可以有很多,不止一个简单的x。
1
|
print (in_func.__closure__[ 0 ].cell_contents) |
用途省略
装饰器概念
说了这么多,终于到了我们的装饰器了。
装饰器本质上是一个函数,该函数用来处理其他函数,它可以让其他函数在不需要修改代码的前提下增加额外的功能,装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等应用场景。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲,装饰器的作用就是为已经存在的对象添加额外的功能。
业务生产中大量调用的函数:
1
2
3
|
def foo(): print ( 'hello foo' ) foo() |
现在有一个新的需求,希望可以记录下函数的执行时间,于是在代码中添加日志代码:
1
2
3
4
5
6
7
8
9
|
import time def foo(): start_time = time.time() print ( 'hello foo' ) time.sleep( 3 ) end_time = time.time() print ( 'spend %s' % (end_time - start_time)) foo() |
bar()、bar2()也有类似的需求,怎么做?再在bar函数里调用时间函数?这样就造成大量雷同的代码,为了减少重复写代码,我们可以这样做,重新定义一个函数:专门设定时间:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
import time def show_time(func): start_time = time.time() func() end_time = time.time() print ( 'spend %s' % (end_time - start_time)) def foo(): print ( 'hello foo' ) time.sleep( 3 ) show_time(foo) |
逻辑上不难理解,而且运行正常。 但是这样的话,你基础平台的函数修改了名字,容易被业务线的人投诉的,因为我们每次都要将一个函数作为参数传递给show_time函数。而且这种方式已经破坏了原有的代码逻辑结构,之前执行业务逻辑时,执行运行foo(),但是现在不得不改成show_time(foo)。那么有没有更好的方式的呢?当然有,答案就是装饰器。
简单装饰器
if foo()==show_time(foo) :问题解决!
所以,我们需要show_time(foo)返回一个函数对象,而这个函数对象内则是核心业务函数:执行func()与装饰函数时间计算,修改如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import time def show_time(func): def wrapper(): start_time = time.time() func() end_time = time.time() print ( 'spend %s' % (end_time - start_time)) return wrapper def foo(): print ( 'hello foo' ) time.sleep( 3 ) foo = show_time(foo) foo() |
函数show_time就是装饰器,它把真正的业务方法func包裹在函数里面,看起来像foo被上下时间函数装饰了。在这个例子中,函数进入和退出时 ,被称为一个横切面(Aspect),这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。
@符号是装饰器的语法糖,在定义函数的时候使用,避免再一次赋值操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
import time def show_time(func): def wrapper(): start_time = time.time() func() end_time = time.time() print ( 'spend %s' % (end_time - start_time)) return wrapper @show_time #foo=show_time(foo) def foo(): print ( 'hello foo' ) time.sleep( 3 ) @show_time #bar=show_time(bar) def bar(): print ( 'in the bar' ) time.sleep( 2 ) foo() print ( '***********' ) bar() |
如上所示,这样我们就可以省去bar = show_time(bar)这一句了,直接调用bar()即可得到想要的结果。如果我们有其他的类似函数,我们可以继续调用装饰器来修饰函数,而不用重复修改函数或者增加新的封装。这样,我们就提高了程序的可重复利用性,并增加了程序的可读性。
这里需要注意的问题: foo=show_time(foo)其实是把wrapper引用的对象引用给了foo,而wrapper里的变量func之所以可以用,就是因为wrapper是一个闭包函数。
key:
@show_time帮我们做的事情就是当我们执行业务逻辑foo()时,执行的代码由粉框部分转到蓝框部分,仅此而已!
装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数,可以被赋值给其他变量,可以作为返回值,可以被定义在另外一个函数内。
带参数的被装饰函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import time def show_time(func): def wrapper(a,b): start_time = time.time() func(a,b) end_time = time.time() print ( 'spend %s' % (end_time - start_time)) return wrapper @show_time #add=show_time(add) def add(a,b): time.sleep( 1 ) print (a + b) add( 2 , 4 ) |
不定长参数
#***********************************不定长参数 import time def show_time(func): def wrapper(*args,**kwargs): start_time=time.time() func(*args,**kwargs) end_time=time.time() print('spend %s'%(end_time-start_time)) return wrapper @show_time #add=show_time(add) def add(*args,**kwargs): time.sleep(1) sum=0 for i in args: sum+=i print(sum) add(2,4,8,9)