Python迭代器与生成器
1、推导式
又称解析式。
推导式是可以从一 个数据序列构建另一个新的数据序列的结构体。
1）列表推导式
打印奇数
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
b = [x for x in a if x % 2 == 1]
c = [x ** 2 for x in a if x % 2 == 1]
print(b, c)
结果：
[1, 3, 5, 7, 9] [1, 9, 25, 49, 81]
打印30以内的所有能被3整除的数
print([i for i in range(1, 31) if i % 3 == 0])
嵌套循环
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva', 'Elven']]
print([name for lst in names for name in lst if name.count("e") == 2])
结果：
['Jefferson', 'Wesley', 'Steven', 'Jennifer']
过滤50以内能被3整除的数，如果这个数是奇数就返回0，偶数返回这个数本身
print([i if i % 2 == 0 else 0 for i in range(1, 51) if i % 3 == 0])
2）字典推导式
d1 = {"a": 1, "b": 2}
d2 = {v: k for k, v in d1.items()}
print(d2)
结果：
{1: 'a', 2: 'b'}
dic = {'a': 1, 'b': 2, 'c': 3, 'ab': 4}
li = {k: v for k, v in dic.items() if 'a' not in k}
print(li)
结果：
{'b': 2, 'c': 3}
3）集合推导式
和列表推导式一致，只是这里使用{}，自带去重功能
l = [-1, 1, 1, 1, 2, 3]
print({i * i for i in l})
结果：
{1, 4, 9}
- 过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母
q1 = ['a', 'ab', 'abc', 'abcd', 'abcde']
print([i.upper() for i in q1 if len(i) >= 3])
- 求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元组列表
x = [i for i in range(0, 6) if i % 2 == 0]
y = [i for i in range(0, 6) if i % 2 != 0]
print([(i, j) for i in x for j in y])
- 快速更换key和value
q3 = {'a': 10, 'b': 34}
print({v: k for k, v in q3.items()})
- 合并大小写对应的value值，将k统一成小写
期望 结果：{‘a’:5, ‘b’:9, ‘c’:3}
q4 = {'B': 3, 'a': 1, 'b': 6, 'c': 3, 'A': 4}
print({k.lower(): q4.get(k.lower(), 0) + q4.get(k.upper(), 0) for k in q4.keys()})
2、可迭代对象（Iterable）
定义：凡是可以返回一个迭代器的对象都可称之为可迭代对象。
判断：
- dir（对象）查看属性中是否存在__iter__方法
- from collections.abc import Iterable
print(isinstance(lst, Iterable))
分类：容器类型、打开状态的files，sockets、range
迭代器： 实现了__iter__ 和__next__ 的方法的都叫做迭代器
__iter__返回自身
__next__返回下一个值
for语法糖：先调用可迭代对象的__iter__ 方法，返回一个迭代器，然后再对迭代器调用__next__ 方法，知道最后一个退出
迭代器可以没有__iter__方法,但是要是for循环的话就要有__iter__方法，返回自身
lst = ['x', 'y', 1, 3, 4]
result = lst.__iter__() #调用__iter__()方法 返回迭代器
print(result.__next__()) #迭代器调用__next__()方法不断获取下一个值
print(result.__next__()) #超出范围就会报错
**懒加载：**需要的时候再生成，而列表一次性生成保存在内存中
from collections.abc import Iterable, Iterator
range_iter = iter(range(10))
print(isinstance(range_iter, Iterable)) # 判断是否是可迭代对象
print(isinstance(range_iter, Iterator)) # 判断是否是迭代器
3、迭代器（Iterator）
好处：迭代器就像一个懒加载的工厂惰性求值，等到有人需要的时候才给它生成值返回，没调用的时候就处于休眠状态等待下一次调用
1） 生成无限序列
from itertools import count
c = count(start=10) # 指定从10开始，步长默认为1
c = count(10, 2) # 从10开始，步长为2 ，调用next可以生成无限序列
print(c, type(c))
print(next(c))
print(next(c))
print(next(c))
count(10, 2) <class 'itertools.count'>
10
12
14
2）从一个有限序列中生成无限序列
from itertools import cycle
import time
weeks = cycle(["Mon","Tue","Wed","Thu","Fri","Sat","Sun"])
print(weeks,type(weeks))
for i in weeks:
print(i)
time.sleep(1)
4、生成器（generator）
生成器一定是迭代器。懒加载，是迭代器更优雅的写法
不需要手动实现iter、next方法
生成器只有俩种写法：生成器表达式、生成器函数
1）生成器表达式
类似于列表推导式，使用（）生成generator。没有手动实现__iter__和__next__方法
result = (x for x in range(1,31) if x % 3 == 0)
print(result,type(result))
结果：
<generator object <genexpr> at 0x000002F156454580>
<class 'generator'>
2）生成器函数
包含了yield关键字的函数
a、yeild关键字
把普通函数变成生成器
作用：
• 当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。
• 当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。
• yield关键字:保留中间算法,下次继续执行
def get_content():
x = 2
yield x
y = 3
yield y
z = 4
yield z
g = get_content()
print(g, dir(g))
print(next(g)) # 第一次执行next函数的时候 遇到yeild就退出，并且返回yeild后面携带的参数，还会记录位置
print(next(g))# 第二次执行的时候就会从上一次执行的地方继续执行
print(next(g))
b、简单的生成器
def func1():
count = 1
while 1:
yield count
count += 1
f = func1()
print(next(f))
print(next(f))
c、生成斐波拉契数列
写法一:
num = input("请输入数列长度：")
def func1():
a = 1
yield a
b = 1
yield b
while 1:
tmp = a + b
yield tmp
a = b
b = tmp
f = func1()
for i in range(int(num)):
print(next(f), end=" ")
写法二：
num = input("请输入数列长度：")
def func1():
a = 0
b = 1
while 1:
yield b
a, b = b, a+b
f = func1()
for i in range(int(num)):
print(next(f), end=" ")
d、生成器函数执行过程
- 当执行f=fib()返回的是一个生成器对象，此时函数体中的代码并不会执行，而是首先返回一个 iterable 对象！
- 只有显示或隐示地调用next的时候才会真正执行函数里面的代码
- 执行到语句 yield b 时，fab() 函数会返回yield后面(右边)的值，并记住当前执行的状态
- 下次调用next时，程序流会回到 yield b 的下一条语句继续执行
- 看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返 回当前的迭代值。
- 由此可以看出，生成器通过关键字 yield 不断的将迭代器返回到内存进行处理，而不会一次性 的将对象全部放入内存，从而节省内存空间。
3）生成器的好处
当你需要以迭代的方式去处理一个巨大的数据集合。比如：一个巨大的文件/一个复杂的数据库查 询等。
• 可以用更少地中间变量写流式代码
• 相比其它容器对象它更能节省内存
• 可以用更少的代码来实现相似的功能
def read_file(fpath):
BLOCK_SIZE = 1024
with open(fpath, "rb") as f:
while True:
block = f.read(BLOCK_SIZE)
if block:
yield block
else:
return
如果直接对文件对象调用 read() 方法，会导致不可预测的内存占用。好的方法是利用固定长度的 缓冲区来不断读取文件的部分内容。通过 yield，我们不再需要编写读文件的迭代类，就可以轻松 实现文件读取。
4）send
def counter(start_at=0):
count = start_at
while True:
val = (yield count)# send 发送一个数据会赋值给val，next获取时，val为None
if val is not None:
count = val
else:
count += 1
count = counter(5)
print(type(count))
print(count.__next__())
print(count.send(9))
print(count.__next__())
count.close() # 关闭生成器，后就不能调用next()
print(count.__next__())
5） yield from
后面必须返回可迭代对象
def g1(x):
yield range(x)
def g2(x):
yield from range(x)
it1 = g1(5) #生成器1
it2 = g2(5) #生成器2
print([x for x in it1])
print([x for x in it2])
结果：
[range(0, 5)]
[0, 1, 2, 3, 4]
5、可迭代对象、迭代器、生成器
可迭代对象iterable
迭代器 iterator
生成器 generator
6、总结
-
如何判断一个对象是可迭代对象，迭代器对象或生成器 ？
实现了iter方法的就是可迭代对象，同时实现了next方法的就是迭代器对象。
包含了yeild关键字的迭代器就是生成器 -
迭代器与生成器的区别 ？
生成器能做到迭代器能做的所有事,而且因为自动创建了 iter()和 next()方法,生成器显得特别简洁
生成器也是高效的，使用生成器表达式取代列表解析可以同时节省内存。除了创建和保存程序状态的自动方法,当生成器终结时,还会自动抛出 StopIteration 异常。
生成器也是一种迭代器,但是只能迭代一次,因为只保存一次值 -
可迭代对象与迭代器的区别？
实现了iter方法的就是可迭代对象，同时实现了next方法的就是迭代器对象。 -
如何定义一个生成器 ?
类似于列表推导式，使用（）生成generator。
定义包含yield关键字的函数 -
如何获取可迭代对象、迭代器与生成器中的数据?
可迭代对象 ：for循环
迭代器、生成器：调用__next__()方法