函数4—生成器和推导式

最新推荐文章于 2024-09-15 22:31:42 发布

weixin_30273931

最新推荐文章于 2024-09-15 22:31:42 发布

阅读量101

点赞数

文章标签： python

原文链接：http://www.cnblogs.com/LW-5208/articles/9329219.html

版权

一、生成器和生成器函数

　　定义：生成器的本质就是迭代器

　　1、生成器的三种创建办法：

　　　　1、通过生成器函数

　　　　2、通过生成器表达式创建生成器

　　　　3、通过数据转换

def func():
    print("紫薇")
    return "林心如"
ret = func()
print(ret)
#结果：
紫薇
林心如

#将函数中的return换成yield就是生成器
def func():
    print("紫薇")
    yield "林心如"
ret = func()
print(ret)
#结果：
<generator object func at 0x0000021592113EB8>
#运行的结果和上面的不一样，由于在函数中存在了yield。那么函数就是一个生成器函数，这个时候，我们在执行这个函数的时候这个函数就不是个函数了，而是获取了这个生成器。

　　2、生成器函数：

　　　　函数中包含了yield的就是生成器函数

#直接执行__next__()来执行一下生成器
def func():
    print("紫薇")
    yield "林心如"
gener = func()   #这个时候函数不会执行，而是获取到生成器
ret = gener.__next__()  #这个时候函数才会执行，yield的作用和return一样，也是返回数据
print(ret)
#结果：
紫薇
林心如

#yield和return的效果是一样的，它们的区别是：yield是分段来执行一个函数，return是停止执行函数

def func():
    print("紫薇")
    yield "林心如"
    print("小燕子")
    yield "赵薇"
gener = func()
ret = gener.__next__()
print(ret)
ret2 = gener.__next__()
print(ret2)
ret3 = gener.__next__()  #最后一个yield执行完毕，再次__next__()程序会报错，也就是说，和return无关了
print(ret3)
#结果：
紫薇
Traceback (most recent call last):
林心如
  File "D:/py/python_tc/day13/test.py", line 111, in <module>
    ret3 = gener.__next__()
小燕子
StopIteration
赵薇

@当程序运行玩最后一个yield，那么后面继续进行__next__()程序会报错。

　　　　注意：生成器函数被执行，获取的是生成器，而不是函数的执行

　　4、取值：

　　　　1、__next__()

#生成去的作用：
例：
def cloth():
    lst = []
    for i in range(1,1000):
        lst.append("衣服" + str(i))
    return lst
cl = cloth()
print(cl)
#衣服我这样做是一次拿完，如果是想一件一件的拿呢？
def cloth():
    for i in range(1,1000):
        yield "衣服" + str(i)
cl = cloth()
print(cl.__next__())
print(cl.__next__())
print(cl.__next__())
print(cl.__next__())
#这样就实现了一件一件的拿。
@区别：第一种是直接一次性全部拿出来，会很占内存，第二种是使用生成器，一次就拿一个，用多少就生成多少，生成器是一个一个的指向下一个。不会回去，__next__()到哪儿指针就指到哪儿，下一次继续获取指针指向的值。

　　　　2、send(值)给上一个位置传一个值，第一个和最后一个yield不用传值

send()和__next__()一样都可以让生成器执行下一个yield。
def love():
    print("我喜欢谁？")
    a = yield "林心如"
    print("a=",a)
    b = yield "赵丽颖"
    print("b=",b)
    c = yield "陈乔恩"
    print("c=",c)
    yield "其实是朴信惠"
gener = love()  #获取生成器
ret1 = gener.__next__()
print(ret1)
ret2 = gener.send("碧瑶")
print(ret2)
ret3 = gener.send("东方不败")
print(ret3)
ret4 = gener.send("车恩尚")
print(ret4)
#结果：
我喜欢谁？
林心如
a= 碧瑶
赵丽颖
b= 东方不败
陈乔恩
c= 车恩尚
其实是朴信惠

　　@、send()和__enxt__()区别：
　　1、send和next()都是让生成器向下走一次
　　2、send()可以给上一个yield的位置传递值，不能给最后一个yield发送值，在第一次执行生成器代码的时候不能使用send()

　　　　3、可以for循环

def func():
    print(111)
    yield 222
    print(333)
    yield 444
    print(555)
    yield 666
gen = func()
for el in gen:
    print(el)
#结果:
111
222
333
444
555
666

二、各种推导式和生成器表达式

　　1、列表推导式 [结果 for 变量 in 可迭代对象 if 筛选]

例1：给出一个列表，通过循环，向列表中添加1-14
lst = []
for i in range(1,15):
    lst.append(i)
print(lst)

#替换成列表推导式
lst = [i for i in range(1,15)]
print(lst)

@列表推导式是通过一行来构建你要的列表，列表推导式看起来代码简洁，但是出错之后很难排查。
列表推导式的语法：
        [结果 for 变量 in 可迭代对象]

例2：从python1期到python14期写入列表：
lis = ["python%s" %i for i in range(1,15)]
print(lis)

@对列表数据进行筛选：筛选模式：[结果 for 变量 in 可迭代对象 if 条件]
例3：获取1-100内所有的偶数
lis = [i for i in range(1,100) if i % 2 == 0]
print(lis)

　　2、字典推导式 {结果 for 变量 in 可迭代对象 if 筛选} 结果=》key:value

例1：把字典中的key和value互换
dic = {"a":1,"b":2}
new_dic = {dic[key]:key for key in dic}
print(new_dic)

例2：在一下list中，从lst1中获取的数据和lst2中相对应的位置的数据组成一个新字典
lst1 = ["紫薇","五阿哥","小燕子",]
lst2 = ["林心如","苏有朋","赵薇"]
dic = {lst1[i]:lst2[i] for i in range(len(lst1))}
print(dic)

　　3、集合推导式 {结果 for 变量 in 可迭代对象 if 筛选} 结果=》key

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

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

　　4、生成器表达式：（和列表推导式的语法基本上是一样的，只是把[]替换成()）

gen = (i for i in range(10))
print(gen)
#结果：
<generator object <genexpr> at 0x000002AE1DC83D58>
#结果打印的就是一个生成器
我们可以使用for循环来循环这个生成器：
gen = ("赵丽颖我第%s次爱你" %i for i in range(10))
for i in gen:
    print(i)

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

例1：获取1-100以内能被3整除的数
shu = (i for i in range(1,100) if i % 3 == 0)
for num in shu:
    print(num)

例2：100以内能被3整除的平方
shu = (i**2 for i in range(1,100) if i % 3 == 0)
for unm in shu:
    print(unm)

例3：寻找名字中带有两个e的人的名字
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
#不用推导式和表达式
new_names = []
for el1 in names:
    for el2 in el1:
        if el2.count("e") >= 2:
            new_names.append(el2)
print(new_names)
#结果：['Jefferson', 'Wesley', 'Steven', 'Jennifer']

#使用表达式
new_names = (el2 for el1 in names for el2 in el1 if el2.count("e")>=2)
for name in new_names:
    print(name)
#结果：
Jefferson
Wesley
Steven
Jennifer

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

　　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]
[]
[]

深坑 ==>生成器，要值的时候才拿值。

@一道非常难的面试题：
def add(a,b):
    return a + b
def test():
    for r_i in range(4):
        yield r_i
g = test()
for n in [2,10]:
    g = (add(n,i) for i in g)
print(list(g))

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

友情提示：惰性机制，不到最后不会拿值