Python的生成器

一 生成器与yield

　　若函数体包含yield关键字，再调用函数，并不会执行函数体代码，得到的返回值即生成器对象。

>>> def my_range(start,stop,step=1):
...     print('start...')
...     while start < stop:
...         yield start 
...         start+=step
...     print('end...')
... 
>>> g=my_range(0,3)
>>> g
<generator object my_range at 0x104105678>

　　生成器内置有__iter__和__next__方法，所以生成器本身就是一个迭代器。

>>> g.__iter__
<method-wrapper '__iter__' of generator object at 0x1037d2af0>
>>> g.__next__
<method-wrapper '__next__' of generator object at 0x1037d2af0>

　　因而我们可以用next(生成器)触发生成器所对应函数的执行，

>>> next(g) # 触发函数执行直到遇到yield则停止,将yield后的值返回，并在当前位置挂起函数
start...
0
>>> next(g) # 再次调用next(g)，函数从上次暂停的位置继续执行，直到重新遇到yield...
1
>>> next(g) # 周而复始...
2
>>> next(g) # 触发函数执行没有遇到yield则无值返回，即取值完毕抛出异常结束迭代
end...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

　　既然生成器对象属于迭代器，那么必然可以使用for循环迭代，如下：

>>> for i in countdown(3):
...     print(i)
... 
countdown start
3
2
1
Done!

　　有了yield关键字，我们就有了一种自定义迭代器的实现方式。yield可以用于返回值，但不同于return，函数一旦遇到return就结束了，而yield可以保存函数的运行状态挂起函数，用来返回多次值。

  总结:return和yield的区别?
　　(1)return:只能返回一次值,就结束函数。
　　(2)yield:可以返回多次值。
　　(3)yield:可以将函数暂停到某个位置。
　　(4)return和yield不能混用。

二 yield表达式应用

# 如何得到自定义的迭代器?
# (1)在函数内存在yield关键字.
# (2)调用函数并不会执行函数体代码.
# (3)会返回一个生成器对象,生成器即自定义的迭代器
def func():
    # return  # 返回函数内的值，但是只能返回一个值，程序遇到return就会跳出.
    print("第一次")
    yield 1
    print("第二次")
    yield 2
    print("第三次")
    yield 3
    print("第四次")

g = func()
print(g)
# 运行结果是: <generator object func at 0x0000025A10E4F660>  generator翻译:生成器,其实生成器就是迭代器,只不过是自定义出来的.

# 如何使用这个自定义的生成器?
# g.__iter__()
# print(g.__iter__())

# 会触发函数体代码的运行,然后遇到yield停下来.将yield后面的值当作本次调用的结果返回
# g.__next__()
print(g.__next__())  # 第一次 1
print(g.__next__())  # 第二次 2
print(g.__next__())  # 第三次 3
print(g.__next__())  # 没有返回值之后报错 :StopIteration

# 统计字符串长度
print("aaa".__len__())
len("aaa")  # 本质是"aaa".__len__()

next(g)  # 本质是g.__next__()
# iter(可迭代对象)  本质可迭代对象.__iter__()

 yield表达式的应用（一）

# 简单的理解yield
def func():
    print("start....")
    x = yield 111  #
    print("哈哈哈哈")
    yield 222
    # print("stop....")

g = func()
res = g.send(None)  # 必须先运行一下g.send(None)等同于next(g)
print(res)  # 返回值是 111

res = g.send("lsj")  #
print(res)  # 返回值是 222
"""
start....
111
哈哈哈哈
2222
"""

 

# yield后不跟返回值
# x = yield返回值（默认返回值为None）一定在函数内的生成器
# 把生成器当作一条狗喂狗投食
def dog(name):
    print("道哥%s准备吃东西了..."%name)
    while True:
        # x = yield None # 不写返回值表示返回值是None
        # x拿到的是yield接受到的值
        x = yield # 不写返回值表示返回值是None
        print("道哥%s吃了%s"%(name,x))

g = dog("alex")
# print(g)  # <generator object dog at 0x0000021DC24AF430>
# print(next(g))  # 道哥lsj准备吃东西了  None
# res = next(g)
# print(res)  # None
# next(g)  # 道哥alex吃了None,遇到yield停下来等待

# 使用send为x传值：也就是seed为yield赋值，yield在传给x
# g.send("一根骨头")
# TypeError: can't send non-None value to a just-started generator
g.send(None)  # 等同于next(g)

# 测试g.send(None)等同于next(g)
# g.send(None) # 道哥alex吃了None
# next(g)  # 道哥alex吃了None

# 再次传值可以是字符串、可以是类型的数据
g.send("一根骨头")  # 道哥alex吃了一根骨头
g.send("肉包子")  # 道哥alex吃了肉包子
g.send([1,2,3]) # 道哥alex吃了[1, 2, 3]


# 总结有yield和没有yield的区别？
# （1）有yield的生成器，运行到yield可以暂停。等待传值后在运行。
# （2）没有yield的函数在运行时，不停止一直运行。

# 关闭g
# g.close()
# g.send("1111")  # 关闭后再次传值会报错StopIteration

 yield表达式的应用（二）

