python基础17-闭包函数-无参装饰器

2022/7/7 1:20:20

本文主要是介绍python基础17-闭包函数-无参装饰器,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

今日学习

闭包函数简介

闭包函数的实际应用

装饰器简介

装饰器推导流程(重要)

装饰器功能完善

装饰器统一使用模板(通用)

装饰器语法糖

装饰器修复计数(待补充)

闭包函数概念

1.定义在函数内部的函数

2.内部函数使用了外部函数名称空间的名字

ps:只有符合上述两个特征的函数才能称为闭包函数
---------------------------
def warapper(username):               #定义warapper函数 username是形参
    #username = 'jason'      
    def index():
        print(username)
    return index

res()

闭包函数的实际应用

import requests
 
#方式一:
def get(url):
    return requests.get(url).text
 
#方式二:
def page(url):                1. #url为形参,page(https:xx实参)相
    def get():                2. #还未调用不看。
        return requests.get(url).text       3. #get获取(url)形参位
    return get                   4.#返回get

# 方式一下载同一页面
get('https://www.python.org')
get('https://www.python.org')
get('https://www.python.org')
……
 
# 方式二下载同一页面
python=page('https://www.python.org')      #将page('https://www.python.org')传给python
python()
python()
python()
……

装饰器

可以理解为:闭包+函数对象+嵌套

在不改变被装饰对象原来的调用方式内部代码的情况下,给被装饰对象添加新的功能

  • 装饰器推导

    -------------------------问题运行代码块并打印出代码块运行时间--------------------------
    # 改变了代码冗余问题(函数传参)
    import time
    #
    # 需求,打印
    # #函数传参 案例一
    # def index(x, y):
    #
    #     start = time.time()
    #     time.sleep(3)
    #     print('index %s %s' % (x, y))
    #     stop = time.time()
    #     print(stop - start)
    # index(111,222)
    #但是需求一次,我们就要做一次print打印,代码冗余繁琐。将print和time优化成函数体
    ------------------------------------------------------------
    
    # #函数传参 方案二
     def index(x,y):
          time.sleep(3)
          print('index %s %s' % (x, y))
     def wrapper():
         start = time.time()
         index(1111, 2222,111) #太死板,如果有改变的话,代码会冗余,位置实参不填写正确也会报错。
         stop = time.time()
         print(stop - start)
     wrapper()
    #此时我们将index(1111, 2222,111)打印需求修改,还有改代码。
    ----------------------------------------------------------------------------
     方案3:方案三优化一  将index(x,y)传参,设置wrapper
    
    # 函数传参
     def index(x,y):
          time.sleep(3)
          print('index %s %s %s' % (x, y))
     def wrapper(g,z):
         start = time.time()
         index(g,z)
         stop = time.time()
         print(stop - start)
    # 打印
     wrapper(111,2223)
        
    -----------------------------------------------------------------------------------
    # 方案3优化二 优化wrapper函数,将index方案写活了
    
     def index(x,y,z):
          time.sleep(2)
          print('index %s %s %s' % (x, y, z))
    
     def wrapper(*args,**kwargs):
         start = time.time()
         index(*args,**kwargs)      #warapper  灵活了,但是index比较死板,如果是再新增home功能,
         stop = time.time()          # 还要再多写一遍函数体,所以尽可能的把index给做成变量。
         print(stop - start)
     wrapper(111,2223,33333)
    -----------------------------------------------------------------------------------
    
    # 方案3优化三#除了将设置warapper函数体后,将函数体内的index优化为传参。
    def index(x, y, z):
        time.sleep(2)
        print('index %s %s %s' % (x, y, z))
    	print(index)
    
    def outer(func):
        def wrapper(*args, **kwargs):
            start = time.time()
            func(*args, **kwargs)  # func实参成为了index,(*args,**kwargs)变为(x,y,z)
            stop = time.time()
            print(stop - start)
        return wrapper
    
    index = outer(index)      #新定义index变量
    index(11,22,33)         
    # func(11,22,33)
    # 1.将index函数 赋值传给上面函数体中的func形参中,此时outer函数形参传给内层函数体(wrapper)下的func
    
  • 推导总结

    1.统计某个函数的运行时间
    2.将统计函数运行时间的代码封装成了函数
    3.直接封装成函数会改变调用方式
    4.利用闭包函数传参尝试
    5.利用重名替换原来函数名的功能
    6.函数的参数
    7.函数的返回值装饰器各种版本
    
  • 装饰器各个版本

    import time
    def home():
        time.sleep(2)
        print('from home')
        return '执行home函数之后的返回值' 
    
    """针对有参无参函数如何兼容"""
    def outer(xxx):
        def get_time(*args, **kwargs):
            start_time = time.time()  
            res = xxx(*args, **kwargs)  
            end_time = time.time()
            print('函数的执行时间是:', end_time - start_time)
            return res
        return get_time
    
    # @outer#装饰语法糖  #home = outer(home)
    home = outer(home)        #outer(home)将home传参给outer(xxx)
    xxx = home()
    print(xxx)
    
    ------------------执行结果--------------------------------
    from home
    函数的执行时间是: 2.008957624435425
    执行home函数之后的返回值
    
    ----------------装饰器叙述总结----------------------
    1.首先定义了home代码功能块,然后outer为无参装饰器(可以理解为嵌套函数outer(xxx)函数体);
    
    2.因为xxx为形参位,outer(home) 就是home作为实参传入xxx形参中。
    3. 闭包函数内层中res = xxx(*args, **kwargs)  相当于 res = home()
    4.res变量 返回结果给get_time
    5.get_time函数返回结果
    6.定义一个新的home变量 home = outer(home)
    7.home()调用
    

拓展小知识-return

  • def add(x, y):
        z = x + y
        return  z
    # print(add(x, y))       #不加return  返回none
    print(add(1,2))  
    -----结果------
    3
    --------------------
    return返回值只能通过print打印才会显示出来,但在交互式模式下不需要print打印-------
    return的作用之一是返回计算的值
    
  • 固定模板

    ---------------- 使用方法  模板 +@outer+代码块-------------------
    
    from functools import wraps               #装饰器的修复技术
    def outer(func_name):
        @wraps(func_name)  # 仅仅是为了让装饰器不容易被别人发现 做到真正的以假乱真
        def inner(*args, **kwargs):
            print('执行被装饰对象之前可以做的额外操作')
            res = func_name(*args, **kwargs)
            print('执行被装饰对象之后可以做的额外操作')
            return res
        return inner
    
    
    
  • 装饰器语法糖

    # 装饰器语法糖
    import time
    
    @outer  #  home = outer(真正的函数名home)
    def home():
        '''我是home函数 我要热死了!!!'''
        time.sleep(1)
        print('from home')
        return 'home返回值'
    
    # help(home)
    # print(home)
    home()
    
    # def index():
    #     '我是index函数 我的功能很强大'
    #     pass
    #
    # help(index)
    


这篇关于python基础17-闭包函数-无参装饰器的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程