Python 闭包 装饰器

 

目录 

1.基础知识点

2.闭包

3.装饰器

 

正文

1.基础知识点------函数可以作为参数传给另一个函数

#将函数作为参数传给另一个函数
def test1(name):
    print("函数test1")
    return name()

def test2():
    print("函数test2")

test1(test2)
"""
函数test1
函数test2
"""

调用函数test1(test2),传入的参数是函数test2

注意test2作为参数，不能加（），才可以被到处传递。如果加了括号，就是调用test2函数了。

例如，下面的test2加括号，就是先调用test2()函数，再执行test1()函数了。

def test1(name):
    print("函数test1")

def test2():
    print("函数test2")

test1(test2())
"""
函数test2
函数test1
"""

 

2.闭包  Closure

①什么是闭包？

 ----嵌套函数：即外层函数里面又定义了一个内层函数

 ----内层函数调用了外层函数的非全局变量

 ----外层函数的返回值：是内层函数名

以上3个条件同时满足，就构成了一个闭包。

这么说有点抽象，举个栗子：

def outer(a):
    print("这是外层函数")
    def inner():
        b=a+1
        print("这是内层函数")
        print(b)
    return inner

outer(3)()

"""

这是外层函数
这是内层函数
4

"""

调用outer(3)得到的结果是打印【这是外层函数】并返回inner ；

outer(3)()就是在outer(3)的基础上再次调用内层函数，得到最后的结果。

 

上面的知识都基本理解了，下面讲解重点内容：装饰器

 

3.装饰器

①什么是装饰器？

装饰器本身也是一个函数或者类，可以新增一些被装饰函数/类的功能，简化代码。

②装饰器的分类：上面的定义可知，有函数装饰器 、类装饰器---------（被装饰的对象可以是函数，也可以是类）

注意：装饰器来装饰函数或者类，被装饰的函数或类的原功能是不变的，会增加一些新的功能；

           其次，被装饰的函数或者类的调用方式是不会变的-----切记

 

③装饰器的语法糖

    被装饰的函数/类名 = 装饰器名（被装饰的函数/类名）

怎么理解这句话，来看个栗子：

#装饰器原理
def fun1(func):

    def fun2():
        print("执行func()函数之前")
        func()
        print("执行func()函数之后")

    return fun2

def fun3():
    print("这是功能函数")

fun3()

print("-------分割线---------")

fun3=fun1(fun3)   #被装饰的函数 = 装饰器名（被装饰的函数名）
fun3()
"""
这是功能函数
-------分割线---------
执行func()函数之前
这是功能函数
执行func()函数之后
"""

 

④函数装饰器实例1-----被装饰的函数，无参数

def login(a):
    print("这是登录函数")
    def recharge():
        a()
        print("这是充值函数")
    return recharge

@login
def withdraw():
    print("这是取现函数")


withdraw()
"""
登录函数
取现函数
充值函数
"""

怎么理解上面的调用步骤：

根据语法糖公式：只要withdraw函数被装饰，那么@login 就等价于 withdraw = login(withdraw)  ====》输出 "登录函数” 和 返回recharge变量

withdraw() = login(withdraw)()==recharge()=====>recharge()函数中的a()就是withdraw(),最后的结果如上。

 

④函数装饰器实例2-----被装饰的函数，有参数

还是上面的装饰函数login（）

def login(a):
    print("这是登录函数")
    def recharge():
        a()
        print("这是充值函数")
    return recharge

要对下面的函数withdraw(p,q)进行装饰，应该怎么修改上面的装饰函数？

def withdraw(p,q):
    print("这是取现函数")

修改步骤：

首先要装饰withdraw(p,q),先在函数上面添加@login；

那么，根据装饰器的语法糖公式：withdraw = login（withdraw）=recharge ;

要调用withdraw() ,那么withdraw（p,q） = login（withdraw）(p,q) =recharge(p,q)

所以，只要修改内层函数为recharge(j,k)即可完成装饰函数的修改。

