Python-装饰器

一、闭包函数

闭包函数=函数嵌套定义+函数对象+名称空间与作用域

闭包函数：在函数中（嵌套）定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生闭包。

1、闭：指的是该函数是定义在一个函数内部的函数
2、包：值得是该函数访问了一个来自于外层函数的变量

为函数体传参的方法：

'''方案一：直接使用参数的形式传递'''
def wrapper(x):
    print(x)

wrapper(111)
wrapper(222)
'''方案二：把函数体想要的参数包给它(即使用闭包的概念)'''
def outter(x):
    def wrapper():  # wrapper = 闭包函数的内存地址
        print(x)

    return wrapper  # 一定不要加括号

f1 = outter(111)  # f = 闭包函数的内存地址
f2 = outter(222)  # f = 闭包函数的内存地址
f1()
f2()
-----------
111
222

乍一看会感觉使用闭包来传参数非常的麻烦，我们之前使用函数，需要参数都是直接传给他，方便也快捷，但是在某些场景下我们定死了某个函数无法直接传参数，那就必须通过其他方式传参数，即闭包的方式，下面介绍的装饰器就是闭包的使用。

二、@符号的使用

@符号作用: 
(1) 可以自动把@符号下面的函数当成参数传递给装饰器
(2) 把新函数进行返回,让新函数去替换旧函数,以实现功能的扩展.
如：
@timer  # 等于func1 = timer(func1)，其目的是为了让使用者不改变调用方式，它依然在调用func1，但是实际已经被我们换成了timer
def func1():
  print(1)

三、叠加多个装饰器的运行步骤

结论：(记住结论既可)

加载顺序:自下而上
执行顺序:自上而下运行内层的wrapper函数

验证过程：

# 叠加多个装饰器
def deco1(func1):  # func1 = wrapper2的内存地址
    def wrapper1(*args,**kwargs):
        print('wrapper1====>')
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1

def deco2(func2):  # func2 = wrapper3的内存地址
    def wrapper2(*args,**kwargs):
        print('wrapper2====>')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

def deco3(func3):  # func3 = 最原始的那个被装饰函数的内存地址
    def wrapper3(*args,**kwargs):
        print('wrapper3====>')
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3

        # index=wrapper1的内存地址
@deco1  # deco1(wrapper2的内存地址)=>wrapper1的内存地址
@deco2  # deco2(wrapper3的内存地址)=>wrapper2的内存地址
@deco3  # deco3(最原始的那个被装饰函数的内存地址)=>wrapper3的内存地址  
def index(x,y):
    print('index=>',x,y)

index(1,2)
-----------------------
wrapper1====>'
wrapper2====>
wrapper3====>
index=>1,2

四、无参装饰器

什么是装饰器：

器：工具
装饰：为被装饰者添加额外的功能

为何要有装饰器：

软件一旦上线运行之后，就应该遵循开放封闭原则：
1、开放指的是对拓展新功能开放
2、封闭指的是对修改源代码封闭
这种情况下，我们在写新功能时，若需要用到新的参数，就无法直接通过原函数来传了，必须通过其他方式来传参，目前我们想到的方法，是两种传参的另一种的方式，闭包函数

定义装饰器的目的：
定义装饰器就是为了在遵循1和2的前提下来为其他函数添加新功能的

ps：
不修改被装饰对象指的是定义与调用都不能修改
所以下述行为都违反了开放封闭原则：
①、修改被装饰对象定义时的源代码
②、修改被装饰对象的调用方式

如何用装饰器：

'''无参装饰器基本格式'''
def wrapper(func):
    def inner(*args,**kwargs):
        res = func(*args,**kwargs)
        return func
    return inner 
  '''
  切记不能在此处加括号，加括号就代表运行,相当于先把inner运行一遍，然后拿到返回值return出去.
  return 出去的值是无法加括号在运行的。
  '''
# 例子
def wrapper(func):
    def inner(*args,**kwargs):
        res = func(*args,**kwargs)
        return res
    return inner()  # 切记不能在此处加括号，加括号就代表运行

