生成器 和 生成器 表达式

本节内容:

　　1.生成器 和 生成器函数

　　2.列表推导式

一.生成器

　　什么是生成器,生成器实质就是迭代器

　　在 python 中的三种方式获取生成器

　　1.通过生成器函数

　　2.通过各种推导式来实现生成器

　　3.通过数据的转换也可以获取生成器

　　首先,我们看一个简单的函数:

　　

def func():
    print('111')
    return 222

ret = func()
print(ret)

# 结果:
'''
111
222
'''

　　将函数中的 return 换成 yield 就是生成器

　　

def func():
    print(111)
    yield 222
ret = func()
print(ret)

# 结果:
#  <generator object func at 0x00000000029B6F68>

　　运行的结果和上面的不一样,为什么呢?由于函数中存在了 yield,那么这个函数就是一个生成器函数,这个时候,我们再执行这个函数的时候,就不再是函数的执行了,而是获取这个生成器,如何使用呢?想想迭代器,生成器的本质就是迭代器,所以,我们可以直接执行 __next__ () 来执行以下的生成器

　　

def func():
    print(111)
    yield 222

gener = func()  # 这个时候函数不会执行,而是获取到生成器
ret = gener.__next__()  # 这个时候函数才会执行,yield 的作用和 return 一样,也是返回数据
print(ret)
# 结果
# 111
# 222

　　那么 ,我们可以看到,yield 和 return 的效果一样的,有什么区别呢? yield 是分段来执行一个函数,return 呢?直接停止执行函数

　　　

def func():
    print(111)
    yield 222
    print(333)
    yield 444
gener = func()
ret = gener.__next__()
print(ret)
ret1 = gener.__next__()
print(ret1)
ret2 = gener.__next__()
print(ret2)

# 结果
'''
111
Traceback (most recent call last):
222
333
  File "F:/爬虫/函数.py", line 72, in <module>
444
    ret2 = gener.__next__() 最后一个 yield 执行完毕,再次__next__()程序报错,也就是说
和return无关了
StopIteration

'''

　　当程序运行完最后一个yield,那么后面继续进行 __next__()程序会报错

　　好了生成器说完了,生成器有什么用呢?我们来看这样一个需求,一个工厂向服装厂定制了 10000套衣服,服装厂就比较实在,加班加点直接生产出了 10000套衣服

def cloth():
    lst = []
    for i in range(10000):
        lst.append(i)
    return lst
cl = cloth()
# 这个数据量实在太大了

　　

　　但是呢?现在工厂没那么多需求,这么多的衣服放哪呢?含尴尬啊,最好的效果就是,我要一套,你给我一套

def cloth():
    for i in range(100000):
        yield '第%s套衣服' % i
cl = cloth()
print(cl.__next__())
print(cl.__next__())
print(cl.__next__())

# 结果
'''
第0套衣服
第1套衣服
第2套衣服
'''

　　区别 ---- 第一种是直接一次性全部拿出来,会很占内存,第二种使用生成器,一次就一个,用多少生成多少,生成器是一个一个的指向下一个,不会回去,__next__()到哪,指针就指到哪,下一次继续获取指针指向的值

　　接下来我们来看 send() 方法,send() 和 __next__() 一样都可以让生成器执行到下一个 yield

　　

def eat():
    print('我要吃什么啊')
    a = yield '馒头'
    print('a = ',a)
    b = yield '大饼'
    print('b = ',b)
    c = yield '烤肉'
    print('c = ',c)
    yield 'Game Over'

gen = eat()
ret = gen.__next__()  # 获取生成器
print(ret)
ret1 = gen.send('胡辣汤')
print(ret1)
ret2 = gen.send('狗粮')
print(ret2)
ret3 = gen.send('猫粮')
print(ret3)

# 结果
'''
我要吃什么啊
馒头
a = 胡辣汤
大饼
b = 狗粮
烤肉
c = 猫粮
Game Over
'''

　　send  和 __next__() 区别:

　　　　1.send  和 next() 都是让生成器向下走一次

　　　　2.send  可以给上一个 yield 的位置传递值,不能给最后一个 yield 发送值,在第一次执行生成器代码的时候不能使用send()

　　　生成器可以使用 for循环来获取内部的元素

　　

def func():
    print(111)
    yield 222
    print(333)
    yield 444
    print(555)
    yield 666
gen = func()
for i in gen:
    print(i)
    

# 结果
'''
111
222
333
444
555
666
'''

　　二 .列表推导式,生成器表达式 以及 其他推导式

　　　　首先先看一下这样的代码,给出一个列表,通过循环,再向列表添加 1- 13

　　

lst = []
for i in range(1, 15):
 lst.append(i)
