裝飾器

靈魂三問

• 1.什麼事裝飾器
  器 => 工具
  裝飾 => 指的是為被裝飾的物件新增新功能

  裝飾器本身可以是任意可呼叫的物件 => 函式
  被裝飾的物件也可以是任意可呼叫的物件 => 函式
  目標：寫一個函式來為另一個函式新增新功能

• 2.為何要用裝飾器
  開放封閉原則：軟體一旦上線就應該對修改封閉，對擴充套件開發
  對修改封閉：
  - 1.不能修改功能的原始碼
  - 2.也不能修改功能的呼叫方式
  對擴充套件開發：
  - 可以為原有的功能新增新的功能
  裝飾器就是要在不修改功能原始碼以及呼叫方式的前提下為員功能新增額外新的功能

• 3.如何用裝飾器

• 如何用裝飾器：

import time

def index():
    print('welcome to index page')
    time.sleep(2)

def outter(func):       #給index功能裝飾一個檢測執行時間的新功能
    #func = 最原始那個index的記憶體地址
    def wrapper():
        start = time.time()
        func()   #最原始那個index的記憶體地址()
        stop = time.time()
        print ('run time is %s'
 
 %(stop-start))
    return wrapper

index = outter(index)     #index = outter(原始那個index的記憶體地址)   #index = wrapper函式的記憶體地址
index()  #wrapper 偷樑換柱，現在的index是wrapper的記憶體地址

• 裝飾器修正1

如果需要index的返回值，上面如果res = index() 實際上是 res = wrapper()

import time

def index():
    print('welcome to index page')
    time.
 
sleep(2)
    return 123

# ===================================================

def outter (func):
    #func = 最原始那個index的記憶體dizh
    def wrapper():
        start = time.time()
        res = func()    #最原始那個index的記憶體地址    把func的返回值指向res
        stop = time.time()
        print('run time is %s' %(stop-start))
        return res       #wrapper的返回值和最原始index的返回值相同
    return wrapper
index = outter(index)    #index = outter(最原始那個index的記憶體地址)  #index = wrapper函式的記憶體地址

# ===================================================

res = index()   #res = wrapper()
print(res)

• 裝飾器修正2

之前被裝飾的函式是無引數的函式，如果被裝飾的函式是有引數的函式

import time

def index():
    print('welcome to index page')
    time.sleep(3)
    return 123

def home(name):
    print('welcome %s to home page' %name)
    time.sleep(1)

# ===================================================

def outter(func):
    #func = 最原始那個home的記憶體地址
    def wrapper (*args,**kwargs):     #用了之前學的*和**的用法
        start = time.time()
        res = func(*args,**kwargs)       #如果被裝飾的函式需要引數，可以把wrapper的引數傳給被裝飾的函式做引數
        stop = time.time()
        print('run time is %s' %(stop-start))
        return res
    return wrapper

index = outter(index)    #index = outter(最原始那個index的記憶體地址) #index = wrapper函式的記憶體地址
home = outter(home)   #home = outter(最原始那個home的記憶體地址) #home = wrapper函式的記憶體地址

# ===================================================

home('wood')   #wrapper('wood')
index()  #wrapper

• 裝飾器的語法糖

之前寫的裝飾器最後都要把被修飾的函式名偷樑換柱給outter
index = outter(index)
home = outter(home)
如果多個函式需要用到這個裝飾器，我們就要寫很多的像上面那樣的程式碼
這要寫重複的東西不是很low，python怎麼能low呢
這裡有一個裝飾器的語法糖的概念

# @裝飾器的名字:要在被裝飾物件正上方單獨一行寫上

import time

def timmer(func):           #寫一個裝飾器
    def wrapper(*args,**kwargs):
        start = time.time()
        res = func(*args,**kwargs):
        stop = time.time()
        print('run time is %s' %(stop-start))
        return res
    return wrapper

@timmer         #@後+裝飾圈的函式名，直接使用省了index = outter(index) 
def index():
    '''這是index功能 '''
    print('welcome to index page')
    time.sleep(2)
    return 123

@timmer       #@後+裝飾圈的函式名，直接使用省了index = home(index) 
def home(name):
    '''這是home功能 '''
    print('welcome %s to home page' %name)
    time.sleep(1)

print(help(index))     #wrapper的註釋
print(index.__name__)     #wrapper的名字

上面程式碼有一個新問題，函式有一些方法：
help可以調函式的註釋
.__name__調函式名
還有很多.__的方法。
這個時候用了裝飾器 index已經不是原來的index了，
現在index指的是wrapper的記憶體地址了，
想神不知鬼不覺的再調最原始的index方法怎麼辦

#from functools import wraps方法
from functools import wraps      #呼叫這個方法

import time

