1，复习，迭代器：双下方法很少直接调用，一般都是通过其他语法触发的；迭代器一定可迭代，可迭代的通过调用iter()方法皆可以得到一个迭代器.
迭代器很方便使用，所有的数据只可以取一次，节省内存空间。生成器的本质就是迭代器，调用生成器函数之后，函数并不执行，而是返回一个生成器，
每次调用next方法会返回一个值，知道取完最后一个，在去取会报错
2，作业，写生成器实现：有一个文件，从文件里分段读取内容，在读取出来的内容前加上***返还给调用者，这个作业其实是给网络编程做铺垫
使用readline或者read(1024)实现
3，网络编程的时候，比方说发送一个视频，都是一点一点的发，一点一点的收，但是我们收发的时候，也不是直接就可以发的，都要做一点包装，这儿就会用到生成器。
4，从生成器取值的三个方法：next；for；数据类型的强制转换，这种会占用内存，完全体现不了生成器的初衷（有的面试题会在这儿出题），一般不用
5，使用生成器的核心就是，这个生成数据的过程，可能会被别人反复的使用，所以要封装成函数，但是我们不能把我们要使用的数据都生成了再返回，所以这儿我们用到了生成一条，返回一条，所以我们用到了yield。
6，最后一个yield的后面的代码是拿不到的，使用for可以，next是不可以的
def generator(): print(123) yield 'a' print(456) yield 'b' print(789) g = generator() for i in g: # yield 后面的数据，for循环是可以拿到的，但是，使用next是拿不到的，最后一个会报错 print(i) 运行结果： 123 a 456 b 789
def generator(): print(123) yield 'a' print(456) yield 'b' print(789) g = generator() print(g.__next__()) print(g.__next__()) print(g.__next__()) 运行结果： 123 Traceback (most recent call last): a 456 File "/Users/guolixiao/PycharmProjects/lisa's_practise/boys/14.1.py", line 20, in <module> b print(g.__next__()) 789 StopIteration
7，这里老师有引入了另外一种访问yield的方式，send，必须有一个参数。
def generator(): print(123) num1 = yield 'a' # 第一次 next之后，会执行到yield抛出'a'，然后停在这里知道给num1赋值，这儿如果不send的话，num1默认是None print(num1) print(456) num2 = yield 'b' # 执行完send之后，"hello"字符串赋值给num1同时执行到第二个yield抛出'b',然后等在这里给num2 赋值 print(num2) print(789) g = generator() print('***',g.__next__()) print('***',g.send("hello")) # 只是这样看的话，send的效果next是一样的
8，结论：send获取下一个值的效果和next是一致的，只是在获取下一个值的时候，给上一个yield的位置传递一个数据
9，使用send注意事项：第一次使用的时候，必须使用next获取下一个值，也就是激活一下，最后一个yield不能接收外部的值
10，如果最后一个yield下面如果确实还有代码要执行，但是没有什么值要返回了，怎么办呢，在最后再加一个yield，然后再支撑我做一次next或者send就行了。
def generator(): print(123) num1 = yield 'a' # 第一次 next之后，会执行到yield抛出'a'，然后停在这里知道给num1赋值，这儿如果不send的话，num1默认是None print(num1) print(456) num2 = yield 'b' # 执行完send之后，"hello"字符串赋值给num1同时执行到第二个yield抛出'b',然后等在这里给num2 赋值 print(num2) print(789) yield # 最后会多出来一个none其实就是这个空yield抛出来的 g = generator() print('***',g.__next__()) print('***',g.send("hello")) # 只是这样看的话，send的效果next是一样的 # print(g.send("world")) print(g.__next__()) # 最后在加的那个yield支撑我在做一次next或者send
11，相对与yield和next，这个send其实用的相对少，next和for，和使用列表取值是必会的，send也要求知道，作用范围和next是一样的，如果不需要往生成器传值，next就可以了，只有我要拿的值，依赖于我往里传的值，才用send。
12，一个例子：获取移动平均值，send不可以在第一个用，第一个必须是next，一个循环里面只可以有一个yield，遮掩才能保证每次send 一次会产生一个新的值
def ava_sum(): num = 0 sum = 0 count = 0 ava_num = 0 while True: num = yield ava_num count += 1 sum += num ava_num = sum/count g = ava_sum() g.__next__() ret = g.send(5) print(ret) ret = g.send(10) print(ret) ret = g.send(3) print(ret) ret = g.send(2) print(ret) 运行结果： 5.0 7.5 6.0 5.0
13，由于上面的移动平均值生成器函数，每次一开始要用一次next激活一下，这有点不友好，我希望一拿到这个函数，就可以直接send了，怎么办？解释器
# 预激生成器功能的装饰器
def init(f): def inner(*args,**kwargs): g = f(*args,**kwargs) g.__next__() # 只需要加一句这个就可以了 return g return inner @init def ava_sum(): num = 0 sum = 0 count = 0 ava_num = 0 while True: num = yield ava_num count += 1 sum += num ava_num = sum/count g = ava_sum() ret = g.send(5) print(ret) ret = g.send(10) print(ret) ret = g.send(3) print(ret) ret = g.send(2) print(ret) 运行结果： 5.0 7.5 6.0 5.0
14，上面多了一个装饰器，下面少些了一个next，因为所有跟send相关的都要激活才可以，加上同一个装饰器就可以少些很多部，对于用户来说就更直观了。用户使用时更方便了
15，python3里面新加入一个知识点，yield from用在生成器函数里面，从容器类型里面一个一个取值。
def generator(): a = '12345' yield from a b = 'abcde' yield from b # 同一个生成器，每个值只可以取一次 # yield from会把所有制打散来取 g = generator() print(g.__next__()) print('================') for i in g: print(i) 运行结果： 1 ================ 2 3 4 5 a b c d e
def generator(): a = '12345' yield a b = 'abcde' yield b # 同一个生成器，每个值只可以取一次 # yield from会把所有值打散来取 g = generator() print(g.__next__()) print('================') for i in g: print(i) 运行结果： 12345 ================ abcde
16， 我们还可以这样来写，但是不推荐
def generator(): a = '12345' for i in a: yield i b = 'abcde' for i in b: yield i # 同一个生成器，每个值只可以取一次 # yield from会把所有制打散来取 g = generator() print(g.__next__()) print('================') for i in g: print(i) 运行结果： 1 ================ 2 3 4 5 a b c d e
17，列表推导式：其实就是一种简单的语法，获取一个列表
li = ["lisa%s"%i for i in range(10)] print(li) #结果就是一个列表 运行结果： ['lisa0', 'lisa1', 'lisa2', 'lisa3', 'lisa4', 'lisa5', 'lisa6', 'lisa7', 'lisa8', 'lisa9']
18，上面的语法和下面的for循环，效果是一样的
li = [] for i in range(10): li.append('lisa%s'%i) print(li) 运行结果： 'lisa0', 'lisa1', 'lisa2', 'lisa3', 'lisa4', 'lisa5', 'lisa6', 'lisa7', 'lisa8', 'lisa9']
19，其他的列表推导式：
li = [i*2 for i in range(10)] print(li) li = [i*i for i in range(10)] print(li) li = [i for i in range(10)] print(li) 运行结果： [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
20，生成器表达式：只要把列表推导式的中括号换成圆括号就变成了生成器表达式，不同点一，括号不一样，第二点不同，返回值不一样，一个返回列表，一个返回一个生成器，生成器表达式运行快，而且几乎不占用内存，这是他比列表表达式好的地方，用户虽然不关心这些，但是我们要关心的，表达式比较简单，并不能满足所有需求，类似三元运算符号，都是比较简单的问题，他能实现的功能，生成式函数都可以实现，一些面试题比较喜欢考这儿。
g = (i for i in range(5)) # 运行到这里只是返回了一个生成器，里面的代码并没有执行 print(g) for i in g: print(i) # 走到print，生成器里面的代码才会运行 运行结果： <generator object <genexpr> at 0x10a1135e8> 0 1 2 3 4
21，老师把生成器比喻成了老母鸡，取值i比喻成鸡蛋，很贴切，但是实际代码，不写中文
22，带条件的生成器表达式：
# [每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据] # [每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据 if 元素相关的条件] # 30以内能被3整除的数 g = (i for i in range(30) if i%3 ==0) for i in g: print(i) 运行结果： 0 3 6 9 12 15 18 21 24 27
23，找出嵌套列表中，名字含有两个字母e的名字，其实多层嵌套，并不是很常用，既要简洁，又要可读，嵌套列表其实用的并不多，要写的大家都可以看得懂，列表推导式里面的，打断点都不好使，直接就出来了，在复杂一点的话，还不如用for循环。
# 嵌套列表,前面女，后面男 li =[['Lisa','Mary','Jeniffer','Lucy'],['Tom','Steven','Jack','Wesley']] g = (name for list_line in li for name in list_line if name.count('e')==2) for i in g: print(i) # for的顺序，先for外面的大列表，再for里面的小列表
24，字典推导式和集合推导式，这两个了解就行了，但是前面的列表推导式是要求会的
# 字典表达式，需要用大括号括起来 # 例一：要求将上面的字典key 和value对调，生成新的字典 my_dict = {'a':20,'b':10,'c':30} my_new_dict = {my_dict[k]:k for k in my_dict} print(my_new_dict) # 例二：合并大小写对应的value值，将k统一成小写 my_dict = {'a':20,'b':10,'c':30,'A':40,'C':60} my_new_dict = {k.lower():my_dict.get(k.lower(),0)+my_dict.get(k.upper(),0) for k in my_dict} # get函数，可以不存在是默认抛出0 dict1 = {'a':20,'b':10} print(dict1.get('c',0)) # 没哟这个key 的时候回抛出0
运行结果
{20: 'a', 10: 'b', 30: 'c'}
{'a': 60, 'b': 10, 'c': 90}
0
25，集合推导式，最大的作用就是去重
my_set = {x*x for x in [1,-1,2,-3,3]}
print(my_set)
运行结果：
{1, 4, 9}
26，各种推导式，两个操作，遍历操作，筛选操作，支持各种推到式，让代码更简洁，但不要写的太复杂了
27，可迭代对象，迭代器，生成器：惰性运算，生成器，一次返回一个结果，生成器我们自己写的，很明显，迭代器是Python自己写的，不明显，但是其实也是惰性的，这对于处理大数据来说是非常有用的。另外提高代码的可读性，同一个迭代器，取值只可以取一次，不找他要值，不干活。