Python日积月累_6_迭代器+生成器

文章目录

迭代器
- 1. 可迭代对象
- 2. 迭代器
- 3. 动手写一个可迭代的类
- 4. 封装到一个类中
- 5. 迭代器的应用
- - range和xrange
  - 使用迭代器生成斐波那契数列
  - 列表解析式
生成器
- 生成器的函数实现
- 通过send方法从外向内给生成器传值

迭代器

1. 可迭代对象

from collections import Interable
print(isinstance([11,22,33],Interable))

如果要使一个对象是可迭代的，必须重写__iter__方法，这样才能通过Interable的检验，但是此时仍不能通过for函数遍历，所以仅仅是可迭代对象，而不是迭代器。

示例代码：

from collections.abc import Iterableclass ClassMate():def __init__(self) -> None:self.name = list()def add(self,name):self.name.append(name)def __iter__(self):passclassmate = ClassMate()
print("判断ClassMate是否是可迭代对象：",isinstance(classmate,Iterable))

2. 迭代器

迭代器必须重写__iter__方法和__next__方法，其中，__iter__方法必须返回一个对象的引用。

可以使用for循环遍历迭代器，for temp in xxx_obj的执行过程：

判断对象xxx_obj是否有__iter__方法（可迭代对象）
在第一步成立的条件下，调用iter函数，得到对象xxx_obj的__next__的返回值，其返回值就是一个迭代器
自动调用迭代器的next函数，即调用迭代器的__next__方法，直到抛出StopIteration异常。

对于这样一个for循环

for i in seq:do_something_to(i)

实际上是这样工作的

fetch_iterator = iter(q)
while True:try:i = fetch_iterator.next()except StopIteration:breakdo_something_to(i)

迭代器非常重要，python3中字典、文件、列表都是可迭代的对象。

3. 动手写一个可迭代的类

from collections.abc import Iterable
from collections.abc import Iterator
# 实现将一个可迭代的类class ClassMate(object):def __init__(self) -> None:self.names = list()def add(self,name):self.names.append(name)def __iter__(self):# 返回一个迭代器的实例对象return ClassIterator(self)class ClassIterator(object):def __init__(self,obj):self.obj = obj# 通过实例属性记录前一次指针的位置self.current_num = 0def __iter__(self):passdef __next__(self):"""next方法执行此方法"""if self.current_num < len(self.obj.names):# 手动防止越界ret =  self.obj.names[self.current_num]self.current_num += 1return retelse:raise StopIteration# for 循环会自动捕获错误classmate = ClassMate()
classmate.add('小王')
classmate.add('小美')
classmate.add('小明')class_iterator = iter(classmate)print("判断classmate是否是可迭代对象",isinstance(classmate,Iterable))
print("判断class_iterator是否是迭代器",isinstance(class_iterator,Iterator))for name in classmate:print(name)# Output:
# 判断classmate是否是可迭代对象 True
# 判断class_iterator是否是迭代器 True
# 小王
# 小美
# 小明

执行过程：

注意：

可迭代对象A的__iter__返回一个迭代器的实例对象B，迭代器B初始化时需要将可迭代对象A 传入初始化方法；
迭代器实例对象通过一个实例属性self.current_num记录当前读取的位置
需要手动防止越界，否则for语句会不断执行__next__，并捕获返回的None，此时，可通过抛出 StopIteration 错误，for循环会自动捕获。

4. 封装到一个类中

上面的方法使用了两个类，有点浪费资源，我们将其全部封装到一个类中

from collections.abc import Iterable
from collections.abc import Iterator
# 实现将一个可迭代的类class ClassMate(object):def __init__(self):self.names = list()self.current_count = 0def add(self,name):self.names.append(name)def __iter__(self):# 返回自身实例对象return selfdef __next__(self):if self.current_count<len(self.names):ret = self.names[self.current_count]self.current_count+=1return retelse:raise StopIterationclassmate = ClassMate()
classmate.add('小王')
classmate.add('小美')
classmate.add('小明')class_iterator = iter(classmate)print("判断classmate是否是可迭代对象",isinstance(classmate,Iterable))
print("判断class_iterator是否是迭代器",isinstance(class_iterator,Iterator))for name in classmate:print(name)# Output:
# 判断classmate是否是可迭代对象 True
# 判断class_iterator是否是迭代器 True
# 小王
# 小美
# 小明

