迭代器协议和for循环工作机制

一 递归和迭代

递归：

迭代：被for循环方法

二 什么是迭代器协议

1.迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个Stoplteration异常，以终止迭代（只能往后走不能往前退）  例如：生孩子

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

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

三 python中强大的for循环机制

for循环的本质：循环所有对象，全都是使用迭代器协议。

（字符串，列表，元祖，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环式，调用了他们内部的_iter_方法，把他们变成了可迭代对象

然后for循环调用可迭代对象的_next_方法去取值，而且for循环会捕捉Stoplteration异常，以终止迭代

l=['a','b','c']
一下表方式访问
print(l[0])
print(l[1])
print(l[2])
#print(l[3])  #超出边界报错：IndexError

#二 遵循迭代器协议访问方式
l=['a','b','c']
diedai_l=l.__iter__()
print(diedai_l.__next__())
print(diedai_l.__next__())
print(diedai_l.__next__())
#print(diedai_l.__next__())   #超出边界报错：StopIteration

#三for循环访问方式
#for循环本质就是遵循迭代器协议的访问方式，先调用 diedai_l=l.__iter__()方法，
#或者直接 diedai_l=iter(l),然后依次执行 diedai_l.next(),直到for循环捕捉到 StopIteration终止循环
#for 循环所有对象的本质是一样的原理
l=['a','b','c']
for i in l:    #diedai_l=l.__iter__()
    print(i)   #i=diedai_l.next()


#四.用 while 去模拟for循环做的事情
l=['a','b','c']

diedai_l=l.__iter__()
while True:
    try:
        print(diedai_l.__next__())
    except StopIteration:
        print('迭代完毕了，循环终止了')
        break

 四 为何要有for循环

l=[1,2,3]

index=0
while index <len(1):
    print(1(index))
    index+=1

序列型字符串，列表，元祖都有下标，用上面的方式可以访问；但非序列型字典，集合，文件对象不可以，for循环就是基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的_iter_方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了。

s=[1,2,3]
iter_s=s._iter_()
print(iter_s)
print(iter_s._next_())
print(iter_s._next_())
print(iter_s._next_())

   

#文件类型

f=open('text.txt','r+')

iter_f=f._iter_()
print(iter_f)
print(iter_f._next_(),end='')
print(iter_f._next_(),end='')

 五 生成器

什么是生成器？

可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用的内置的_iter_方法），所以生成器就是可迭代对象

生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）

1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次从它离开的地方继续执行

2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

生成器的优点

Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。

总结：

1.是可迭代对象

2.实现了延迟计算，节省内存空间

3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算生内存的好处。

 三元运算  列表解析 生成器表达式

三元运算：是对简单的条件语句的缩写

#书写格式

result = 值1 if  条件  else  值2

#如果条件成立，那么将“值1”赋值给result变量，否则，将值2赋值给result变量

name = 'dream'
result = 'sb' if name == 'dream' else '帅哥'
print(result)

列表解析

方法一： 
egg_list=[]
for i in range(10)
    egg_list.append('鸡蛋%s'  %i)
print(egg_list)

方法二：
l= ['鸡蛋%s' %i for i in range(10)]  #列表解析
print(l)

生成器表达式

egg_list=('鸡蛋%s' %i for i in range(10))
print(egg_list)
print(next(egg_list))      #next本质就是调用
print(egg_list.__next__())
print(egg_list.__next__())

总结：

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

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

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

sum(x**2 for x in xrange(4))

而不用多此一举的先构造一个列表：

sum ([x ** 2 for x in xrange(4)])