print(lst)

　　替换成列表推导式

　　

lst = [i for i in range(1, 15)]
print(lst)

　　列表推导式是通过一行来构建你要的列表,列表推导式看起来代码简单,但是出现错误之后很难排查

　　列表推导式的常用写法:

　　　　[结果  for 变量 in 可迭代对象]

　　例如:

　　　　从 python1  到  python20 写入列表lst:

　　

lst = ['python%s' % i for i in range(1,21)]
print(lst)

　　我们还有对列表进行筛选

　　筛选模式:

　　　　[结果  for 变量 in 可迭代对象  if   条件]

# 获取1-100内所有的偶数
lst = [i for i in range(1, 100) if i % 2 == 0]
print(lst)

　　生成器表达式和列表推导式的语法基本上是一样的,只是把 [ ]  换成了 ( )

gen = (i for i in range(10))
print(gen)
# 结果: 
# <generator object <genexpr> at 0x106768f10>

　　 打印的结果就是一个生成器,我们可以使用for循环来循环这个生成器　　

gen = ("麻花藤我第%s次爱你" % i for i in range(10))
for i in gen:
　　print(i)

　　　生成器表达式也可以进行筛选:

　　

# 获取1-100内能被3整除的数
gen = (i for i in range(1,100) if i % 3 == 0)
for num in gen:
 print(num)
# 100以内能被3整除的数的平⽅
gen = (i * i for i in range(100) if i % 3 == 0)
for num in gen:
 print(num)
# 寻找名字中带有两个e的⼈的名字
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven',
'Joe'],
 ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
# 不⽤推导式和表达式
result = []
for first in names:
 for name in first:
 if name.count("e") >= 2:
 result.append(name)
print(result)
# 推导式
gen = (name for first in names for name in first if name.count("e") >= 2)
for name in gen:
 print(name)

　　生成器表达式 和 列表推导式的区别:

　　　　1.列表推导式比较耗内存,一次性加载,生成器表达式几乎不占用内存,使用的时候才分配和使用内存

　　　　2.得到的值不一样,列表推导式得到的是一个列表,生成器表达式获取的是一个生成器

　　生成器的惰性机制:生成器只有在访问的时候才取值,说白了,你找他要他才给你值,不找他要,它是不会执行的

def func():
    print(111)
    yield 222
g = func() # 生成器g
g1 = (i for i in g) # 生成器g1. 但是g1的数据来源于g
g2 = (i for i in g1) # 生成器g2. 来源g1
print(list(g)) # 获取g中的数据. 这时func()才会被执行. 打印111.获取到222. g完毕.
print(list(g1)) # 获取g1中的数据. g1的数据来源是g. 但是g已经取完了. g1 也就没有数据了
print(list(g2)) # 和g1同理

# 结果

'''
111
[222]
[]
[]
'''

　　　深坑 ===> 生成器,要值的时候才执行　

　　字典推导式:

　　　　根据名字应该也可以猜到,推导出来的是字典

　　

# 把字典中的key和value互换
dic = {'a': 1, 'b': '2'}
new_dic = {dic[key]: key for key in dic}
print(new_dic)
# 在以下list中. 从lst1中获取的数据和lst2中相对应的位置的数据组成⼀个新字典
lst1 = ['jay', 'jj', 'sylar']
lst2 = ['周杰伦', '林俊杰', '邱彦涛']
dic = {lst1[i]: lst2[i] for i in range(len(lst1))}
print(dic)

# 结果
'''
{1: 'a', '2': 'b'}
{'jay': '周杰伦', 'jj': '林俊杰', 'sylar': '邱彦涛'}
'''

　　集合推导式:

　　　　集合推导式可以帮助我们直接生成一个集合,集合的特点:无序,不重复,所以集合推导式自带去重功能

lst = [1, -1, 8, -8, 12]
# 绝对值去重
s = {abs(i) for i in lst}
print(s)

# 结果
# {8, 1, 12}

　　　总结:推导式有-----> 列表推导式,字典推导式,集合推导式,没有元祖推导式

　　　　　　生成器表达式 : (结果  for 变量  in  可迭代对象   if条件筛选)

　　　　　　　生成器表达式可以直接获取到生成器对象,生成器对象可以直接进行for循环,生成器具有惰性机制

一个面试题,难度系数*******************:

def add(a, b):
    return a + b
def test():
    for r_i in range(4):  # 0 1 2 3
        yield r_i
g = test()           # 0 1 2 3
for n in [2, 10]:   # 2  10
    g = (add(n, i) for i in g)
print(list(g))

# 结果
# [20, 21, 22, 23]

 　　友情提示: 惰性机制,不到最后不会拿值