• Python之迭代器、生成器、装饰器和递归

    一、迭代器&生成器
    1.迭代器
    迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
    迭代器只能往前不会后退，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

    特点：

    1. 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
    2. 不能随机访问集合中的某个值 ，只能从头到尾依次访问
    3. 访问到一半时不能往回退
    4. 便于循环比较大的数据集合，节省内存空间
    在变量加入iter，设置成一个迭代器，在迭代器中“_next_” 一个功能可用。
    例子：
    1. #!/usr/bin/env python
    2. # -*-coding:utf-8 -*-
    3. names = iter(['feng','soft','worter'])
    4. print(names)
    5. print(names.__next__())
    6. print(names.__next__())
    7. print(names.__next__())
    8. #print(names.__next__())
    执行结果
    1. <list_iterator object at 0x00000000021CB208>
    2. feng
    3. soft
    4. worter
    由于names里面有三个元素此时候在执行第四次就会报错，具体如下：
    1. #!/usr/bin/env python
    2. # -*-coding:utf-8 -*-
    3. names = iter(['feng','soft','worter'])
    4. print(names)
    5. print(names.__next__())
    6. print(names.__next__())
    7. print(names.__next__())
    8. print(names.__next__())
    执行结果
    1. <list_iterator object at 0x00000000027BB438>
    2. Traceback (most recent call last):
    3. feng
    4.   File "E:/Python/S12/day4/didaiqi.py", line 8, in <module>
    5. soft
    6.     print(names.__next__())  
    7. worter
    8. StopIteration  看见这个报错
    9. Process finished with exit code 1
    和读取文件中的for line in f: print line的过程类似，不是一次性把所有文件读入内存。
    2.生成器（generator）
    一个函数调用时返回是一个迭代器，那这个函数就叫做生成器（generator），如果函数中包含yield语法，那这个函数就会变成生成器

    作用：yield可以使函数中断，并保存中断状态，中断后，代码可以继续往下执行，过一段时间还可以再重新调用这个函数，从上次yield的下一句开始执行。

    例子：
    1. #!/usr/bin/env python
    2. # -*-coding:utf-8 -*-
    3. def cash_money(amount):
    4.     while amount > 0 :
    5.         amount -= 100
    6.         yield  100
    7.         print("过来取钱了啦")
    8. atm = cash_money(500)
    9. print(type(atm))
    10. print(atm.__next__())
    11. print(atm.__next__())
    12. print('testset')
    13. print(atm.__next__())
    执行结果：
    1. <class 'generator'>
    2. 100
    3. 过来取钱了啦
    4. 100
    5. testset
    6. 过来取钱了啦
    7. 100
    9. Process finished with exit code 0
    对于上面例子的结论：当执行到100的时候，while里面的print的就不执行了，当第二次执行_next_的时候，才会执行print，然后再while一次，还是执行到yield就返回了。
    另外，还可通过yield实现在单线程的情况下实现并发运算的效果。
    例子：
    1. #!/usr/bin/env python
    2. # -*-coding:utf-8 -*-
    3. import  time
    4. def consumer(name): # 消费者
    5.     print('%s 准备吃包子了！' %name)
    6.     while True:
    7.         baozi = yield
    8.         print("包子[%s]来了，被[%s]吃了！" %(baozi,name))
    9. def producer(name): #供方
    10.     c = consumer('zhangs')
    11.     d = consumer('li')
    12.     c.__next__()
    13.     d.__next__()
    14.     print('顾客要吃包子，开始做包子啦！')
    15.     for i in range(10):  #range 0-9
    16.         time.sleep(1)  #程序停止1秒
    17.         print('做了两个！')  
    18.         c.send(i)  #和前面的yield进行配合。
    19.         d.send(i)
    20. producer('feng')
    以上大体的执行过程：首先producer函数被调用，赋值”feng“,开始执行producer函数，分别将consumer赋值，定义为c、d，执行c._next_()，跳到cusumer生成器，执行print，进入while循环，”baozi“后面的yiled无输入值，此时c的第一次挂起，这时候d执行同样的操作，同样挂起，这时候c.__next__()、d.__next__()都执行完成了，开始执行print，for循环，执行到c.send(i)时候，由于给予c发送了一个生成器值，执行会返回到baozi，并赋予了i的值，往下执行print,在执行d.send(i),随着for 循环i一直变化，send一直向yield输送值，直到整个过程完成。整体就形成了交互式的异步信息传递。
    执行结果：
    1. zhangs 准备吃包子了！
    2. li 准备吃包子了！
    3. 顾客要吃包子，开始做包子啦！
    4. 做了两个！
    5. 包子[0]来了，被[zhangs]吃了！
    6. 包子[0]来了，被[li]吃了！
    7. 做了两个！
    8. 包子[1]来了，被[zhangs]吃了！
    9. 包子[1]来了，被[li]吃了！
    10. 做了两个！
    11. 包子[2]来了，被[zhangs]吃了！
    12. 包子[2]来了，被[li]吃了！
    13. 做了两个！
    14. 包子[3]来了，被[zhangs]吃了！
    15. 包子[3]来了，被[li]吃了！
    16. 做了两个！
    17. 包子[4]来了，被[zhangs]吃了！
    18. 包子[4]来了，被[li]吃了！
    19. 做了两个！
    20. 包子[5]来了，被[zhangs]吃了！
    21. 包子[5]来了，被[li]吃了！
    22. 做了两个！
    23. 包子[6]来了，被[zhangs]吃了！
    24. 包子[6]来了，被[li]吃了！
    25. 做了两个！
    26. 包子[7]来了，被[zhangs]吃了！
    27. 包子[7]来了，被[li]吃了！
    28. 做了两个！
    29. 包子[8]来了，被[zhangs]吃了！
    30. 包子[8]来了，被[li]吃了！
    31. 做了两个！
    32. 包子[9]来了，被[zhangs]吃了！
    33. 包子[9]来了，被[li]吃了！
    二、装饰器

    函数的默认反馈值是None
    先来个例子：
    1. def login(func1): #这个时候的（func1）参数为（tv('func2')）
    2.     def inner(arg):
    3.         print('passswd user verification.........')
    4.         func1(arg) #arg等价于func2
    5.   #      return func()
    6.     return  inner  #此处的inner为一个函数体  #编号1
    7. @login  #等价于 login(tv)
    8. def tv(name):
    9.     print('welcome to tv')
    11. tv('func2')
    执行结果：
    1. C:Python34python.exe E:/Python/zhuangshiqi.py
    2. passswd user verification.........
    3. welcome to tv
    这个事要细细道来。
    装饰器实际是将要执行的函数进行了包含进去了，执行过程是先执行自己的函数，先到自己的第一层，使用编号为1的跳入自己的函数，先执行完后在执行实际的函数。过程有些绕，在顺着教和我请教的大神的说法顺下：
    1.首先第一点说明很重要，很重要、很重要：变量定义和调用。
    @函数名 是python的一种语法糖。如上面例子所示，@login 实际上是将@login是当有人去调用@login 下面的参数时作为自己的一个参数执行了，如例子所示当程序判断有人要执行tv('func2')参数时，这时候发现def tv(name)上面有@login 时就开始执行@login 参数了。此时将tv作为原来的login参数带入，即此时login(func1)中的func1开始等于tv变成了如下代码。
    1. login(tv('func2')): #这个时候的（func1）参数为（tv('func2')）
    2.     def inner(arg):
    3.         print('passswd user verification.........')
    4.         func1(arg)
    5.   #      return func()
    6.     return  inner  #此处的inner为一个函数体  #编号1
    2.执行第一步
    在执行login函数时，发现def inner函数，直接跳到return函数，注意后面有个inner,并把inner返回给login（注意这个时候tv== func1这个函数还没执行呢），这里的inner代表的是一个函数，并非执行函数。同时跳到调用tv函数的地方去判断是否有赋值，有则取出，这个时候把func2取过来啦。

    3.执行第二步
    根据上一步return的返回值，此时login就会跳入到inner这个函数里面了（注意第一步的return值必须是第二层函数体的名字），同时会把tv(func2)抽取出来，也就是说这个时候arg == func2 ，执行第一步print，然后执行func1(arg)（刚刚说过func1在第一步就被tv替换了,arg被第二步的func2替换了）
    4.执行第三步
    刚刚说过由于func1已经被tv取代，arg 已经被func2取代，因此在执行func1(arg) == tv('func2'),此时会直接跳入tv(name)函数执行里面的内容。

    总结：
    配置装饰器过程中:
    1.在第一层的return必须是返回第二层的函数名。
    2.执行的函数有一个参数，第二层就需要有几个参数。

    copy过来的：
    一个参数的：
    def w1(func):
    def inner(arg):
        # 验证1# 验证2# 验证3return func(arg)
    return inner

