铁乐学python_day13_迭代器生成器

灰太狼 2022-05-28 12:09 237阅读 0赞

### 一、【可迭代对象Iterable】 ###

粗略判断的话，我们可以说能被for循环进行遍历的对象就是可迭代对象，如str，list，tuple，dict（key），set，range。  
（open file 中的文件句柄属于迭代器的一种。）

如果想要更直观的判断的话，在这里我们使用dir()方法查看一下对象所有的可操作方法：

s ='hello,wutiele'
    print(dir(s))
    显示：
    
    ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

同样，dir列表，元祖，字典等类型的对象时也可以查看到有’**iter**‘操作方法。  
当然，上面的方法查看太麻烦，我们可以使用in的方法判断，返回布尔值为真的就是操作方法中有’**iter**‘的，如：

l1 = ['lv1', 'lv2', 'lv3', 'lv4', 'lv5']
    print('__iter__' in dir(l1))
    
    显示：
    True
    
    所以我们又可以说，内部含有'__iter__'方法的对象是可迭代对象。
    可迭代对象遵循可迭代协议，可迭代协议的定义非常简单，就是内部实现了__iter__方法。
    还有一种方法可以直观判断，那就是isinstance：
    from collections import Iterable
    t1 = ('枪兵', '射手', '剑士', '僧侣')
    print(isinstance(t1, tuple))
    print(isinstance(t1, Iterable))
    
    显示：
    True
    True
    
    isinstance同样作为判断类型的方法，它比type方法判断面更广，且返回的值是布尔值。

### 二、【迭代器Iterator】 ###

迭代器英文是iterator。

迭代器比起可迭代对象来说，其实它只多包含了一个操作方法，那就是'__next__'方法。
    
    下面使用__iter__将可迭代对象转化成迭代器，然后使用__next__方法操作一番，可以看到这个方法是做什么用的：
    from collections import Iterable
    t1 = ('枪兵', '射手', '剑士', '僧侣')
    
    t1_obj = t1.__iter__()
    print(t1_obj)
    print(type(t1_obj))
    print(isinstance(t1_obj, Iterator))
    print(isinstance(t1_obj, tuple))
    
    输出结果
    <tuple_iterator object at 0x0000000000D90DA0>
    <class 'tuple_iterator'> True False 可迭代对象转化成迭代器：可迭代对象.__iter__() 上例使用print和type查看从tuple转化的迭代器可以看到类型己经变成了tuple_iterator。 迭代器.__next__() t1 = ('枪兵', '射手', '剑士', '僧侣') t1_obj = t1.__iter__() print(t1_obj.__next__()) print(t1_obj.__next__()) print(t1_obj.__next__()) print(t1_obj.__next__()) # 返回 枪兵 射手 剑士 僧侣 如果再操作多一次.__next__会怎样？从头循环开始吗？答案是： 报错，StopIteration异常。 print(t1_obj.__next__()) StopIteration __next__方法每一次只会取出迭代器中的一个元素，是不是和for循环时的操作有点像？ 其实for循环一个可迭代对像时，用到的就有__next__操作方法。 迭代器遵循迭代器协议：对象不仅含有__iter__方法，同时还含有__next__方法。 for循环，能遍历一个可迭代对象，他的内部到底进行了什么？ 将可迭代对象转化成迭代器。（可迭代对象.__iter__()） 内部使用__next__方法，一个一个取值。 加了异常处理功能，取值到底后自动停止。 【使用while模拟for循环机制】 li = [i for i in range(1, 100)] # 转换成迭代器 l1_obj = li.__iter__() while True:
        # 异常处理，尝试进行try块区的语句，如果报错就执行except块区语句处理异常。
        try:
            j = l1_obj.__next__()
            print(j)
        # 当出现StopIteration异常时，不报错而是执行break中断while循环。
        except StopIteration:
            break

那么，使用for循环相比while，也就是迭代器它有什么好处呢？  
首先没有迭代器的话，while只能处理有下标的列表，字符串和元祖，字典，集合，文件就不方便了；  
其次，对大数据来说，使用迭代器比起直接使用列表（比如一百万个元素的列表），字符串（超大文本的日志）等节省内存空间多了，因为它的惰性机制，它生成后，只会在内存空间占用一条元素的空间；  
满足惰性机制，取一个值才输出一个值；  
同样由于怠惰，迭代器也不能反复取值（不能逆向或取到尽时重头又来），它内部有一个指针，取一个就指向到下一个，一直向前，不会反复。  
迭代器最大的好处就是节省内存空间。

