zoukankan      html  css  js  c++  java
  • python高级-闭包-装饰器

    闭包内容:

    1. 匿名函数:能够完成简单的功能,传递这个函数的引用,只有功能

    2. 普通函数:能够完成复杂的功能,传递这个函数的引用,只有功能

    3. 闭包:能够完成较为复杂的功能,传递这个闭包中的函数以及数据,因此传递是功能+数据

    4. 对象:能够完成最复杂的功能,传递很多数据+很多功能,因此传递的是数据+功能

    5. 很多人学习python,不知道从何学起。
      很多人学习python,掌握了基本语法过后,不知道在哪里寻找案例上手。
      很多已经做案例的人,却不知道如何去学习更加高深的知识。
      那么针对这三类人,我给大家提供一个好的学习平台,免费领取视频教程,电子书籍,以及课程的源代码!
      QQ群:1097524789

    ———————————————————

    1. 对全局函数进行修改:在函数当中加global,在闭包中外边中的变量加nonlocal

    2. 闭包定义:有两个函数嵌套使用,里面的函数可以使用外面函数所传输的参数,最后可传递的是里面函数的结构与数据(个人理解)。

    3. 最后闭包可以在python中引申出装饰器 ———————————————————

     1 def closure():
     2     # 在函数内部再定义一个函数,
     3     # 并且这个函数用到了外边函数的变量,那么将这个函数以及用到的一些变量称之为闭包
     4     def closure_in(x):
     5         print('---------我是打不死的%s--------' %x)
     6     return closure_in
     7 ​
     8 x = closure()
     9 x('小强')
    10 ​
    11 print('*'*20)
    12 # -----加餐---------
    13 def closure_1(a,b,c):
    14     def closure_on(x):
    15         print('-----%s加餐-------' %b)
    16         print(a*x + c)
    17     return closure_on
    18 ​
    19 demo = closure_1(2,'小强',3) #传closure_1函数
    20 demo(4) #传clsure_on函数
    21 ​
    22 #注:函数不加括号,调用的是函数本身【function】;函数加括号,调用的是函数的return结果。
    

    装饰器内容:

    代码要遵守‘开放封闭’原则;对已经写好的函数遵守封闭,对功能扩展遵守开放;

     1 # 装饰器的作用:为了对原来的代码上进行扩展
     2 def decoration(func):
     3     def call_func():
     4         print('-------正在装饰 -------' )
     5         func()
     6     return call_func
     7 ​
     8 #@decoration     #--->demo_new = decoration(demo)
     9 def demo():
    10    print('demo----')
    11 ​
    12 demo_new = decoration(demo)
    13 demo_new()
    

    使用装饰器来测试一个函数的运行时:

     1 import time
     2 def set_func(func):
     3     def call_func():
     4         start_time = time.time()
     5         func()
     6         stop_func = time.time()
     7         print(‘alltimes is %f’ %(stop_func-start_fun))
     8     return call_func
     9 @set_func
    10 def test1():
    11     print(‘——-test1———’)    
    12 test1()
    13 ​
    14 #等价于:
    15 @set_func==test1 = set_func(test1)
    16 ​
    

    1. 没有参数,没有返回值的函数进行装饰:

     1 def set_func(func):
     2     def call_func():
     3         print(‘———test2——-’)
     4         print(‘———-test3——’)
     5         func()
     6     return call_func
     7     
     8 @set_func
     9 def test1():
    10     print(‘——test1——-   ’)
    

    2. 对有参数无返回值的函数进行装饰:

     1 def set_func(func):
     2     def call_func(a):  #变
     3         print(‘———test2——-’)
     4         print(‘———-test3——’)
     5         func(a) #变
     6     return call_func
     7     
     8 @set_func
     9 def test1(num):
    10     print(‘——test1——- %d    ’ %num)
    11 ​
    12 test1(100) —->call_func(100)
    13 test1(200)——>call_func(200)
    

    复现装饰器原理:

    ————————————————————————-

    只要遇到@函数 装饰器(这句话),在程序中就已经执行了!!

    3. 不定长参数的函数装饰:

     1 def set_func(func):
     2     def call_func(*args,**kwargs):  #变
     3         print(‘———test2——-’)
     4         print(‘———-test3——’)
     5         func(*args,**kwargs) #(拆包)将元祖拆开,每个进行传输;
     6         #func(args,kwargs)—>不行,相当于传递了两个参数:一个元祖,一个字典。
     7     return call_func
     8     
     9 @set_func
    10 def test1(num,*args,**kwargs):
    11     print(‘——test1——- %d    ’ %num)
    12     print(‘——test1——-   ’ , args)
    13     print(‘——test1——- ’ ,kwargs )
    14     
    15 test1(100)  
    16 test1(100,200)
    17 test1(100,200,300,mm=100)
    
    
    

    注意: *args 保存不定长参数,以元祖保存, **kwargs 保存字典形式(mm=...)

    4.对应的返回值参数进行装饰、通用装饰器:

     1 #通用装饰器
     2 def set_func(func):
     3     print(“开始进行装饰———-”)
     4     def call_func(*args,**kwargs):  #变
     5         print(‘———test2——-’)
     6         print(‘———-test3——’)
     7         return func(*args,**kwargs) #(拆包)将元祖拆开,每个进行传输;如果没有return ret返回none。
     8         #func(args,kwargs)—>不行,相当于传递了两个参数:一个元祖,一个字典。
     9     return call_func
    10     
    11 @set_func
    12 def test1(num,*args,**kwargs):
    13     print(‘——test1——- %d    ’ %num)
    14     print(‘——test1——-   ’ , args)
    15     print(‘——test1——- ’ ,kwargs )
    16     return ‘ok’    #—-返回给上面的func(),然后return func—ret
    17     
    18 ret = test1(100)
    19 ​
    

    5. 多个装饰器对同一个函数进行装饰:

     1 def add_qx(func):
     2     print(“——开始进行装饰权限1———-”)
     3     def call_func(*args,**kwargs):  #变
     4         print(‘这是权限验证1’)
     5         return func(*args,**kwargs)
     6     return call_func
     7     
     8 ​
     9 def add_xx(func):
    10     print(“——开始进行装饰xx功能———-”)
    11     def call_func(*args,**kwargs):  #变
    12         print(‘这是xx权限验证’)
    13         return func(*args,**kwargs)
    14     return call_func
    15     
    16 @add_qx
    17 @add_xx
    18 def test1():
    19     print(‘——test1——-’) 
    20 ​
    21 test1()
    22 ​
    

    首先执行第一个,但是第一个装饰器下面不是函数(装饰器原则:下面必须是函数,否则不执行),所以第一个函数先等待,等第二个装饰器执行后形成函数在交给第一个装饰器;所以运行结果是:

    1. 开始进行装饰xx的功能,

    2. 开始进行装饰权限1,

    3. 这是权限验证1,

    4. 这是xx权限验证,

    5. ——- test1 ——-,

    ——————装饰器练习—————- 输出格式: <td><h1>haha</h1></td>

     1 def set_func_1(func):
     2     def call_func():
     3         return ‘<h1>’ + func() + ’</h1>’
     4     return call_func
     5     
     6 ​
     7 def set_func_2(func):
     8     def call_func():
     9         return ‘<td>’ + func() + ’</td>’
    10     return call_func
    11     
    12 @set_func_1()
    13 @set_func_2()
    14 def get_str():
    15     return ‘haha’
    16     
    17 print(get_str()) 
    
    
    18 最后执行的效果: <h1><td>haha</td></h1>
    

    6. 用类对函数进行装饰(了解):

     1 class Test(object):
     2     def __init__(self,func):
     3         self.func = fun
     4         
     5     def __call__(self):
     6         print(‘这里是装饰器的功能。。。。’)
     7         return self.func()
     8         
     9 @Test
    10 def get_str():
    11     return ‘haha’
    12     
    13 print(get_str())
    

    以上就是装饰器与闭包的全部内容,希望有所收获,如果有错误,希望指出,感谢!!

  • 相关阅读:
    高精度计算
    高精度除以低精度
    P1258 小车问题
    POJ 2352 stars (树状数组入门经典!!!)
    HDU 3635 Dragon Balls(超级经典的带权并查集!!!新手入门)
    HDU 3938 Portal (离线并查集,此题思路很强!!!,得到所谓的距离很巧妙)
    POJ 1703 Find them, Catch them(确定元素归属集合的并查集)
    HDU Virtual Friends(超级经典的带权并查集)
    HDU 3047 Zjnu Stadium(带权并查集,难想到)
    HDU 3038 How Many Answers Are Wrong(带权并查集,真的很难想到是个并查集!!!)
  • 原文地址:https://www.cnblogs.com/shann001/p/13202523.html
Copyright © 2011-2022 走看看