1.装饰器的定义
装饰器：给已有函数增加额外的功能的函数，本质上是一个闭包函数
特点：
- 1.不修改已有函数的源代码
- 2.不修改已有函数的调用方式
- 3.给已有函数增加额外的功能
- 4.代码执行时先解析装饰器
|
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
import time # 装饰器原理# def show():# n=0# for i in range(10000000):# n+=i# print('show_',n)## # 定义一个闭包# def count_time(fun):# def inner():# start=time.time()# fun()# end=time.time()# print(f'用时{end-start}秒')# return inner## # 装饰器在装饰函数时的原理# show=count_time(show)# show() # 定义装饰器（语法糖）def count_time(fun): # 必须要有一个参数接收被装饰函数 def inner(): start=time.time() fun() end=time.time() print(f'用时{end-start}秒') return inner# 装饰器写法：@闭包的外部函数，必须在闭包定以后使用print('解析装饰器1')@count_time # 解释成show=count_time(show)，show指向count_time函数中的innerdef show(): n=0 for i in range(10000000): n+=i print('show_',n) print('解析装饰器2')@count_time # 解释成display=count_time(display)def display(): print('Display') print('正式执行...')show()display() |
2.装饰器的通用类型的定义
（当被装饰函数有参数或者有返回值时同样适用）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
'''装饰器的通用类型的定义(当被装饰函数有参数或者有返回值时同样适用)''' def outer(func): def inner(*args,**kwargs): # *为元组和列表解包，**为字典解包 print('*'*30) print(args,kwargs) ret=func(*args,**kwargs) # 解包，否则形参是元组或字典 print('*'*30) return ret return inner @outerdef show(name,msg): return str(name)+' say: '+str(msg) print(show('Tom',msg='Hello')) |
3.多个装饰器同时装饰一个函数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
# 第一个闭包def wrapper_div(func): def inner(*args,**kwargs): return '<div>'+func(*args,**kwargs)+'</div>' return inner # 第二个闭包def wrapper_p(func): def inner(*args,**kwargs): return '<p>'+func(*args,**kwargs)+'</p>' return inner # 从下往上装饰，从上往下执行@wrapper_div@wrapper_p# 定义一个函数def show(): return 'Short life I use Python.' print(show()) #<div><p>Short life I use Python.</p></div> |
4.多个装饰器同时装饰一个函数（二）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
def outer1(func): def inner(): print('装饰器1-1') func() print('装饰器1-2') return inner def outer2(func): def inner(): print('装饰器2-1') func() print('装饰器2-2') return inner'''1.show指向outer1.inner2.outer1.inner.func指向outer2.inner3.outer2.inner.func指向show'''@outer1@outer2def show(): print('Show...') show() |
5.类装饰器使用方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
import time class Wrapper(): def __init__(self,func): self.func=func # 当类中实现了此方法时，该类的实例对象就变成了可调用对象，即可以在实例对象后面加() def __call__(self, *args, **kwargs): print('装饰内容1...') start=time.time() ret=self.func(*args,**kwargs) end=time.time() print(f'执行了{end-start}秒') print('装饰内容2...') return ret |
该装饰器执行完成后，被装饰函数指向该类的实例对象
如果让被装饰函数执行，那么在类中要添加__call__方法，相当于闭包格式中的内函数
一旦被装饰函数执行调用，那么就会去执行实例对象中的__call__函数
|
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
26
27
|
@Wrapper #解释成show=Wrapper(show),show变成了类的一个对象def show(): print('Show...') show()6.装饰器带有参数（使用带有参数的装饰器，其实是在装饰器外面又包裹了一个函数）# @Author : Kant# @Time : 2022/1/23 22:43 def set_args(msg): def outer(func): def inner(): print('装饰内容',msg) func() return inner return outer '''使用带有参数的装饰器，其实是在装饰器外面又包裹了一个函数，使用该函数接收参数，返回的是装饰器调用set_args()后会返回outer的地址引用，变成了@outer'''@set_args('Hello')# 无论闭包函数写成什么样子，被装饰函数永远指向闭包函数的内函数def show(): print('Show...') show() |
6.使用装饰器实现自动维护路由表
路由功能：通过请求的路径，可以找到资源的地址
|
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
# 定义一个路由表字典router_table={}def router(url): def wrapper(func): def inner(): print('1') print('inner-',func) # 查看当前的被装饰函数是谁 func() # 在这里维护路由表字典 router_table[url]=inner # 如果写func，inner函数中的内容都不会执行 print('路由表字典：',router_table) return inner return wrapper @router('index.html')def index(): print('首页内容') @router('center.html')def center(): print('个人中心') @router('mail.html')def mail(): print('邮箱页面') @router('login.html')def login(): print('登录页面') def error(): print('访问页面不存在') def request_url(url): func=error if url in router_table: func=router_table[url] func() print('开始执行函数')request_url('index.html')request_url('center.html')request_url('mail.html')request_url('test.html')request_url('login.html') |
到此这篇关于Python装饰器的定义和使用详情的文章就介绍到这了,更多相关Python装饰器内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://kantlee.blog.csdn.net/article/details/122684743
