码迷,mamicode.com
首页 > 其他好文 > 详细

装饰器和闭包

时间:2019-03-05 11:06:05      阅读:193      评论:0      收藏:0      [点我收藏+]

标签:targe   策略模式   话题   方法   term   注意   另一个   __call   info   

装饰器用来在不修改原函数代码的情况下,增强该函数的功能。要想熟练掌握装饰器,必须理解闭包。

闭包粗略的讲就是保存有状态的函数,它除了在装饰器中有作用之外,还是回调式异步编程和函数式编程的基础。所以闭包的重要性可想而知。

装饰器基础知识

装饰器就本质而言依然是一个函数,他接收一个函数作为参数,然后返回它,或者返回另一个函数。

 1 import functools
 2 def deco(func):
 3     #@functools.wraps(func) 
 4     def inner():
 5         print("running inner()")
 6     return inner
 7 
 8 @deco
 9 def target():
10     print("running target()")
11 """
12 target = deco(target) 与
13 @deco
14 def target():
15     ...
16 是一样的,@只是python的语法糖而已
17 """
18 target()
19 print(target)

使用python的@语法,虽然函数名称还是target,但是函数指针已经发生了改变,不再指向自身,而是指向deco里面的inner函数。

print(target)打印的结果是:<function deco.<locals>.inner at 0x0000000003590378>

@functools.wraps(func)的作用是把inner的函数名__name__替换成target

加上之后print(target)打印的结果就是:<function target at 0x0000000003590378>.

使用装饰器改进策略模式

 1 promos = []
 2 
 3 #装饰器
 4 def deco(func):
 5     promos.append(func)
 6     return func
 7 
 8 @deco
 9 def fidelity_promotion(order):
10     """
11     为积分1000及以上的顾客提供5%的折扣
12     """
13     return order.total()*0.05 if order.customer.fidelity >= 1000 else 0
14 
15 @deco
16 def bulkitem_promotion(order):
17     """
18     单个商品为20个及以上提供10%的折扣
19     """
20     discount = 0
21     for item in order.cart:
22         if item.quantity >= 20:
23             discount += item.total()*0.1
24     return discount
25 
26 @deco
27 def largeorder_promotion(order):
28     """
29     订单中的不同商品达到10个及以上时提供7%折扣
30     """
31     itemset = set(item.product for item in order.cart)
32     #print(itemset)
33     return order.total()*0.07 if len(itemset) >= 10 else 0
34 
35 #最佳的折扣方案
36 def best_promotion(order):
37     return max(promo(order) for promo in promos)
38 
39 print("------------------------")
40 joe = Customer(John Doe, 0)
41 ann = Customer(Ann Smith, 1100)
42 cart = [
43     LineItem(banana, 4, .5),
44     LineItem(apple, 10, 1.5),
45     LineItem(watermellon, 5, 5.0)
46 ]
47 
48 print(Order(joe, cart, best_promotion))
49 print(Order(ann, cart, best_promotion))

使用装饰器修饰几个promotion函数,装饰器接收函数作为参数,然后把函数名追加到promos列表中,在把袁术原封不动的返回,这样做有几个好处。

* 折扣函数可以随意定义,只有在定义前加上@deco即可加入促销策略

* 方便禁用某种策略,只需注释掉@deco

不过,多数装饰器都是会被装饰的函数。通常,装饰器会在内部定义一个内部函数,然后将他返回,替换原来的函数。使用内部函数的代码几乎都要靠闭包才能正确运行,为了理解闭包,我们先来看一下python的变量作用域。

变量的作用域

先来看一个例子

1 def f(x):
2     print(x)
3     print(y)
4 
5 f(3)

毫无疑问,程序会抛出NameError: global name ‘y‘ is not defined。出现错误不奇怪,因为我们没给b赋值。

如果先给全局变量y赋值,在调用f就不会出现任何问题。

1 y = 4
2 def f(x):
3     print(x)
4     print(y)
5 
6 f(3)

以为懂了?再来看一个可能会让你吃惊的例子。

1 y = 4
2 def f(x):
3     print(x)
4     print(y)
5     y += 1
6     
7 f(3)

运行结果表明,程序会抛出NameError: global name ‘y‘ is not defined。一开始我也觉得很吃惊,我本以为程序会引用全局变量y,打印出4,可事实却不是这样。

python解释器会认为y是局部变量,因为 y+=1,也就相当于y=y+1,给y赋值了,那么python就会在局部作用域找y,发现y没有值,因此会报错。如果想要使用全局变量y,可以使用global关键字。

1 y = 4
2 def f(x):
3     print(x)
4         global y
5     print(y)
6     y += 1
7     
8 f(3)
9 print(y) #y的值变为5