#2.被装饰函数有参数
def login(a):
    print("这是登录函数")
    def recharge(j,k):
        print("这是充值函数")
        return a(j,k)

    return recharge

@login
def withdraw(p,q):
    print("这是取现函数")
    return p+q

print(withdraw(3,4))
"""
这是登录函数
这是充值函数
这是取现函数
7
"""

在实际项目应该中，参数可能有0个或者多个，那么就用到了可变长参数（动态参数）：

元祖形式的可变长参数*args,   和字典形式的**kwargs，如下

添加计时器功能（自动化中用计时器的功能非常多，在这里提及一下）

#2.被装饰函数有参数
import time
def login(a):
    print("这是登录函数")
    def recharge(*args,**kwargs):
        time_before =time.time()
        res= a(*args,**kwargs)
        time_after = time.time()
        ti = time_after-time_before
        print(ti) #计时器功能
        print("这是充值函数")
        return res

    return recharge

@login
def withdraw(p,q):
    print("这是取现函数")
    return p+q


print(withdraw(3,4))
"""
这是登录函数
这是充值函数
0.0
这是取现函数
7
"""

 

④函数装饰器实例3-----被装饰的类，无参数

def login(a):
    print("这是登录函数")
    def recharge():
        a()
        print("这是充值函数")
       
    return recharge

还是上面login这个函数装饰器，要对一个类进行装饰，应该怎么修改装饰器？

@login
class MyClass:
    def withdraw(self):
        print("这是取现函数")

首先，在类的上面添加@login

类里面的实例方法的调用，首先要初始化一个对象MyClass(),对象再去调用里面的方法，即MyClass().withdraw()

同理，语法糖公式：MyClass = login(MyClass)=recharge 

那么 ,要初始化对象MyClass()，则MyClass()=login(MyClass)（）=recharge （），即最后是调用recharge()函数，就是要修改内层函数。

那么怎么修改？最后要实现MyClass().withdraw(), 所以recharge()函数的返回值要是一个MyClass()对象，也就是return a() -----a是login的形参，装饰后传入的就是MyClass

#3被装饰的是一个类
def login(a):
    print("这是登录函数")
    def recharge():
        print("这是充值函数")
        return a()

    return recharge

@login   #MyClass() = login(MyClass)() =recharge()
class MyClass:
    def withdraw(self):
        print("这是取现函数")

MyClass().withdraw()
"""
这是登录函数
这是充值函数
这是取现函数
"""

 

⑤类装饰器实例1---装饰函数

魔术方法 ：__call__(),只有在类的对象加上括号的时候，才会触发

举个栗子：

class MyClass:
    def __call__(self,*args,**kwargs):
        print("这个是魔术方法")


MyClass()()  #类的对象加上括号，触发call方法
#这个是魔术方法

那么，由上面的类，给下面的函数装饰，应该怎么修改类装饰器呢？

⑤类装饰器

@MyClass
def fun():  
    print("功能函数")

函数的调用就是fun()

公式: fun=MyClass(fun) -->则类里面要传个参数啊----》参数哪里传？__init__()传参数啊。即类里面添加一个__init__()进行初始化

又 fun()=MyClass(fun)()，即MyClass(fun)()对象又加一个括号，会触发call方法，所以要在call方法中去调用被装饰的函数，就可以实现不影响原功能函数的功能，又可以新增功能啦

class MyClass:

    def __init__(self,a):
        self.a = a

    def __call__(self,*args,**kwargs):
        self.a()
        print("这个是魔术方法")


@MyClass
def fun():  #fun()=MyClass(fun)()
    print("功能函数")

fun()
"""
功能函数
这个是魔术方法
"""

 

⑤类装饰器实例2---装饰类

class MyClass:

    def __init__(self,a):
        self.a = a

    def __call__(self,*args,**kwargs):
        print("这个是魔术方法")
        return self.a()


@MyClass  #B()=MyClass(B)()
class B:
    def fun(self):
        print("B类的实例方法")