@w1
def f1(arg):
    print 'f1'

    两个参数的：
    def w1(func):
    def inner(arg1,arg2):
        # 验证1# 验证2# 验证3return func(arg1,arg2)
    return inner

@w1
def f1(arg1,arg2):
    print 'f1

    三个参数的：

    def w1(func):
    def inner(arg1,arg2,arg3):
        # 验证1# 验证2# 验证3return func(arg1,arg2,arg3)
    return inner

@w1
def f1(arg1,arg2,arg3):
    print 'f1'


    下面这个重要:
    装饰N个参数的。
    1. def w1(func1):
    2.     def inner1(*args,**kwargs):
    3.         print('ONE')
    4.         return func1(*args,**kwargs)
    5.     return inner1
    7. def w2(func2):
    8.     def inner2(*args,**kwargs):
    9.         print('TWO')
    10.         return func2(*args,**kwargs)
    11.     return inner2
    14. @w1
    15. @w2
    16. def f1(arg1,arg2,arg3):
    17.     print('tset222')
    18.     return  f1
    20. test = f1('one','two','three')
    21. print(test)
    执行结果
    1. C:Python34python.exe E:/Python/S12/day4/zhuangshiqi.py
    2. ONE
    3. TWO
    4. tset222
    5. <function w1.<locals>.inner1 at 0x00000000021FCC80> （这个啥意思？）
    执行过程是先执行@w1，在执行@w2，，先顺序的对@w1、@w2第一层执行一遍，然后再一次执行第二层，执行完第二层后会再次跳到@w1，利用刚刚赋值的参数，去执行f1里面的参数。


    一个函数被多个装饰器装饰




    三、递归   
    在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
    来自百度经验：程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。而递归函数无非是在指定的条件下做普通的循环而已。
    递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。
    递归算法解决问题的特点：
    (1) 递归就是在过程或函数里调用自身。
    (2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
    (3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
    (4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

    递归文件，要比上一次处理的问题要小。

    要求

    递归算法所体现的“重复”一般有三个要求：
    一是每次调用在规模上都有所缩小(通常是减半)；
    二是相邻两次重复之间有紧密的联系，前一次要为后一次做准备(通常前一次的输出就作为后一次的输入)；
    三是在问题的规模极小时必须用直接给出解答而不再进行递归调用，因而每次递归调用都是有条件的(以规模未达到直接解答的大小为条件)，无条件递归调用将会成为死循环而不能正常结束。

    例子：
    1. def binary_search(data_source,find_n):
    2.     mid = int(len(data_source)/2)
    3.     if len(data_source) >1:
    4.         if data_source[mid] > find_n:
    5.             print('data in left of [%s]' % data_source[mid])
    6.             binary_search(data_source[:mid],find_n)
    7.         elif data_source[mid] < find_n:
    8.             print('data in right of [%s]' % data_source[mid])
    9.             binary_search(data_source[mid:],find_n)
    10.         else:
    11.             print('found',data_source[mid])
    12.     else:
    13.         print('cannot find ...')
    14. if __name__ == '__main__':
    15.     data = list(range(1,6000000))
    16.     binary_search(data,666666)
    执行结果：
    1. C:Python34python.exe E:/Python/递归——list.py
    2. data in left of [3000000]
    3. data in left of [1500000]
    4. data in left of [750000]
    5. data in right of [375000]
    6. data in right of [562500]
    7. data in right of [656250]
    8. data in left of [703125]
    9. data in left of [679687]
    10. data in left of [667968]
    11. data in right of [662109]
    12. data in right of [665038]
    13. data in right of [666503]
    14. data in left of [667235]
    15. data in left of [666869]
    16. data in left of [666686]
    17. data in right of [666594]
    18. data in right of [666640]
    19. data in right of [666663]
    20. data in left of [666674]
    21. data in left of [666668]
    22. data in right of [666665]
    23. found 666666

    二分法
  • 相关阅读:
    关于applet
    Hello.java
    filter用户授权的例子
    logfilter
    Java EE课程设计——企业人力资源管理系统
    条件查询、SQL、JPQL、HQL比较
    web service和ejb的区别
    RPC
    hashcode()和equals()的区别
    关于JSON
  • 原文地址：https://www.cnblogs.com/worter991/p/5161253.html
Copyright © 2020-2023  润新知