### 三、【生成器Generator】 ###

生成器本质上也是迭代器（自带了__iter__方法和__next__方法），特点是惰性运算，开发者自定义。

目前知道的迭代器有两种：  
一种是调用方法直接返回的；  
一种是可迭代对象通过执行iter方法得到的。  
迭代器的好处是可以节省内存。  
如果在某些情况下，我们也需要节省内存,就只能自己写。自己写的这个能实现迭代器功能的东西就叫生成器。

生成器产生迭代器的方式：  
1）生成器函数构造；  
函数体中使用yield语句而不是return语句返回结果。  
也就是说你只要在一个函数的函数体中看到有yield，你就知道它不是一个常规函数，而是一个生成器了。  
yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行。  
2）用生成器推导式构造；  
3）数据类型的转化。

#### 【生成器函数】 ####

一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。

#### 【next】 ####

例：next()取出生成器的值：

import time
    def genrator_fun():
        lv1 = '枪兵*14'
        print('人族可以产出1级兵了！')
        yield lv1
        lv2 = '弓箭手*8'
        print('人族可以产出2级兵了！')
        yield lv2
    
    g = genrator_fun()
    print('g:', g) # 打印g输出生成器类型
    print('-'*12, '我是华丽的分割线', '-'*12)
    print(next(g)) # 使用next方法取出g生成器的第一个值(yield)
    time.sleep(1)
    print(next(g)) # 第二次执行取的是第二个值
    
    g: <generator object genrator_fun at 0x0000000000DB86D0>
    ------------ 我是华丽的分割线 ------------
    人族可以产出1级兵了！
    枪兵*14
    人族可以产出2级兵了！
    弓箭手*8
    
    例2:指针会顺着取出的值执行下去
    def dead_sold():
        # 可怕的亡灵大军，己经累积到1万个骷髅兵了！
        for i in range(1, 10001):
            yield '可怕的亡灵大军，己经累积到第 %s 个骷髅兵了！' % i
    d = dead_sold() # 将函数赋值给一个变量，不然直接在下面的式子用会反复只取到第1个骷髅
    for i in range(50):
        print(d.__next__())
    print('华丽分割线'.center(30, '-'))
    for i in range(150):
        print(d.__next__())
    
    可怕的亡灵大军，己经累积到第 47 个骷髅兵了！
    可怕的亡灵大军，己经累积到第 48 个骷髅兵了！
    可怕的亡灵大军，己经累积到第 49 个骷髅兵了！
    可怕的亡灵大军，己经累积到第 50 个骷髅兵了！
    ------------华丽分割线-------------
    可怕的亡灵大军，己经累积到第 51 个骷髅兵了！
    可怕的亡灵大军，己经累积到第 52 个骷髅兵了！
    可怕的亡灵大军，己经累积到第 53 个骷髅兵了！

上例中，取到第50个值时，再执行取值的语句时不会从第1个起执行，而是顺着51开始。

#### 【send】 ####

send和__next__()一样,都是执行下一个yield，不同的是，send还可以给上一个yield赋值。
    当然，函数体中第一个取值语句不能为send，因为第一个之前并没有yield可给它进行赋值。
    同样，最后一个yield不能接受send的赋值，因为最后一个后面并不能再取出值了。
    send是取值和赋值同时进行的，且赋的是上一个yield的值。
    def generator():
        content = yield 1
        print('=======', content, '=======') # 打印上一个yield的值
        yield 2
        yield 3
    
    g = generator()
    ret = g.__next__()
    print('***', ret)
    ret = g.send('hello')   #send赋值给上一个yield
    print('***', ret)
    
    *** 1
    ======= hello =======
    *** 2

### 【列表推导式和生成器表达式】 ###

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。  
例，创建1到10的列表：  
l = \[i for i in range(1,10)\]

1.把列表解析的\[\]换成()得到的就是生成器表达式  
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存。  
3.Python不但使用迭代器协议，让for循环变得更加通用。  
大部分内置函数，也是使用迭代器协议访问对象的。  
例如，sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：  
sum(x \*\* 2 for x in range(1,11))

【补充】  
1、可以直接作用于for循环的对象统称为可迭代对像；  
2、可以被next()函数调用并不断返回下一个值的对象称为迭代器（iterator）；  
3、生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出stopIteration错误表示无法继续下一个值。

end  
2018-4-4