@wrapper
def func1():
    print(11)

func1()
-----------------
11
TypeError: 'NoneType' object is not callable

'''
前面打印出来的11其实是运行wrapper里的inner产生的，所以以上程序的运行流程是
1.先把func1传给wrapper,然后运行了wrapper中的代码，返回 inner()
2.inner() 就开始执行inner函数，即运行了一遍func1，所以打印了11
3.此时的func1 = inner()  而inner()又等于func1(),func1没有返回值，默认返回None
4.变成了None(),报错
'''

无参装饰器的应用场景以及构建装饰器步骤：

需求：有一个index函数，此时我们要在index函数基础上添加一个计算运算时间的功能，因为是公司项目，我们不能修改原函数的调用方式，也不能修改源代码。

# 一、被装饰器对象index如下
import time

def index(x,y):
    time.sleep(1)
    print("index---->",x,y)

index(1,2)

# 二、为index添加计算运算时间与登录功能
import time
from functools import wraps

def timmer(func):
    def wrapper(*args,**kwargs):
        start = time.time()
        res = func(*args,**kwargs)
        end = time.time()
        print(end-start)
        return res
    return wrapper

def login(func):
    def wrapper(*args,**kwargs):
        name = 'yang'
        pwd = '123'
        inp_name = input("请输入您的用户名：").strip()
        inp_pwd = input("请输入您的密码").strip()
        if inp_name == name and inp_pwd == pwd:
            print("登录成功")
            res = func(*args,**kwargs)
            return res
    return wrapper

@timmer
@login
def index(x,y):
    time.sleep(1)
    print("index---->",x,y)

index(1,2)

五、有参装饰器

对于不再需要新参数的装饰器，两层就可以解决了，但是当我们的装饰器需要新的参数，如在登录的时候，我们要判断我们用户名与密码的来源，此时需要外部将来源传进来。而两层的装饰器中，第一层，是为了给原函数传参数，他的参数不能动，而第二层，因为装饰器语法@的原因，也已经定死了此处只能传一个函数名，也不能传参数，所以我们需要构造第三层来接受外部的参数，而在内部的函数可以在不改动自己依然可以获取到外层的函数.

'''有参装饰器模版'''
def outter2(x,y,z,a,b):
    def outter1(func):
        def wrapper(*args,**kwargs):
            res=func(*args,**kwargs)
            return res
        return wrapper
    return outter1

例子:

def outter(engine = 'file'):
    def deco2(func2):
        def wrapper2(*args,**kwargs):
            inp_name = input('username>>>: ').strip()
            inp_pwd = input('password>>>: ').strip()

            if engine == "file":
                print('基于file的认证')
                if inp_name == "egon" and inp_pwd == "123":
                    print('login successful')
                    res2=func2(*args,**kwargs)
                    return res2
                else:
                    print('username or password error')
            elif engine == 'mysql':
                print('基于mysql的认证')
            elif engine == 'ldap':
                print('基于ldap的认证')
            else:
                print('未知的engine')
        return wrapper2
    return deco2

@outter(engine='mysql')  # @deco2 # index=deco2(index)
def index(x,y):
    print('index=>',x,y)

index(1,2)  # index=>wrapper

六、类装饰器

我们也可以用类来装饰函数

# 利用类静态方法装饰
class MyClass:
    @staticmethod
    def zhuangshi1(func):
        def newfunc():
            print("装饰前")
            func()
            print("装饰后")
        return newfunc

    def __call__(self, *args, **kwargs):
        return self.zhuangshi2(*args, **kwargs)

    def zhuangshi2(self,func):
        def newfunc():
            print('装饰前')
            func()
            print('装饰后')
        return newfunc


# 利用类静态方法，本质和原来的用函数装饰一样
@MyClass.zhuangshi1
def func1():
    print('运行func1')

func1()

# 利用__call__方法
@MyClass()
def func2():
    print('运行了func2')

func2()