def timmer(func):           #寫一個裝飾器
    @wraps(func)       #在wrapper上面寫一個@wraps(func)把最原始函式的那些都調過來
    def wrapper(*args,**kwargs):
        start = time.time()
        res = func(*args,**kwargs):
        stop = time.time()
        print('run time is %s' %(stop-start))
        return res
    return wrapper

@timmer         #@後+裝飾圈的函式名，直接使用省了index = outter(index) 
def index():
    '''這是index功能 '''
    print('welcome to index page')
    time.sleep(2)
    return 123

@timmer       #@後+裝飾圈的函式名，直接使用省了index = home(index) 
def home(name):
    '''這是home功能 '''
    print('welcome %s to home page' %name)
    time.sleep(1)

print(help(index))      #這就顯示index的註釋
print(index.__name__)    #index的名字

• 無參裝飾器

根據上面的裝飾器可以確定一個無參裝飾器的模板

#無參裝飾器的模板
def outter(func):
    def wrapper(*args,**kwargs):
        res = func(*args,**kwargs)
        return res
    return wrapper

用這個寫一個認證功能

import time

user_info = {'current_user':None}    #變數值是可變的

def auth(func):
    def wrapper(*args,**kwargs):
        if user_info['current_user'] is not None:
            res = func(*args,**kwargs)     
            return res      #return會結束函式
        inp_user = input('username>>>: ').strip()
        inp_pwd = input('password>>>: ').strip()
        if inp_user == 'egon' and inp_pwd == '123':
            # 記錄登入狀態
            user_info['current_user']=inp_user

            print('login successful')
            res = func(*args,**kwargs)
            return res
        else:
            print('user or password error')
    return wrapper

@auth
def index():
    """這是index功能"""
    print('welcome to index page')
    time.sleep(2)
    return 123

@auth
def home(name):
    """這是home功能"""
    print('welcome %s to home page' %name)
    time.sleep(1)

• 有參裝飾器

之前我們說的都是無參裝飾器，裝飾器本身不需要引數的，引數都是為了轉給或轉到原函式的，現在說有參裝飾器，除了需要轉給原函式的引數外，裝飾器本身的功能也需要引數的情況

def outter2(xxx,yyy):
    #區域性內的兩個閉包函式的引數都是不能動的，在需要xxx，yyy就需要在往上找了，不能找到全域性作用域去吧
    #再包一下，三層閉包函式，最外層的給xxx，yyy傳值
    def outter(func):
        def wrapper(*args,**kwargs):
            res = func(*args,**kwargs)
            print(xxx)
            print(yyy)
            return res
        return wrapper
    return outter

我們上面的裝飾器是把認證的來源寫死了，如果我們是從檔案中呼叫資料來認證，如果我們是從mysql資料庫裡呼叫資料，ldap裡面呼叫資料

import time

user_info = {'current_user':None}

def auth2(engine = 'file'):    #定義一個預設形參，engine預設=‘file’
    def auth(func):
        def wrapper(*args,**kwargs):
            if user_info['current_user'] is not None:
                res = func(*args,**kwargs)
                return res
            inp_user = input('username>>>: ').strip()
            inp_pwd = input('password>>>: ').strip()

            if engine == 'file':
                print('基於檔案的認證')
                if inp_user == 'egon' and inp_pwd == '123':
                    # 記錄登入狀態
                    user_info['current_user']=inp_user

                    print('login successful')
                    res=func(*args,**kwargs)
                    return res
                else:
                    print('user or password error')
            elif engine == 'mysql':
                print('基於mysql資料的認證')
            elif engine == 'ldap':
                print('基於ldap的認證')
            else:
                print('無法識別認證源')
        return wrapper
    return auth

@auth2(engine = 'mysql') # @auth ===> index=auth(最原始那個index的記憶體地址)===》index=wrapper
def index():
    """這是index功能"""
    print('welcome to index page')
    time.sleep(2)
    return 123

@auth2(engine = 'file')
def home(name):
    """這是home功能"""
    print('welcome %s to home page' %name)
    time.sleep(1)

index() #wrapper()
home('egon')

• 補充作用域，global與nonlocal

x = 1
def func():
   x = 2

func()
print(x)     #x在全局裡找，x=1  1是整型不能在區域性直接改


x = []
def func():
   x.append(1)
   x.append(2)
   x.append(3)

func()
print(x)     #x是列表，是可變的，可以在區域性直接改

# global: 在區域性宣告變數是全域性變數
x = 1
def func():
    global x       #global我就是要改
    x = 2

func()
print(x)      #print 2

# nonlocal:在區域性宣告變數是外層函式的變數，如果外層沒有，就在往更外存找，知道在外層的函式
x = 333
def f1():
    x = 222
    def f2():
        x = 111
        def f3():
            nonlocal x
            x = 0
        f3()
        print('f2內部的x: ',x)
    f2()
    print('這是f1內部的x: ',x)

f1()
print(x)