python-生成器-推导式

生成器

首先我们来看看什么是个生成器，生成器它的本质就是迭代器

在python中有以下几种方式来获取生成器

1.通过生成器函数

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

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

def func():
    print(11)
    return 22
ret = func()
print(ret)
# 运行结果:
11
22

我们只需要修改一个地方就可以把函数变成生成器 就是将函数中的return换成yield就是生成器

定义生成器

def func():
    print(11)
    yield 22
func()

我们这样写没有任何的变化，这是为什么呢？ 我们来看看函数名加括号获取到的是什么?

为什么不会执行呢??不是函数名加括号就是调用这个函数吗? 你想的没有问题,只是因为函数体中出现了yield

咱们可以理解为,生成器是基于函数的形式变成的.

我们func()这一步是在创建一个生成器，然后我们就可以赋值到别得变量中，然后进行使用了

def func():
    print(11)
    yield 22
ret = func()
print(ret)

结果：
<generator object func at 0x0000020BFDE2EFC0>

获取的这个生成器.如何使用呢???

回想下迭代器是怎么使用的，再想想生成器的本质就是迭代器。我们是不是就可以直接使用迭代器的方式直接使用生成器啦。

def func():
    print("111")
    yield 222


gener = func()  # 这个时候函数不会执⾏. ⽽是获取到⽣成器
ret = gener.__next__()  # 这个时候函数才会执⾏. yield的作⽤和return⼀样. 也是返回数据
print(ret)

结果：
111
222

那么我们可以看到，yield和return的效果是一样的。但是还是有点区别

yield是分段来执行一个函数，yield可以出现多次

return是直接停止这个函数，return可以出现多次但是只会执行到第一个就结束了

def func():
    print("111")
    yield 222
    print("333")
    yield 444
gener = func()
ret = gener.__next__()
print(ret)
ret2 = gener.__next__()
print(ret2)
ret3 = gener.__next__()
# 最后⼀个yield执⾏完毕. 再次__next__()程序报错

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

好了生成器我们认识了，生成器有什么作用呢?

生成器的作用

我们来看一下这个需求,老男孩向楼下好适口的老板订购了10000个包子.好适口老板也实在一下就全部都做出来了

def eat():
    lst = []
    for i in range(1,10000):
        lst.append('包子'+str(i))
    return lst
e = eat()
print(e)

这样做是没有问题，但是我们目前这么点人吃不完这么多，只能先放到一个地方，过会在吃的时候包子就凉了.这样也不太好

最后是老板能够咱们吃一个他做一个.这样我们就不用考虑没地方和包子凉的问题了,咱们实现一个吃一个做一个

def eat():
    for i in range(1,10000):
        yield '包子'+str(i)
e = eat()
print(e.__next__())
print(e.__next__())
print(e.__next__())
print(e.__next__())
print(e.__next__())
print(e.__next__())

结果：
包子1
包子2
包子3
包子4
包子5
包子6

上下的区别: 第一种是直接把包子都拿来,很占内存也就是很占咱们的位置,第二种使用生成器,想吃就拿一个.吃多少个包多少个.生成器是一个一个的,一直向下进行,不能向上.next()到哪,指针就指到哪儿.下一次继续就获取指针指向的值

对比显示:生成器的好处是节省内存

我们再来看一个和__next__类似的东西send()

send和__next__()一样都可以让生成器执行到下一个yield

def eat():
    for i in range(1,10000):
        a = yield '包子'+str(i)
        print('a is',a)
        b = yield '窝窝头'
        print('b is', b)
e = eat()
print(e.__next__())
print(e.send('大葱'))
print(e.send('大蒜'))

结果：
包子1
a is 大葱
窝窝头
b is 大蒜
包子2

send是将括号中的内容传给了上一yield,然后yield接收的值就可以赋值给变量

send和__next__()区别:

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

send可以给上一个yield的位置传递值, 在第一次执行生成器的时候不能直接使用send(),但是可以使用send(None)

生成器可以for循环来循环获取内部元素:

def func():
    yield 1
    yield 2
    yield 3
    yield 4
    yield 5
f = func()
for i in f:
    print(i)
    
结果：
1
2
3
4
5

yield from

在python3中提供一种可以直接把可迭代对象中的每一个数据作为生成器的结果进行返回

def func():
    lst = ['卫龙','老冰棍','北冰洋','牛羊配']
    yield from lst
g = func()
for i in g:
    print(i)

yield from 小坑

有个小坑,yield from 是将列表中的每一个元素返回,所以 如果写两个yield from 并不会产生交替的效果

def func():
    lst1 = ['卫龙','老冰棍','北冰洋','牛羊配']
    lst2 = ['馒头','花卷','豆包','大饼']
    yield from lst1
    yield from lst2
g = func()
for i in g:
    print(i)
结果：
卫龙
老冰棍
北冰洋
牛羊配
馒头
花卷
豆包
大饼

推导式

列表推导式

列表推导式，生成器表达式以及其他推导式。

首先我们先看一下这样的代码，给出一个列表，通过循环，向列表中添加1~10：

li = []
for i in range(10):
    li.append(i)
print(li)

结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

我们换成列表推导式是什么样的,来看看:

列表推导式的常⽤写法:

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

ls = [i for i in range(10)]
print(ls)

结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

例. 从python1期到python18期写入列表lst:

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

结果：
['python1', 'python2', 'python3', 'python4', 'python5', 'python6', 'python7', 'python8', 'python9', 'python10', 'python11', 'python12', 'python13', 'python14', 'python15', 'python16', 'python17', 'python18']

筛选模式

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

lst = [i for i in range(100) if i %2 == 0]
print(lst)

结果：
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

生成器推导式

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

gen = (i for i in range(10))
print(gen)

结果：
<generator object <genexpr> at 0x000001A6A716D048>

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

gen = ("第%s次" % i for i in range(10))
for i in gen:
    print(i)
    
结果：
第0次
第1次
第2次
第3次
第4次
第5次
第6次
第7次
第8次
第9次

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

# 获取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 i in gen:
    print(i)

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

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
# list的底层有for循环,for就是一直执行__next__() 所以可以将生成器放到list中
print(list(g))   # 获取g中的数据. 这时func()才会被执行. 打印111.获取到222. g完毕.
print(list(g1))  # 获取g1中的数据. g1的数据来源是g. 但是g已经取完了. g1 也就没有数据了
print(list(g2))  # 和g1同理理
print(next(g))
print(next(g1))
print(next(g2))   # 可以用next来验证  其实list就是将内容迭代了转换成了列表

字典推导式

根据名字应该也能猜到，推导出来的是字典

lst1 = ['jay','jj','meet']
lst2 = ['周杰伦','林俊杰','郭宝元']
dic = {lst1[i]:lst2[i] for i in range(len(lst1))}
print(dic)

结果：
{'jay': '周杰伦', 'jj': '林俊杰', 'meet': '郭宝元'}

集合推导式

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

lst = [1,2,3,-1,-3,-7,9]
s = {abs(i) for i in lst}
print(s)

结果：
{1, 2, 3, 7, 9}

总结:

推导式有，列表推导式，字典推导式，集合推导式，没有元组推导式

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

生成器表达式可以直接获取到⽣成器对象。

⽣成器对象可以直接进行for循环。

⽣成器具有惰性机制。

集合推导式和字典推导式很是类似，记住一个小技巧能够快速区分那个是字典那个是集合

​ 字典推导式前面的结果是有个冒号，而集合的前面结果就是单纯的结果