编程语言
首页 > 编程语言> > python函数之闭包及装饰器

python函数之闭包及装饰器

作者:互联网

一、闭包

  1. 闭包的定义:

    • 闭包是嵌套在函数中的函数。

    • 闭包必须是内层函数对外层函数的变量(非全局变量)的引用。

      def make_average():
          li = []
          def average(price):
              li.append(price)
              total = sum(li)
              return total/len(li)
          return average
      avg = make_average()
      print(avg(100000)) # 100000.0
      print(avg(110000)) # 105000.0
      print(avg(120000)) # 110000.0

      1561097228948

      ​ 如上图当在函数嵌套时,第一层函数返回的是第二层函数的函数名,并且内层函数引用了第一层函数的变量的时候就形成了闭包。闭包函数的空间不会随着函数 的结束而消失,引用的变量被称为自由变量,也不会随函数的结束而消失。

  2. 如何判断闭包

    如果此函数拥有自由变量,那么就可以侧面证明其是否是闭包函数了

    # 对上个例子使用入下命令
    print(avg.__code__.co_freevars)
    # ('li',)

    通过以上命令可查看函数中是否存在自由变量

    # 拓展:查看其他变量名命令
    print(avg.__code__.co_varnames) # 查看局部变量
    # ('price', 'total')
    print(avg.__closure__ ) # 获取具体的自由变量
    # (<cell at 0x000001ACC81487F8: list object at 0x000001ACC83447C8>,)
    print(avg.__closure__[0].cell_contents) # 获取具体自由变量的值
    # [100000, 110000, 120000]
  3. 闭包的作用

    保存局部信息不被销毁,保证数据安全性

  4. 闭包的应用

    • 可以保存一些非全局变量但是不易被销毁和改变的数据
    • 装饰器的基础