# yield表达式的应用（二）了解
# x = yield 返回值（默认返回值为None）一定在函数内的生成器
# 把生成器当作一条狗喂狗投食
def dog(name):
    food_list = []  # 定义一个空列表
    print("道哥%s准备吃东西了..."%name)
    while True:
        # x = yield None # 不写返回值表示返回值是None
        # x拿到的是yield接受到的值(值先给yield后给x)
        # x = yield 1111 # yield后跟返回值:1111先赋值给yield后把yield赋值给x
        x = yield food_list # yield后跟空列表
        print("道哥%s吃了%s"%(name,x))
        food_list.append(x)

g = dog("alex")
# g.send(None)  # 道哥alex准备吃东西了...
# res = g.send(None)  # 道哥alex准备吃东西了...
# print(res)  # 1111

# 加入send功能x
# res = g.send("肉包子")
# print(res)
#
# res = g.send(["a","b"])
# print(res)

# 向定义的列表内传参
res = g.send(None)
print(res)  # []

res = g.send("一根骨头")
print(res)  # ['一根骨头']

res = g.send("肉包子")
print(res)  # ['一根骨头', '肉包子']

三 三元表达式、列表生成式、生成器表达式

• 三元表达式

# 需求: 比较两个参数的大小,返回较大值
# def func(x,y):
#     if x > y:
#         return x
#     else:
#         return y
#
# res = func(1,2)
# print(res)

# 使用三元表达式,解决上面的需求
# 语法格式:条件成立时返回的值 if 条件 else 条件不成立时返回的值
x = 1
y = 2
res = x if x > y else y 
print(res)

• 列表生成式
• 列表生成式是python为我们提供的一种简化代码的解决方案，用来快速生成列表，语法如下

[expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
]

l = ['lsj','lxx_dsb','alex_dsb','wxx','xxq_dsb']
# 需求:将含有dsb放到新列表里
# new_l = []
# for name in l:
#     if name.endswith('dsb'):
#          new_l.append(name)
# print(new_l)

# 列表生成器的目的是将上述代码更精简
# new_l = [name for name in l if name.endswith('dsb')]  # ['lxx_dsb', 'alex_dsb', 'xxq_dsb']
# new_l = [111 for name in l if name.endswith('dsb ')]  # [11, 11, 11]
new_l = [name for name in l ]  # ['lsj', 'lxx_dsb', 'alex_dsb', 'wxx', 'xxq_dsb']
print(new_l)

# 案例
# 把所有小写字母全变成大写
new_l = [name.upper() for name in l ]
print(new_l)
# 把所有的名字去掉后缀_dsb
# new_l = [name.split('_')[0] for name in l ]  # 方式一
new_l = [name.replace('_dsb','') for name in l ]  # 方式二
print(new_l)

• 生成器表达式

l = [表达式 for x in 可迭代对象 if 条件]
g = (表达式 for x in 可迭代对象 if 条件)  next(g)
sum(表达式 for x in 可迭代对象 if 条件)
list(表达式 for x in 可迭代对象 if 条件)
dic = {键:值 for k in 可迭代对象 if 条件}
set = {元素 k in 可迭代对象 if 条件}

# (1)字典生成式
keys = {'name','age','gender'}
dic = {key:None for key in keys}
print(dic,type(dic))  # {'age': None, 'gender': None, 'name': None} <class 'dict'>

# 把下面的列表转换成字典,并且不要gender的数据
items =[('name','lsj'),('age',18),('gender','male')]
dic = {k:v for k,v in items if k != 'gender'}
print(dic,type(dic))  # {'name': 'lsj', 'age': 18} <class 'dict'>

# (2)集合生成式
set = ['name','age','gender']
set1 = {k for k in set}
print(set1,type(set1))  # {'age', 'name', 'gender'} <class 'set'>

# (3)元组生成式,从0到10一组数
g = (i for i in range(10) if i > 3)
print(g,type(g))  # 得到不是元组(因为元组式不可变数据类型),所以没有元组生成式,这是一个生成器表达式.
                #  <generator object <genexpr> at 0x0000022B79C4F7B0> <class 'generator'>

# (4)针对生成器的玩法?
ge = (i for i in range(10) if i > 3)
# 强调:此刻ge内部一个值也没有,没等到next(ge)的时候取出一个值,再next(ge)的时候再取出一个值
print(ge)
print(next(ge))  # 4
print(next(ge))  # 5

# 应用:统计笔记.txt文件里的字符数 sum()

# print(sum([1,2,3,4,5]))  # sum()对传入的可迭代对象进行累加,运行结果是:15
# 方式一:
# with open('笔记.txt',mode='rt',encoding='utf-8') as f:
#     res = 0
#     for line in f:
#         res += len(line)
#     print(res)

# 方式二:如果文件行过多,此时文件内容放入f的数据太多
# with open('笔记.txt',mode='rt',encoding='utf-8') as f:
#     size_of_line = [len(line) for line in f]
#     print(size_of_line)  # 每一行的长度 [11, 1]
#     res = sum(size_of_line)
#     print(res)

# 方式三:效率最高,不受方式二文件行数过多影响
# with open('笔记.txt',mode='rt',encoding='utf-8') as f:
#     g = (len(line) for line in f)
#     print(g)
#     res = sum(g)
#     print(res)
# 方式三：优化
with open('笔记.txt',mode='rt',encoding='utf-8') as f:
    # res = sum((len(line) for line in f)) # 运行结果: 10 
    res = sum(len(line) for line in f)  # 同上的效果  10
    print(res)