python基础__装饰器修饰器

装饰器处理逻辑

当解释器读到@装饰符，会先解析@下一行的内容，把下一行的函数或者类作为@后边的函数的参数，执行被装饰的函数。

例子1：被修饰函数不带参数

 1 def log(func):
 2     def wrapper():
 3         print('log开始 ...')
 4         func()
 5         print('log结束 ...')
 6     return wrapper
 7 
 8 @log
 9 def test():
10     print('test ..')
11 
12 test()

例子2：被修饰函数带参数

 1 from functools import wraps
 2 def log(func):
 3     @wraps(func)
 4     def wrapper(*args,**kwargs):
 5         print('log开始 ...',func.__name__)
 6         ret = func(*args,**kwargs)
 7         print('log结束 ...')
 8         return ret
 9     return wrapper
10     
11 @log
12 def test1(s):
13     print('test1 ..', s)
14     return s
15 
16 @log
17 def test2(s1, s2):
18     print('test2 ..', s1, s2)
19     return s1 + s2
20 
21 test1('a')
22 test2('a','bc')

例子3：修饰符带参数，需要比上面例子多一层包装

 1 from functools import wraps
 2 
 3 def log(arg):    
 4     def _log(func):
 5         @wraps(func)
 6         def wrapper(*args,**kwargs):
 7             print('log开始 ...',func.__name__, arg)            
 8             ret = func(*args,**kwargs)
 9             print('log结束 ...')
10             return ret
11         return wrapper
12     return _log
13  
14 @log('module1')
15 def test1(s):
16     print('test1 ..', s)
17     return s
18 
19 @log('module1')
20 def test2(s1, s2):
21     print('test2 ..', s1, s2)
22     return s1 + s2
23 
24 
25 test1('a')
26 test2('a','bc')

 

在函数定义中我们返回函数，为什么是函数名，而不是函数名()？

这是因为当把一对小括号放在后面，这个函数就会执行；如果不放括号在函数后面，那函数可以被到处传递，并且可以赋值给别的变量而不去执行它。

 

 

 

中国人的人生意义可以用一个具体的词来形容：牵挂！

当你离开这个世界的时候，心中满是自己牵挂的人和事，如果一个人了无牵挂，那这个人也是不怕死的。