迭代器和生成器

内容目录　　　　　　　　　　　　　　　　　　　　　　

迭代和可迭代协议　　　　　　　　　　　　

迭代器和迭代器协议　　　　　　　　　　　

初识生成器　　　　　　　　　　　　　　　

生成器函数　　　　　　　　　　　　　　　

列表推导式和生成器表达式　　　　　　　   

本章小结　　　　　　　　　　　　　　　　

 

迭代和可迭代协议　　　　　　

迭代 --> 可以将某个数据集内的数据“一个挨着一个的取出来”，就叫做迭代

可迭代协议 --> 可以被迭代要满足的要求就叫做可迭代协议 (就是内部实现了__iter__方法)

迭代器和迭代器协议　　　　　

迭代器 --> 迭代器是一个可以记住遍历的位置的对象
迭代器协议 -->  含有__iter__和__next__的方法
可迭代的不一定是迭代器，迭代器一定可迭代，可以通过调用iter()方法得到一个迭代器
 迭代器的特点：
  很方便使用，且只能取所有的数据取一次
  节省内存空间
通过调用for循环使可迭代的变成一个迭代器

初识生成器　　　　　　　　　

 生成器
 生成器的本质就是迭代器
 生成器的表现形式
     生成器函数
     生成器表达式
 生成器函数：
    含有yield关键字的函数就是生成器函数
    特点：
        调用函数的之后函数不执行，返回一个生成器
        每次调用next方法的时候会取到一个值
        直到取完最后一个，在执行next会报错
从生成器中取值的几个方法
     next
     for
　　　send
     数据类型的强制转换 : 占用内存

import time
def func():
    a = 1
    print('定义的a')
    yield a
    b = 2
    print('定义的b')
    yield b
    c = 3
    print('定义的c')
    yield c
ret = func()
print(next(ret))  #定义的a 1
time.sleep(1)
print(next(ret)) #定义的b 2

 

生成器函数　　　　　　　　　

def cloth():
    for i in range(1,21):
        yield '生产的第%s件衣服'%i

cloths = cloth()

n = 0
for i in cloths:

    n += 1
    if n == 6:
        break
    print(i)

def look(filem):
    f = open(filem,mode='r',encoding='utf-8')
    while 1:
        line = f.readline()
        yield line.strip()

ret = look('监听文件')
for i in ret:
    if 'python' in i:
        print(i)

def generator():
    print(123)
    content = yield 1
    print('=======',content)
    print(456)
    yield 2

g = generator()
ret = g.__next__() #123
print('***',ret) #*** 1
ret = g.send('hello')   #send的效果和next一样 #打印456,并且传递给content一个‘hello’
print('***',ret) # *** 2

#send 获取下一个值的效果和next基本一致
#只是在获取下一个值的时候，给上一yield的位置传递一个数据
#使用send的注意事项
    # 第一次使用生成器的时候 是用next获取下一个值
    # 最后一个yield不能接受外部的值

# yield from 相当于for 一个循环
def gen1():
    for c in 'AB':
        yield c
    for i in range(3):
        yield i

print(list(gen1())) #['A', 'B', 0, 1, 2]

def gen2():
    yield from 'AB'
    yield from range(3)

print(list(gen2())) #['A', 'B', 0, 1, 2]

 

列表推导式和生成器表达式　　

# [每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型]    #遍历之后挨个处理
#[满足条件的元素相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件]   #筛选功能

# #30以内所有能被3整除的数
ret = [i for i in range(10) if i%3 == 0] #完整的列表推导式
print(ret) #[0, 3, 6, 9]

# # 例三:找到嵌套列表中名字含有两个‘e’的所有名字
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
         ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
ret = (name for lst in names for name in lst if name.count('e') ==2)
print(list(ret)) #['Jefferson', 'Wesley', 'Steven', 'Jennifer']

# （每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型]    #遍历之后挨个处理）
#（满足条件的元素相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件）  #筛选功能

g = (i for i in range(10) if i%3 == 0)  #完整的列表推导式
print(list(g)) #[0, 3, 6, 9] 可以使用for循环遍历所有元素 list强转数据类型占用内存

# 例一：将一个字典的key和value对调
mcase = {'a': 10, 'b': 34}
mcase_frequency = {mcase[k]: k for k in mcase}
print(mcase_frequency) #{10:'a' , 34:'b'}

# 例二：合并大小写对应的value值，将k统一成小写
mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
# {'a':10+7,'b':34,'z':3}
macase = {k.lower():mcase.get(k.lower(),0)+mcase.get(k.upper(),0)for k in mcase}
print(macase)

mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase}
print(mcase_frequency) #{'a': 17, 'b': 34, 'z': 3}

#集合推导式，自带结果去重功能
squared = {x**2 for x in [1, -1, 2]}
print(squared) #{1, 4}

 

本章小结　　　　　　　　　　

可迭代对象：

　　拥有__iter__方法

　　特点：惰性运算

　　例如:range(),str,list,tuple,dict,set

迭代器Iterator：

　　拥有__iter__方法和__next__方法

　　例如:iter(range()),iter(str),iter(list),iter(tuple),iter(dict),iter(set),reversed(list_o),map(func,list_o),filter(func,list_o),file_o

生成器Generator：

　　本质：迭代器，所以拥有__iter__方法和__next__方法

　　特点：惰性运算,开发者自定义

使用生成器的优点：

1.延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。