1. 程式人生 > >02python 裝飾器(python函式)

02python 裝飾器(python函式)

裝飾器的形成過程


      20           1
import
time
2
 
         
         
          
          
           3
           
          
         
 
         
         
          
          
           4
           
          
         
def func():                      # 定義一個函式
5
    time.sleep(0.01)
6
    print('hello world!')
7
 
         
         
          
          
           8
           
          
         
 
         
         
          
          
           9
           
          
         
def timer(f):                    # 一個閉包函式,接收一個函式,也叫做裝飾器函式
10
    def inner():
11
        start = time.time()
12
        f()                      # 被裝飾函式
13
        end = time.time()
14
        print(end - start)
15
    return inner
16
 
         
         
          
          
           17
           
          
         
 
         
         
          
          
           18
           
          
         
func = timer(func)
19
func()
20
 
         
        
       
      
     
    
   
     
    
   
     
    
   
  
 

  
 

 裝飾器的定義:把接收函式作為引數,以及返回內部函式的函式稱之為裝飾器函式        
 

 

語法糖的概念


      20           1
import time
2
 
         
         
          
          
           3
           
          
         
 
         
         
          
          
           4
           
          
         
def timer(f):                    # 一個閉包函式,接收一個函式,也叫做裝飾器函式
5
    def inner():
6
        start = time.time()
7
        f()                      # 被裝飾函式
8
        end = time.time()
9
        print(end - start)
10
    return inner
11
 
         
         
          
          
           12
           
          
         
 
         
         
          
          
           13
           
          
         
@timmer                          # 語法糖 @裝飾器函式名
14
def func():                      # 被裝飾函式   # 定義一個函式   # func = timer(func)
15
    time.sleep(0.01)
16
    print('hello world!')
17
 
         
         
          
          
           18
           
          
         
    
19
# func = timer(func)
20
func()                           # 在呼叫的時候只要呼叫func()即可!這才是裝飾器
     
再次進化        (被裝飾的函式有返回值)

      55           1
import time
2
 
         
         
          
          
           3
           
          
         
 
         
         
          
          
           4
           
          
         
def timer(f):
5
    def inner():
6
        start = time.time()
7
        f()
8
        end = time.time()
9
        print(end - start)
10
    return inner
11
 
         
         
          
          
           12
           
          
         
 
         
         
          
          
           13
           
          
         
@timer
14
def func():
15
    time.sleep(0.01)
16
    print('hello world!')
17
    return ‘pontoon on the way!
18
 
         
         
          
          
           19
           
          
         
ret = func()
20
print(ret)
21
 
         
         
          
          
           22
           
          
         
>>>hello world!
23
0.010217905044555664
24
None        # 列印的結果是None,而不是pontoon on the way!,因為這裡接收的是inner函式裡面的返回值,而inner函式裡面並沒有返回值
25
 
         
         
          
          
           26
           
          
         
 
         
         
          
          
           27
           
          
         
-------------------------------------------------------------------------------------------------------------------------------------------------------
28
import time
29
 
         
         
          
          
           30
           
          
         
 
         
         
          
          
           31
           
          
         
def timer(f):
32
    def inner():
33
        start = time.time()
34
        ret = f()                   # 得到傳遞過來函式的返回值
35
        end = time.time()
36
        print(end - start)
37
        return ret                  # 返回
38
    return inner
39
 
         
         
          
          
           40
           
          
         
 
         
         
          
          
           41
           
          
         
@timer
42
def func():
43
    time.sleep(0.01)
44
    print('hello world!')
45
    return 'pontoon on the way!'
46
 
         
         
          
          
           47
           
          
         
 
         
         
          
          
           48
           
          
         
# func = timer(func)
49
ret = func()
50
print(ret)
51
 
         
         
          
          
           52
           
          
         
>>>hello world!
53
0.010081291198730469
54
pontoon on the way!
55
 
         
        
       
      
     
    
   
     
    
   
     
    
   
  
 

  
 
 
 
究極進化        (被裝飾的函式有引數)


      49           1
import time
2
 
         
         
          
          
           3
           
          
         
 
         
         
          
          
           4
           
          
         
def timer(f):
5
    def inner(*args, **kwargs):
6
        start = time.time()
7
        ret = f(*args, **kwargs)        # 得到傳遞過來函式的返回值
8
        end = time.time()
9
        print(end - start)
10
        return ret                      # 返回
11
    return inner
12
 
         
         
          
          
           13
           
          
         
 
         
         
          
          
           14
           
          
         
@timer
15
def func(a, b):
16
    time.sleep(0.01)
17
    print('hello world!')
18
    return 'pontoon on the way!'
19
 
         
         
          
          
           20
           
          
         
 
         
         
          
          
           21
           
          
         
# func = timer(func)
22
ret = func(1, 2)                        # 這裡相當於執行inner()
23
print(ret)
24
 
         
         
          
          
           25
           
          
         
-----------------------------------------------------------------------------------------------
26
# 簡化之
27
import time
28
 
         
         
          
          
           29
           
          
         
 
         
         
          
          
           30
           
          
         
def wrapper(f):
31
    def inner(*args, **kwargs):
32
        ret = f(*args, **kwargs)        # 得到傳遞過來函式的返回值
33
        retu