5. 迭代器的应用

range和xrange

【补充】range和xrange的区别：

range和xrange的区别：在python2中range返回数值，xrange返回一个可迭代的对象，占用了极小的空间，

在python3中，range也返回的是一个可迭代对象了。

使用迭代器生成斐波那契数列

例如可以使用迭代器实现斐波那契数列

# 一般实现
a = 0
b = 1
i = 0
while i<10:a,b = b,a+bprint(a)

# 迭代器实现class  Fibonacci(object):def __init__(self,all_num):self.max_num = all_numself.count_num = 0self.a = 0self.b = 1def __iter__(self):return selfdef __next__(self):if self.count_num < self.max_num:self.count_num += 1self.a,self.b = self.b,self.a+self.breturn self.aelse:raise StopIterationfibo = Fibonacci(10)
for num in fibo:print(num)

列表解析式

列表解析，List comprehensinos，来自于Haskell语言，可以取代lambda、map和filter函数的部分使用场景。

语法[expr for iter_val in iterable if cond_expr]

例1：计算一个序列成员的平方

map(lambda x:x**2,range(6))
# 或者
[x**2 for x in range(6)]

例2：挑选出序列seq中的奇数

filter(lambda x: x%2,seq)
# or
[x for x in seq if x%2]

例3：计算文本中的单词个数【列表解析式支持多重循环和多个if语句，执行顺序从左到右】

f = open('test.txt','r')
len([word for line in f for word in line.split()])

生成器表达式和列表解析式很类似：(expr for iter_val in iterable if cond_expr)，因为生成器表达式使用了“延迟计算”(lazy evaluation)，所以在内存上比列表解析式更加有效。

生成器

生成器是一种特殊的迭代器，你只能对它迭代一次，因为它在运行时生成值，并不存储进内存。

生成器的函数实现

生成器由两种定义方式，第一种即是将列表解析式的[]换成()，不过更常用的是函数的形式：

例子：使用生成器生成斐波那契数列

def create_num(all_num):a,b = 0,1count_num = 0while count_num < all_num:yield a  a,b = b,a+bcount_num += 1
obj = create_num(10)
for i in obj:print(i)# 当执行到yield的时候，生成器会暂停输出，并返回结果

可见，生成器和函数的一个重要区别就是函数名()h会立即执行，而obj = 生成器()只是创建一个生成器对象，通过next obj的方式，返回内部yield对应的值，下次调用next的时候，则会从上次yield暂停的地方开始执行。

当然也可以使用while True的方式遍历生成器对象，但是 需要手动捕获异常 作为结束条件。

def create_num(all_num):a,b = 0,1count_num = 0while count_num < all_num:yield a  a,b = b,a+bcount_num += 1 obj = create_num(10)
while True:try:ret = next(obj)print(ret)except Exception as ret:print(ret.value)break

也可以创建多个生成器，互不影响，类似于类创建的对象之间的关系。

通过send方法从外向内给生成器传值

生成器的yield不仅能够将生成器内部的值传出来，还能够接收外部传送的数据，需要send方法传递。

demo:

def create_num(all_num):a,b = 0,1count_num = 0while count_num < all_num:ret_in = yield a  print(">>>ret>>>",ret_in)a,b = b,a+bcount_num += 1 obj = create_num(10)
ret_out = next(obj)
print(ret_out)ret_out = obj.send("hahahah")
print(ret_out)

首先，执行yield a，将a的值传递给ret_out，然后在send调用时，继续执行这一行，但是yield已经没有返回值，这里传递给ret_in的值，就是send中的参数。

注意：send不能在一开始处就调用，否则会报错。

小结：

拥有一个__iter__和__next__方法的类的实例对象叫做迭代器，可以节省内存空间；拥有yield的函数叫生成器，可以在yield处暂停执行，并在下次调用时从上次暂停的地方重新开始，两者都可以通过next进行遍历。