在学习装饰器之前我们先了解下什么是闭包。

闭包

• 函数引用

def test1(): print("--- in test1 func----")# 调用函数test1()# 引用函数ret = test1print(id(ret))print(id(test1))#通过引用调用函数ret()

运行结果：

--- in test1 func----140212571149040140212571149040--- in test1 func----

我们发现 test1() 和 test1 是有区别的,前者是直接调用函数,后者只是函数的引用.

• 闭包

# 定义一个函数def test(number): # 在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包 def test_in(number_in): print("in test_in 函数, number_in is %d" % number_in) return number+number_in # 其实这里返回的就是闭包的结果 return test_in# 给test函数赋值，这个20就是给参数number,此时ret是 test_in 的引用ret = test(20)# 注意这里的100其实给参数number_inprint(ret(100))#注 意这里的200其实给参数number_inprint(ret(200))

运行结果:

in test_in 函数, number_in is 100120in test_in 函数, number_in is 200220

闭包实例

假如我们要求直线 y=ax+b 的长度.

# 第1种k = 1b = 2y = k*x+b# 缺点：如果需要多次计算，那么就的写多次y = k*x+b这样的式子y = k * 1 + by = k * 2 + b# 第2种def line_2(k, b, x): print(k*x+b)line_2(1, 2, 0)line_2(1, 2, 1)line_2(1, 2, 2)line_2(3,4,0)line_2(3,4,1)line_2(3,4,2)# 缺点：如果想要计算多次这条线上的y值，那么每次都需要传递k，b的值，麻烦print("-"*50)# 第3种: 全局变量k = 1b = 2def line_3(x): print(k*x+b)line_3(0)line_3(1)line_3(2)k = 11b = 22line_3(0)line_3(1)line_3(2)# 缺点：如果要计算多条线上的y值，那么需要每次对全局变量进行修改，代码会增多，麻烦print("-"*50)# 第4种：缺省参数def line_4(x, k=1, b=2): print(k*x+b)line_4(0)line_4(1)line_4(2)line_4(0, k=11, b=22)line_4(1, k=11, b=22)line_4(2, k=11, b=22)# 优点：比全局变量的方式好在：k, b是函数line_4的一部分 而不是全局变量，因为全局变量可以任意的被其他函数所修改# 缺点：如果要计算多条线上的y值，那么需要在调用的时候进行传递参数，麻烦print("-"*50)# 第5种：实例对象class Line5(object): def __init__(self, k, b): self.k = k self.b = b def __call__(self, x): print(self.k * x + self.b)line5_1_2 = Line5(1, 2)# 对象.方法()# 对象()line5_1_2(0)line5_1_2(1)line5_1_2(2)line5_11_22 = Line5(11, 22)line5_11_22(0)line5_11_22(1)line5_11_22(2)line5_1_2(3)# 缺点：为了计算多条线上的y值，所以需要保存多个k, b的值，因此用了很多个实例对象， 浪费资源print("-"*50)# 第6种：闭包def line_6(k, b): def create_y(x): print(k*x+b) return create_yline_6_1 = line_6(1, 2)line_6_1(0)line_6_1(1)line_6_1(2)line_6_2 = line_6(11, 22)line_6_2(0)line_6_2(1)line_6_2(2)

可以发现:

• 匿名函数能够完成基本的简单功能,只有简单功能.
• 普通函数能够完成较为复杂的功能,只有功能.
• 闭包能够完成较为复杂的功能,包含功能和数据,传递的是数据+功能(即外层函数能保存接收的数据给里面的函数使用)
• 对象能够完成最复杂的功能,包含很多数据和很多功能,传递的是数据+功能
• 闭包也具有提高代码可复用性的作用.
• 注意:由于闭包引用了外部函数的局部变量,导致外部函数的局部变量没有及时释放而消耗内存.

修改外部函数中的变量

# 使用关键字 nonlocal 即可修改外部函数的变量def func1(a): def func2(): nonlocal a a += 1 return a return func2

装饰器

装饰器本质上就是闭包,装饰器在不改变原函数的定义的条件下,给原函数扩展功能.

下面我们来分析这段代码:

1 def out(func):2 def inner():3 print('正在装饰')4 func()5 return inner6 @out7 def test():8 print('我被装饰啦!')9 test()

func 的执行调用过程

1. 第1行:out 装饰器函数
2. 第6行:底层实现 test = out(test) ,不会执行,需要等待
3. 第7行:定义 func 函数对象
4. 第6行:先执行右边,在执行左边.func-->test,test-->inner
5. 第9行:test(),本质上调用 inner()
6. 第3行
7. 第4行
8. 第8行

多个装饰器装饰一个函数

def message(func): print("1. 正在添加短信的装饰功能") def message_pay(): print("----正在做短信安全验证-----") func() return message_paydef gesture(func): print("2. 正在添加手势的装饰功能") def gesture_pay(): print("----正在做手势密码安全验证---") func() return gesture_pay# 短信安全验证 和 手势密码安全验证@gesture # pay = gesture(pay)@message # pay = message(pay)def pay(): print("---正在支付中---")# 装饰器装饰函数是自动执行pay()

打印结果:

1. 正在添加短信的装饰功能2. 正在添加手势的装饰功能----正在做手势密码安全验证-------正在做短信安全验证--------正在支付中---

• 装饰的顺序:从内到外,就和我们平时穿衣服一样
• 执行的顺序:从外到内,就和我们平时脱衣服一样

类装饰器

# 类对象可以的当做 装饰器函数class Person(object): def __init__(self, func): self.func = func def __call__(self, *args, **kwargs): # print("我被调用啦哟") self.func()# 类装饰器@Person # t = Person(t) 将函数当做参数传递 __init__() takes 1 positional argument but 2 were givendef t(): print("我是被装饰函数....")# 'Person' object is not callable# 调用对象 需要实现 __call__方法t()

类装饰器平时用的较少,了解即可

带参数的装饰器

def set_level(level): def set_fun(func): def call_func(): if level == 1: print("正在做手势安全验证.....") elif level == 2: print("正在做短信验证码验证.....") func() return call_func return set_fun@set_level(1) # 1. 调用函数 set_level(1), 返回set_fun, 2. 让set_fun作为装饰器函数 login = set_fun(login)def login(): print("-----正在登陆中-------")@set_level(2)def pay(): print("-----正在支付中-------")login()pay()

带参数的装饰器可以这样理解:,最外层将相当于一般的函数,只是将参数给里面的装饰器,实际上里面的闭包才是装饰器.

私信我获取 python 全套资料