Python中的迭代器、生成器——10

什么是迭代器

迭代器即迭代的工具

迭代是一个重复的过程，每一次重复即一次迭代，且每次迭代的结果都是下一次迭代的初始值

while True:    #这里只是单纯的重复，不是迭代
    print('-----')

l = [1,2,3]
count = 0

while count <= len(l):   #这里是迭代
    print(l[count])
    count += 1

迭代器协议

1、迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代

2、可迭代对象：实现了迭代器协议的对象（对象内部定义一个__iter__()方法）

3、协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环、sum、min、max函数等）使用迭代器协议访问对象

 

 

对于序列类型，如：字符串、列表元组等，我们可以使用索引的方式迭代取出其包含的元素，但是对于无序类型：字典，集合，文件等是没有索引的，所以我们要想取出其内部包含的元素，则必须找出一种不依赖于索引的方式

 

可迭代对象指的是有内置方法__iter__的对象：

'hello'.__iter__
(1,2,3).__iter__
[1,2,3].__iter__
{'a':1}.__iter__
{'a','b'}.__iter__
{'a','b'}.__iter__
open('a.txt').__iter__

 

可迭代对象执行obj.__iter()得到的结果就是迭代器对象

而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

文件类型是迭代器对象

open('a.txt').__iter__
open('a.txt').__next__

迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

dic = {'a':1,'b':2,'c':3}    
iter_dic = dic.__iter__()  #得到迭代器对象，迭代器对象即有__iter__又有__next__，但是迭代器.__iter__()得到的仍然是迭代器本身
iter_dic.__iter__() is iter_dic  #True

print(iter_dic.__next__())#next(iter_dic)
print(iter_dic.__next__())#next(iter_dic)
print(iter_dic.__next__())#next(iter_dic)
#print(iter_dic.__next__())#抛出异常StopIteration，结束

iter_dic = dic.__iter__()
while 1:
    try:
        k = next(iter_dic)
        print(dicp[k])
    except StopIteration:
        break

for循环

dic = {'a':1,'b':2,'c':3}
for k in dic:
    print(dic[k])
#for循环的工作原理
#1、执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic
#2、执行next(iter_dic)，将得到的值赋值给k，然后执行循环代码体
#3、重复过程2，直到捕捉到异常StopIteration，结束循环

迭代器的优缺点

优点：

体格一种统一的、不依赖于索引的迭代方式

惰性计算，节省内存

缺点：

无法获取长度（只有在next完毕后才知道到底有几个值）

一次性的，只能往后走，不能往前退

 

 

生成器

只要函数内部包含有yield关键字，那么函数名()得到的结果就是生成器，并且不会执行函数内部代码

def test():
    yield 1
    yield 2
    yield 3

print(test)#结果是：<function test at 0x01E79D68>
test().__next__()

yield：

把函数做成迭代器

对比retrun，可以返回多个值，可以挂起/保存函数的运行状态

yield关键字的另一种使用形式，表达式形式yield

def eater(name)
    print('%s 准备吃饭了' %name)
    food_list = []
    while True:
        food = yield food_list
        print('%s 吃了 %s' %(name,food))
        food_list.append(food)

g = eater('egon')
g.send(None)
g.send('蒸羊羔')
g.send('蒸鹿茸')
g.send('蒸熊掌')
g.send('烧素鸭')
g.colse()
g.send('烧素鹅')
g.send('烧鹿尾')

 

 

 

生成器就是迭代器

a.__iter__
a.__next__
res = next(a)
print(res)

 

生成器表达式

列表解析

a = ['jidan %s' %i for i in range(10)]

把列表解析的[]换成()得到的就是生成器表达式

a1 = ('jidan %s' %i for i in range(10))

列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存

python使用迭代器协议让for循环变得更加通用，大部分内置函数，也是使用迭代器协议访问对象的，例如sum函数是python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以我们可以直接这样计算一系列值的和：

s = sum(x ** 2 for x in range(10))
print(s)
#结果是：285

而不需要先构建一个列表：

sum = ([x ** 2 for x in range(10)])

 

来源：https://www.cnblogs.com/winsdom/p/9123828.html