二、装饰器

  1. 开放封闭原则

    • 软件面世时不可能将所有的功能都设计好,会定期进行更新迭代。对于软件之前的源码一般不会修改,对函数里面的代码以及函数的调用方式不会改变。

    • 封闭原则:不改变源码

    • 开放原则:更新增加一些额外的功能

      而装饰器完美的诠释了开放封闭原则

  2. 初识装饰器

    1. 定义:装饰器就是一个函数,他要装饰一个函数,在不改变原函数的源码及调用方式的前提下给其增加额外的功能

      • 有一个函数,现在要给其增加一个测试执行效率的功能

        def index():
            print('欢迎访问博客园')
      • 第一步:通过添加time模块进行测试

        import time
        def index():
            time.sleep(2)
            print('欢迎访问博客园首页')
        start_time = time.time()
        index()
        end_time = time.time()
        print(f'此函数的执行效率{end_time-start_time}')

        ​ 虽然这种方式完成了对此函数增加效率测试功能,但当需要对多个对象增加此项功能时,就会出现过多的代码重复

      • 第三步:通过能将功能封装在函数中来避免代码的重复

        import time
        def index():
            time.sleep(2)
            print('欢迎访问博客园首页')
        def test_time(x):
            start_time = time.time()
            x()
            end_time = time.time()
            print(f'此函数的执行效率{end_time- start_time}')
        test_time(index)

        ​ 虽然解决了代码重复问题,并且在不改变源码的前提下完成了给函数添加了功能,但改变了函数的调用方式

      • 第四步:通过闭包来达到使原函数的调用方式不变

        import time
        def index():
            time.sleep(2)
            print('欢迎访问博客园首页')
        def test_time(x):
            def inner():
                start_time = time.time()
                x()
                end_time = time.time()
                print(f'此函数的执行效率{start_time-end_time}')
            return inner
        ret = test_time(index)
        ret()

        ​ 此时虽然进行了闭包但是函数调用方式还是改变了

      • 第五步:将函数调用这一步直接赋给原函数的函数名

        import time
        def index():
            time.sleep(2)
            print('欢迎访问博客园首页')
        def test_time(x):
            def inner():
                start_time = time.time()
                x()
                end_time = time.time()
                print(f'此函数的执行效率{start_time-end_time}')
            return inner
        index = test_time(index)
        index()

        ​ 这样就完成了在不改变原函数源码以及调用方式的前提下,给函数增加了一项功能

    2. 通过语法糖加装装饰器

      import time
      def test_time(x):
          def inner():
              start_time = time.time()
              x()
              end_time = time.time()
              print(f'此函数的执行效率{start_time-end_time}')
          return inner
      @test_time
      def index():
          time.sleep(2)
          print('欢迎访问博客园首页')
      index()
  3. 被装饰的函数带返回值

    ​ 当被装饰函数带返回值时,由于装饰器实际执行的时inner函数,而inner函数并没有返回值,因此当被装饰函数带返回值时,直接用上述装饰器的话得到的返回值就是None。

    ​ 所以应对装饰器进行升级,对其增加返回值并且返回的应该是index函数的返回值

    import time
    def test_time(x):
        def inner():
            start_time = time.time()
            ret = x()
            end_time = time.time()
            print(f'此函数的执行效率{start_time-end_time}')
            return ret
        return inner
    @test_time
    def index():
        time.sleep(2)
        print('欢迎访问博客园首页')
        return 666
    index()     
  4. 被装饰的函数带参数

    ​ 当函数带参数时,同上面的原因,由于inner函数缺少形参函数执行时会报错,要使函数执行就需要给inner函数增加形参

    import time
    def test_time(x):
        def inner(*args,**kwargs):
            start_time =time.time()
            ret = x(*args,**kwargs)
            end_time = time.time()
            print(f'此函数的执行效率{start_time-end_time}')
            return ret
        return inner
    @test_time
    def index(1,2,3):
        time.sleep(2)
        print('欢迎访问博客园首页')
        return 666
  5. 标准版装饰器

    装饰器的格式:

    def warpper(f):
        def inner(*args,**kwargs):
            '''被装饰函数之前的操作'''
            ret = f(*args,**kwargs)
            '''被装饰函数之后的操作'''
            return ret
        return inner
  6. 带参数的装饰器

    ​ 举例说明,抖音:绑定的是微信账号密码。 qq:绑定的是qq的账号密码。 你现在要完成的就是你的装饰器要分情况去判断账号和密码,不同的函数用的账号和密码来源不同。

    ​ 由于之前写的装饰器只能接受一个参数就是函数名,所以现在要写一个可以接受参数的装饰器。

    def chioce(n):
        def wrapper(f):
            def inner(*args,**kwargs):
                if n== 'qq':
                    user_name = input('请输入用户名:').strip()
                    password = input('请输入密码:').strip()
                    with open('qq',encoding = 'utf-8') as f1:
                        for i in f1:
                            user, pwd = i.strip().split('|')
                            if user_name == user and pwd == password:
                                ret = f(*args,**kwargs)
                                return ret
                        print('用户名密码错误')
                 elif n == 'tiktok':
                    user_name = input('请输入用户名:').strip()
                    password = input('请输入密码:').strip()
                    with open('qq',encoding = 'utf-8') as f1:
                        for i in f1:
                            user, pwd = i.strip().split('|')
                            if user_name == user and pwd == password:
                                ret = f(*args,**kwargs)
                                return ret
                        print('用户名密码错误')
            return inner
        return wrapper
    @chioce('qq')
    def qq():
        print('成功访问qq')
    @chioce('tiktok')
    def tiktok():
        print('成功访问抖音')
    qq()
    tiktok()

    由于中间有一部分是重叠代码可进行简化:

    def chioce(n):
        def wrapper(f):
            def inner(*args,**kwargs):
                user_name = input('请输入用户名:').strip()
                password = input('请输入密码:').strip()
                with open(n,encoding = 'utf-8') as f1:
                    for i in f1:
                        user, pwd = i.strip().split('|')
                        if user_name == user and pwd == password:
                            ret = f(*args,**kwargs)
                            return ret
                    else:
                        print('用户名密码错误')
            return inner
        return wrapper
    @chioce('qq')
    def qq():
        print('成功访问qq')
    @chioce('tiktok')
    def tiktok():
        print('成功访问抖音')
    qq()
    tiktok()

    将文件名用传进去的参数n代替,可通过n直接判断调用的使哪个函数的文件

  7. 多个装饰器装饰一个函数

    有如下代码分析最后打印的结果:

    def wrapper1(func1): # func1 == f函数
        def inner1():
            print('wrapper1,before func') # 2
            func1() # 3
            print('wrapper1,after func') # 4
        return inner1
    def wrapper2(fun2): # func2 == inner1
        def inner2():
            print('wrapper2,before func') # 1
            func2() # func2 == inner1
            print('wrapper2,after func') # 5
        return inner2
    @wrapper2    # f = wrapper2(f)中里面的f==inner1 外面的f==inner2
    @wrapper1    # f = wrapper1(f)中里面的f==func1 外面的f==inner1
    def f():
        print('in f')
    f()
    结果:
    wrapper2,before func
    wrapper1,before func
    in f
    wrapper1,after func
    wrapper2,after func

    1561448814943

  8. 递归函数

    递归函数:函数或者其他代码都可以解决递归解决的问题,但是递归在某些时候能出奇制胜的效果,人理解函数,神理解递归。其实递归就是函数本身调用他自己

    举例:

    def age(n):
        if n == 1:
            return 18
        else:
            return age(n-1)+2
    print(age(4))
    结果:
    24 # 18+2+2+2

    可通过sys.setrecursionlimit查看电脑递归次数上限:

    import sys
    import sys
    print(sys.setrecursionlimit(10000000))
    def func(n):
        print(n)
        n += 1
        print(666)
        func(n)
    func(1)

    将如下列表中的每项元素打印出来:

    l1 = [1, 3, 5, ['太白','元宝', 34, [33, 55, [11,33]]], [77, 88],66]
    def func(n):
        for i in n:
            if type(i) == list:
                fun(i)
             else:
                print(i)
    func(l1)

标签:return,函数,包及,python,之闭,inner,time,print,def
来源: https://www.cnblogs.com/yaoqi17/p/11084589.html