生成器与迭代器

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、列表推导式

#列表推导式 字典推导式 集合推导式
# 旧的列表 ------>>新的列表

#1.列表推导式: 格式：[表达式 for 变量 in 旧列表] 或者 [表达式 for 变量 in 旧列表 if 条件]

#过滤长度小于或者等于3的人名
names=['tom','lily','abc','jack','steven','bob','ha']
result=[name for name in names if len(name)>3]
result=[name.capitalize() for name in names if len(name)>3]
print(result)
#[(偶数,奇数),(),(),()] [(0,1),(0,3),(0,5),(0,7),(0,9),(2,1),(2,3),..]
#嵌套for 循环
newlist=[(x,y) for x in range(5) if x%2==0 for y in range(10) if y%2!=0]
print(newlist)
'''
newlist=[]
def func()
    for i in range(5):
        if i%2==0:
            for j in range(10):
                if j%2!=0:
                    newlist.append((i,j))
    return newlist
x=func()
print(x)
'''
'''
def func(names):
    newlist=[]
    for name in names:
        if len(name)>3:
            name=name.title()
            newlist.append(name)
    return newlist
'''
#将1-100之间能被3整除，组成一个新的列表
newlist=[i for i in range(1,101) if i%3==0 and i%5==0]
print(newlist)

#列表嵌套的使用的方法 --没有条件
list1=[[1,3,5],[1,4,7],[3,6,9],[2,4,8]]
list2=[i[-1] for i in list1]
print(list2) # [5, 7, 9, 8] 结果为

#if else 使用案例
dict1={'name':'tom','salary':5000}
dict2={'name':'lucy','salary':8000}
dict3={'name':'jack','salary':4500}
dict4={'name':'lily','salary':3000}
list1=[dict1,dict2,dict3,dict3]
#if 薪水大于5000 加200，低于等于5000加500
newlist=[employee['salary']+200 if employee['salary']>5000 else employee['salary']+500 for employee in list1]
print(newlist) #其结果为[5500, 8200, 5000, 5000]

#集合推导式 {} 与类似列表推导式，在列表推导式上添加了一个去处重复项
list1=[1,3,4,5,4,6,7,89,8]
set1={x+1 for x in list1 if x>5}
print(set1)  #其结果为{1, 3, 4, 5, 6, 7, 8, 89}

#字典推导式
dict1={'a':'A','b':'B','c':'C','d':'C'}
newdict={value:key for key,value in dict1.items()}
print(newdict) #其结果为{'A': 'a', 'B': 'b', 'C': 'd'}

二 生成器的产生

1.通过列表生成式生成

'''

通过列表生成式(列表推导式),我们可以直接创建一个列表.
但是，受内存限制，列表容量肯定是有限的
而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间。
如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间白白浪费
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢?
这样就不必创建完整的list，从而节省大量的空间，在python中，这种一边循环一边计算的机制，称为生成器，generator
得到生成器的方式
1.通过列表推导式得到生成器

'''
#[x for x in range(1000000)]

#[0,3,6,9,12,15,18,21,,,27]
result=[x for x in range(30) if x %3==0]
print(result)
print(type(result))

#得到生成器
g=(x*3 for x in range(10))
print(type(g))
print(g) #<generator object <genexpr> at 0x02FF9170>

#方式一:通过调用_next_()方式得到元素，每调用一次只能得到一个元素
for i in range(10):
    print(g.__next__())

#方式2: next(生成器对象) 系统内置的函数bult_in
#每调用一次next则会产生一个元素
print(next(g))  #StopIteration 生成器本来就可以产生10个，得到了10个，再调用就会抛出异常

2.通过函数生成

g=(x*3 for x in range(10))
while True:
    try:
        e=next(g)
        print(e)
    except:
        print('没有更多元素了')
        break

#定义生成器的方式二，借助函数完成
#只要函数中出现了yield关键字，说明函数就不是函数了。就变成生成器了
#斐波那契数列
'''
步骤:
1.定义一个函数，使用yiled关键字
2.调用函数，接收调用的结果
3.得到的结果就是生成器
4.借助于next(),_next_()得到你想要的元素
'''
def func():
    n=0
    while True:
        n +=1
       # print(n)
        yield n  #return n + 停止

g=func()
# print(g)
# print(next(g))
# print(next(g))

#斐波那契额数列
# 0,1,1,2,3,5,8
def fib(length):
    a,b=0,1
    n=0
    while n<length:
        #print(b)
        yield b
        a,b=b,a+b
        n+=1
    return '没有更多元素的值' #return 就是在得到Stopteration后提示信息

g=fib(8)

print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))

3.生成器的方法

'''
 生成器方法:
 _next_(): 获取下一个元素
 send(value): 向每次生成器调用中传值 注意:第一次调用send(None)

'''




def gen():
    i=0
    while i<5:
        temp=yield  i # return 0 + 暂停
        print('twmp:',temp)
        for x in range(temp):
            print('-------->',x)
        print('**************')
        i+=1
    return '没有更多的数据'

g=gen()
# print(next(g))
# print(next(g))
# print(next(g))

#g._next_
print(g.send(None))
n1=g.send(3)
n2=g.send(5)
print('n1:',n1,'n2:',n2)

4.生成器的应用(协程)

#进程 >线程> 协程
#迅雷 10个线程
def task1(n):
    for i in  range(n):
        print("正在搬第{}块砖".format(i))
        yield None
def task2(n):
    for i in range(n):
        print("正在听第{}首歌!".format(i))
        yield None
g1=task1(5)
g2=task2(5)

while True:
    try:
        g1.__next__()
        g2.__next__()
    except:
        break

'''
 生成器:generator
 定义生成器的方式:
 1.通过列表推导式方式
    g=(x+1 for x in range(6))
2.函数+ yield
    def func():
        ...
        yield
    g=func()
    
  产生元素:
    1.next(generator) --->每次调用都会产生一个新的元素，如果元素产生完毕，再去调用就会产生异常
    2.生成器自己的方法:
        g._next_()
        g.send(value) 把值传进去

应用:协程
        
    
'''

三. 迭代器

#可迭代的对象 1.生成器 2.元组，列表，集合，字典，字符串
#如何判断一个对象是否是可迭代的
from collections import Iterable
list1=[1,4,7,8,9]

f=isinstance(list1,Iterable)
print(f)
f=isinstance('abc',Iterable)
print(f)
f=isinstance(100,Iterable)
print(f)

g=(x+1 for x in range(10))
f=isinstance(g,Iterable)
print(f)

#迭代器
'''
迭代是访问集合元素的一种方式，迭代器是一个可以记住遍历的位置的对象
特点:
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束
迭代器只能往前不会后退
[1,2,3,5,6]
可以被next()函数调用并不断返回下一个值的对象称为迭代器.
可迭代的 是不是肯定就是迭代器?
生成器是可迭代的，也是迭代器
list是可迭代的，但不是迭代器
list--->iter(list)----->迭代器 next()
'''
list1=[1,2,3,4,5]
# print(next(list1))
# print(next(list1))
list1=iter(list1)
print(next(list1))
print(next(list1))
'''
生成器与迭代器

'''