生成器,生成器函数以及推导式,生成器表达式

一丶生成器

  生成器的本质就是迭代器

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 0x0000019D9FF3D150>

  生成器的特点和迭代器一样,取值方式和迭代器一样(__next__(),send():给上一个yield的传值)

def func():
    print("111")
    yield 222
ret = func()
ret1 = ret.__next__()
print(ret1)     #111  222 

  生成器一般由生成器函数和生成器表达式来创建

  其实就是手写的迭代器

二丶生成器函数

  和普通函数没有区别,里面有yield的函数就是生成器函数

  生成器函数在执行的时候默认不会执行函数体,返回生成器

  通过生成器__next__() 分段执行这个函数

# 例题:
# 一公司订购10000件衣服,而员工并没有这么多,一次分不完只能堆起来.占空间
def cloth():
    lst = []
    for i in range(10000):
        lst.append("衣服"+ str(i))
    return lst
cl = cloth()

#最好的方法是来一个新员工领一套,不用一次性做那么多件衣服,用多少取多少.
def cloth():
    lst = []
    for i in range(10000):
        lst.append("衣服"+ str(i))
    yield lst
cl = cloth()

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

 send()给上一个yield传值,不能在开头(没有上一个yield),最后一个yield也不能用send()

def eat():
    print("我吃什么啊")
    a = yield "馒头"
    print("a=",a)
    b = yield "⼤饼"
    print("b=",b)
    c = yield "⾲菜盒⼦"
    print("c=",c)
    yield "GAME OVER"
gen = eat() # 获取⽣成器
ret1 = gen.__next__()
print(ret1)
ret2 = gen.send("胡辣汤")
print(ret2)
ret3 = gen.send("狗粮")
print(ret3)
ret4 = gen.send("猫粮")
print(ret4)

三丶推导式

  1.列表推导式[结果   for循环   条件筛选]

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

  2.字典推导式{K:V for循环  条件筛选}

# 把字典中的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)

  3.集合推导式{K  for循环  条件}

#集合推导式可以帮我们去重
lst = [1,1,2,4,9,6,8,4,2,6]
s = {i for i in lst}
print(s)    #{1, 2, 4, 6, 8, 9}

四丶生成器表达式

  (结果 for循环 条件)

# 获取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(1,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']]

# #不用推导式和表达式
lst = []
for i in names:
    for name in i:
        if name.count("e") >= 2:
            lst.append(name)
print(lst)

#推导式
gen = (name for i in names for name in i if name.count("e") >= 2)
for name in gen:
    print(name)

 生成器的惰性机制:

  生成器只有在访问的时候才取值. 说白了. 你找他要他才给你值. 不找他 要. 他是不会执行的.

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同理

  面试题:

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

 

 特点:

    1.惰性机制

    2.只能向前

    3.节省内存(鸡蛋理论)

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

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

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

 

猜你喜欢

转载自www.cnblogs.com/qicun/p/9469316.html
今日推荐