前言
假如现在有一个列表L = [1,2,3,4,5],如果需要获取列表里的内容，有几种方法？
第一种：
L[0]
第二种：
for i in L:
print(i)
如果用索引取值，我们可以取到任意位置的值，前提是你得知道这个值在什么位置。
如果用for循环来取值，我们把每个值都取到，不需要关心每个值的位置，因为只能按照顺序来取值。
但是，有没有人想过为啥可以使用for循环取值？
Python中的for循环
想搞清楚for循环，还是得从代码的角度看：
for i in [1,2,3,4,5]:
print(i)
上面这段代码没啥问题，但是我们换一种情况，循环一组数字12345，
for i in 12345:
print(i)
# 结果：
Traceback (most recent call last):
File "D:/Mark/学员问题.py", line 4, in <module>
for i in 12345:
TypeError: 'int' object is not iterable
报错了！莫慌，有报错提示TypeError: 'int' object is not iterable,说int类型不是iterable,老马百度翻译了一下
也就是说int类型不是可迭代的！
迭代
什么是迭代
"可迭代"这个概念，我们可以从报错上分析，之所以12345不可以for循环，是因为它不可迭代，反过来意思就是，如果"可迭代"，那么就可以被for循环！
我们知道，字符串，列表，元组，字典，集合都可以被for循环，说明它们是可迭代的。
from collections import Iterable
l = [1, 2, 3, 4]
t = (1, 2, 3, 4)
d = {1: 2, 3: 4}
s = {1, 2, 3, 4}
print(isinstance(l, Iterable))
print(isinstance(t, Iterable))
print(isinstance(d, Iterable))
print(isinstance(s, Iterable))
打印结果都是True,那么迭代指的就是可以将数据一个挨着一个的取出来。
可迭代协议
能被for循环的就是可迭代的，但是for怎么知道谁是可迭代的呢？
假设我们有一个数据类型，希望这个类型里的东西可以被for循环，那么就必须满足for循环的要求，而这个要求就是"协议"
可以满足被迭代的要求就叫做可迭代协议，可迭代协议的定义非常简单，就是内部实现了__ iter__方法。
print(dir([1,2]))
print(dir((2,3)))
print(dir({1:2}))
print(dir({1,2}))
在打印结果中，不难发现，都有一个__ iter__方法。也就是说要想可迭代，那么内部必须有一个__iter__方法
那么，__ iter__方法有什么用呢？
print([1,2].__iter__())
# 结果：
<list_iterator object at 0x000001D5CF34C898>
又出现一个不懂的单词iterator，翻译一下
迭代器
又是一个新问题,什么是迭代器？
虽然现在还不清楚，但是我们已经有了一个迭代器，我们来研究下这个列表的迭代器和列表的区别.
# 迭代器的方法 - 列表的方法
print(set(dir([1,2].__iter__()))-set(dir([1,2])))
# 结果：
{'__next__', '__length_hint__', '__setstate__'}
可以看到，迭代器中多了三个方法，那么这三个都分别有什么用处？
iter_list = [1,2,3,4,5,6].__iter__()
#获取迭代器中元素的长度
print(iter_list.__length_hint__())
#根据索引值指定从哪里开始迭代
print(iter_list.__setstate__(4))
#一个一个的取值
print(iter_list.__next__())
print(iter_list.__next__())
在for循环中，就是在内部调用了__next__方法才能取到一个一个的值。
如果我们一直取next取到迭代器里已经没有元素了，就会抛出一个异常StopIteration，告诉我们，列表中已经没有有效的元素了。
L = [1,2,3,4]
L_iter = L.__iter__()
while True:
try:
item = L_iter.__next__()
print(item)
except StopIteration:
break
迭代器遵循迭代器协议：必须拥有__iter__方法和__next__方法。
动手试试：看看range()是个啥？
生成器
在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
Python中提供的生成器：
1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表
生成器Generator：
本质：迭代器(所以自带了__iter__方法和__next__方法，不需要我们去实现)
特点：惰性运算,开发者自定义
好处：节省内存。
栗子：
假如我去饭店吃面，我上来就要挑战100碗，老板娘答应了，然后开始下面给我吃【手动狗头】，她做一碗，我吃一碗，也可以做3碗，我吃3碗，而不是说等100碗全部做好，在给我，等她做完，面坨了，我也不想吃了（要节约粮食！！！）
def produce():
"""下面"""
for i in range(2000000):
yield "做好第%s份面"%i
product_g = produce()
print(product_g.__next__()) #要一碗
print(product_g.__next__()) #再要一碗
print(product_g.__next__()) #再要一碗
num = 0
for i in product_g: #要五碗
print(i)
num +=1
if num == 5:
break
生成器表达式
l1=[i for i in range(10)] #列表解析
g1=(i for i in range(10)) #生成器表达式
print(g1)
print(next(g1)) #next本质就是调用__next__
print(g1.__next__())
print(next(g1))
1.把列表解析的[]换成()得到的就是生成器表达式
2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3.Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。
面试题
# 面试一
def demo():
for i in range(4):
yield i
g=demo()
g1=(i for i in g)
g2=(i for i in g1)
print(list(g1))
print(list(g2))
# 面试二
def add(n,i):
return n+i
def test():
for i in range(4):
yield i
g=test()
for n in [1,10]:
g=(add(n,i) for i in g)
print(list(g))