闭包

有时,人们会把闭包和函数弄混,这是有历史原因的:在函数内部定义函数的做法并不常见,直到开始使用lambda函数时才会这样做。而且,只有在涉及嵌套函数才会有闭包问题,因此许多人是同时知道这两个概念的。

闭包,也就是延伸了作用域的函数,包括函数体中的引用、不在函数体也不是全局变量的引用。关键是他能访问函数体之外的非全局变量。

学术性的话通常言简意赅、清晰准确,但不容易理解。

假设我们现在有一个avg函数,他要计算平均值,每次都有新的值加进来,因此每次的平均值可能都不一样。我们想,所以得保存之前的历史数据。

用类实现的代码如下:

 1 class Average(object):
 2     def __init__(self):
 3         self.series = []
 4 
 5     def __call__(self, val):
 6         self.series.append(val)
 7         return sum(self.series)/len(self.series)
 8 
 9 avg = Average()
10 print(avg(1))
11 print(avg(2))
12 print(avg(3))
13 print(avg(4))

但是今天我们要学习的是闭包,所以用高级函数实现如下:

 1 def make_average():
 2     series = []
 3     def average(val):
 4         series.append(val)
 5         return sum(series)/len(series)
 6     return average
 7 
 8 
 9 avg = make_average()
10 print(avg(1))
11 print(avg(2))
12 print(avg(3))
13 print(avg(4))

函数make_average内部定义了一个空列表series,和一个内部函数average,average接收一个参数,然后把参数放进列表中,计算平均值,make_average最后返回average函数。

现在,我们来比较一下两者实现的差别。

类的方式实现很明显,他把所有的历史数据都放在实例的series列表中,但是高阶函数里的average到哪里去找series列表呢?

注意,series定义在make_average函数中,那么在average函数中,series被称为自由变量(free variable)。指的是未在本地作用域中绑定的变量。

技术图片

series参数被绑定在average函数的__closure__属性中,它是个列表,每个元素是cell对象,数据保存在cell_contents中。

1 avg = make_average()
2 print(avg(1))
3 print(avg(2))
4 print(avg(3))
5 print(avg(4))
6 print(avg.__closure__)
7 for item in avg.__closure__:
8     print(item.cell_contents)

运行结果如下:

技术图片

综上,闭包本质就是函数,只是他会保留定义时在函数外部存在的自由变量的绑定,这样调用函数时,虽然定义作用域不可用,但是保留的那些自由变量依然可以使用。

nonlocal声明

前面的make_average实现效率并不高,因为每次添加一个值进去,都得重新编列一遍series列表求和,如果我们能绑定历史的求和值跟元素个数,显然效率更高。

方法一:

 1 def make_average():
 2     s = 0
 3     n = 0
 4     def average(val):
 5         n += 1
 6         s += val
 7         return s/n
 8     return average
 9 
10 avg = make_average()
11 avg(1)

一运行,咦?怎么报错了呢

别急,我们换种方法试一下:

方法二:

 1 def make_average():
 2     s_n = {sum:0, n:0}
 3     def average(val):
 4         s_n[n] += 1
 5         s_n[sum] += val
 6         return s_n[sum]/s_n[n]
 7     return average
 8 
 9 avg = make_average()
10 print(avg(1))
11 print(avg(2))
12 print(avg(3))
13 print(avg(4))

一运行,终于没问题了。这是为什么?

在一开始,我们讨论过变量作用域的话题,方法一中, s+=val等价于 s = s+val,也就是给变量s赋值,这时,python就不再把s当成自由变量,而是当成局部变量看待,因此会报错,告诉你s是局部变量在没有赋值前被引用。再来看下为什么方法二没问题,方法二定义了一个字典,尽管在average函数里修改字典里键对应的值,但是并没有对字典本身做什么赋值操作,因此s_n绑定的还是自由变量,同理,你换成列表用append的方式也是一样的。

为了解决方法一中存在的问题,python3引入了nonlocal声明。它的作用就是把变量标记为自由变量,明确的告诉python解释器,这个变量是自由变量而非局部变量,即使在给它赋值,那也是自由变量。

正确的代码如下:

 1 def make_average():
 2     s, n = 0, 0
 3     def average(val):
 4         nonlocal s, n #标记为自由变量
 5         s += val
 6         n += 1
 7         return s/n
 8     return average
 9 
10 
11 avg = make_average()
12 print(avg(1))
13 print(avg(2))
14 print(avg(3))
15 print(avg(4))

 

装饰器和闭包

标签:targe   策略模式   话题   方法   term   注意   另一个   __call   info   

原文地址:https://www.cnblogs.com/forwardfeilds/p/10475306.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!