zoukankan      html  css  js  c++  java
  • 生成器,生成器函数以及推导式,生成器表达式

    一丶生成器

      生成器的本质就是迭代器

    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 
    def generator():
        print(123)
        content = yield 1
        print('=======',content)
        print(456)
        yield2
    
    g = generator()
    ret = g.__next__()
    print('***',ret)
    ret = g.send('hello')   #send的效果和next一样
    print('***',ret)
    
    #send 获取下一个值的效果和next基本一致
    #只是在获取下一个值的时候,给上一yield的位置传递一个数据
    #使用send的注意事项
        # 第一次使用生成器的时候 是用next获取下一个值
        # 最后一个yield不能接受外部的值

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

      其实就是手写的迭代器

    二丶生成器函数

      和普通函数没有区别,里面有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.得到的值不一样,列表推导式得到的是一个列表,生成器表达式获得的是一个生成器

     

  • 相关阅读:
    实验五
    实验四
    实验三
    实验二
    寄存器(内存访问)
    实验一
    寄存器
    Mermaid 绘图总结
    电脑查看系统版本
    _ZNote_Chrom_插件_Chrom运行Android软件_APK
  • 原文地址:https://www.cnblogs.com/qicun/p/9469316.html
Copyright © 2011-2022 走看看