一、裝飾器

　　裝飾器本質就是一個python函式，它可以讓其他函式在不需要做任何程式碼變動的前提下，增加額外的功能，裝飾器的返回值也是一個函式物件。裝飾器的應用場景：插入日誌，效能測試，事務處理，快取等場景

　　二、裝飾器的形成過程

　　現在有個需求，想讓你測試這個函式的執行時間，在不改變這個函式的情況下。

　　1，簡單版裝飾器

import time
def fun():
    time.sleep(2)
    print('你好啊')

def test(f):
    def inner():
        start_time=time.time()
        f()
        end_time
 
=time.time()
        print(end_time-start_time)
    return inner
fun=test(fun)          #這個版本的雖然可以實現任何功能的測試，但每次函式執行前都得寫上這一句很是麻煩
fun()

　　2，語法糖

import time
def fun():
    time.sleep(2)
    print('你好啊')

def test(f):
    def inner():
        start_time=time.time()
        f()
        end_time=time.time()
        
 
print(end_time-start_time)
    return inner
@test           #相當於fun=test(fun)，只是裡面封裝好了的，以後測試函式就不用寫fun=test(fun),只需要在定義函式上面寫上@test就行
fun()

　　上面的裝飾器裝飾的函式都沒有引數，下面裝飾一個帶引數的裝飾器。

　　3，裝飾帶引數的函式

import time
def test(f):
    def inner(*args,**kwargs):
        start_time=time.time()
        f(*args,**kwargs)
        end_time
 
=time.time()
        print(end_time-start_time)
    return inner
@test
def fun():
    time.sleep(2)
    print('你好啊')

　　4，裝飾帶引數和有返回值的函式

import time
def test(f):
    def inner(*args,**kwargs):
        start_time=time.time()
        res=f(*args,**kwargs)
        end_time=time.time()
        print(end_time-start_time)
        return res
    return inner
@test
def fun1(a,s,d,f):
    return a+s+d+f

 　　對於上面的裝飾器來說，如果我要看函式的資訊，比如fun.__doc__檢視函式註釋的方法，fun.__name__檢視函式名，由於加上裝飾器後fun=inner，所以結果會有錯誤。下面解決

　　5，可以檢視函式資訊的裝飾器

import time
from functools import wraps
def test(f):
    @wraps(f)
    def inner(*args,**kwargs):
        start_time=time.time()
        res=f(*args,**kwargs)
        end_time=time.time()
        print(end_time-start_time)
        return res
    return inner
@test
def fun1(a,s,d,f):
    return a+s+d+f

　　三、裝飾器主要功能和固定結構

　　1，固定寫法

def timer(func):
    def inner(*args,**kwargs):
        '''執行函式之前要做的'''
        re = func(*args,**kwargs)
        '''執行函式之後要做的'''
        return re
    return inner

　　2，可以檢視函式資訊的

from functools import wraps

def deco(func):
    @wraps(func) #加在最內層函式正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

　　四、帶引數的裝飾器（是裝飾器袋引數）

　　比如說之前要求你為10個函式加上裝飾，你得在每個函式上面寫上@；一個月之後，不需要裝飾器了，你又要把每個函式上的@給去掉；沒過多久又讓你加上裝飾器；反覆新增，反覆刪除，這可是10萬個函式，很龐大的工程。其實現在給裝飾器加一個引數，很輕鬆就解決問題。

import time
def outer(flg):
    def test(f):
        def inner(*args,**kwargs):
            if flg:
                start_time=time.time()
            res=f(*args,**kwargs)
            if flg:
                end_time=time.time()
                print(end_time-start_time)
            return res
        return inner
    return test
flg=True       #flg為True時加上裝飾器，為False時不加裝飾器
@outer(flg)
def fun1(a,s,d,f):
    return a+s+d+f
r=fun1(2,3,4,5)
print(r)

　　五、多個裝飾器裝飾一個函式

def wrapper1(func):  func=f
    def inner1():
        print('wrapper1 ,before func')
        func()
        print('wrapper1 ,after func')
    return inner1

def wrapper2(func):  func=inner1
    def inner2():
        print('wrapper2 ,before func')
        func()
        print('wrapper2 ,after func')
    return inner2

@wrapper2     #f=wrapper2(f),現在後面的f已經變為inner1，f=inner2
@wrapper1     #f=wrapper1(f),f=inner1
def f():
    print('in f')

f()      #此時f為inner2
所以結果為：
wrapper2，before func
wrapper1，before func
in f
wrapper1，after func
wrapper2，after func

　　六、單例模式

　　單例模式就是一個類只能產生一個物件，就算產生多個物件，多個物件都是指向同一地址

class Person:
    __status=None
    def __new__(cls, *args, **kwargs):
        if not Person.__status:
            Person.__status=object.__new__(Person)
        return Person.__status
ob1=Person()
ob2=Person()
print(ob1)
print(ob2)