类B中的方调用是B().fun()

B()=MyClass(B)()，触发call（）方法，不影响原来的类的调用，在call中，直接将a()返回即可。

 

⑥对装饰器进行传参----定义三层函数，最外层函数的返回值是第二层函数名

在接口自动化中，数据驱动ddt,就是装饰器传参，对参数做了一系列的处理，将每条数据传入内层函数中。

下面来探究装饰器传参的原理。

def var(name):
    def test1(a):
        print("test1函数")
        def test2(b):
            for i in name:
                a(i)
            print("test2函数")
        return test2
    return test1

@var([1,2,3])  #var([1,2,3])=test1 ---> fun()=test1(fun)()=test2(b)
def fun(b):
    print("正在执行第{}条测试用例".format(b))

fun(2)
"""
test1函数
正在执行第1条测试用例
正在执行第2条测试用例
正在执行第3条测试用例
test2函数
"""

装饰器传参数，在最外层函数传参。

@var([1,2,3])传入参数是列表[1,2,3],  var([1,2,3])=test1,按照装饰器的语法糖，在内层函数中调用了a(),就是调用fun().

在这个基础上，增加了for循环。-----仿照ddt数据驱动

 

⑦多个装饰器的执行顺序-----------原理从下往上，执行从上往下

def test1(fun1):
    def wrapper1():
        fun1()
        print("装饰器1")
    return wrapper1

def test2(fun2):
    def wrapper2():
        fun2()
        print("装饰器2")
    return wrapper2

@test1     #wrapper2=test1(wrapper2)
@test2     #fun=test2(fun)=wrapper2
def fun():
    print("功能函数")

fun()

"""

功能函数
装饰器2
装饰器1

"""

原理讲解：fun()函数被test1()、test2()装饰，按照原理从下往上，fun函数先被test2()装饰，再被test1装饰时，test1装饰的其实就是wrapper2

装饰原理从下往上，写出公式。

 

@test1     #wrapper2=test1(wrapper2)
@test2     #fun=test2(fun)=wrapper2


执行按照从上往下：wrapper2()=test1(wrapper2)()
首先wrapper2()的执行结果是： 
功能函数
装饰器2 
再看，test1装饰wrapper2，即test1中转入的参数是wrapper2,最后输出的结果如上代码的输出结果

⑧装饰器的应用

1).计时          装饰器中实现计时功能，在自动化测试中，可以用来计时（装饰器中实现计时、调用原函数、计时，计算时差，实现计时功能）

2).前置、后置条件。装饰器中实现前置条件(比如打开浏览器)，再调用原函数，实现后置条件（关闭浏览器）-----装饰器中调用原函数的前后各实现钱之后只条件即可

3).鉴权 比如登录 充值

   关联：只有先登录-->才能进行充值

 装饰器函数或者类，实现登录功能，获取token/session; 被装饰的充值函数，会自动获取token/session

 

 举个栗子（写个大致的过程）：

#导入session类
from requests import Session

#初始化一个session对象
s=Session()

#装饰器-实现登录功能
def login_success(fun):
    URL = "www.douban.com"
    json={"username":"kkk","password":"123456"}
    method = "post"
    def wrapper():
        s.post(url=URL,json=json,method=method)
        fun()
    return wrapper

@login_success
def recharge():
    res=s.post()

上面的例子，s这个对象属于全局变量，闭包使用的是非全局变量，那么可以用装饰器传参数的方式，将Session()对象作为参数，这样的话，闭包内部函数引用的就是外层函数的非全局变量。

如下：登录和充值是同一个session会话。-----登录装饰器给充值用例装饰

#导入session类
from requests import Session
#装饰器-实现登录功能
def var(s):
    def login_success(fun):
        URL = "www.douban.com"
        json={"username":"kkk","password":"123456"}
        method = "post"
        def wrapper():
            s.post(url=URL,json=json,method=method)
            fun()
        return wrapper
    return login_success

@var(Session())   #=@login_success
def recharge():
    res=s.post()