17可迭代对象

list 是一个迭代对象

可以通过 for .. in .. 这类语句遍历读取数的对象称之为可迭代对象

1li = [1,2,3]
2
3for i in li:
4    print(i)
5

17.1 什么是可迭代对象

可迭代对象

1. 字符串
2. 列表
3. 元组
4. 字典
5. 集合

满意以下条件的也可以成为可迭代对象

1. 对象实现了 _iter_ 方法
2. __iter__ 方法返回了迭代器对象

for工作原理

1. 在内部对可迭代对象调用__iter__方法，获取到迭代器对象
2. 再一次次通过迭代器对象调用__next__方法获取迭代结果

判断对象是否可以迭代？

1. 使用函数 isinstance() isinstance(对象，Iterable)

1from collections.abc import Iterable
2# 这个Iterable再python3.3-python3.9中弃用了，所以需要添加collections.abc
3
4print(isinstance(123, Iterable)) #判断123是否是可迭代对象
5print(isinstance("python",Iterable)) #判断"python"是否为可迭代对象
6
7

17.2 迭代器、iter和next

迭代器只能往前不会后退

迭代器有两个函数： iter()和next()

通过iter()函数取得可迭代对象的迭代器

1li = ['zs','lisi','wangwu','zhaoliu'] #列表是可迭代对象
2
3name_iter = iter(li) #获得迭代器对象
4
5print(next(name_iter))
6print(next(name_iter))
7print(next(name_iter))
8print(next(name_iter))
9print(next(name_iter))    #取完元素后，还取值就会抛异常
10
11
12
13#============等价于==================
14name_iter = li.__iter__()
15
16print(name_iter.__next__())
17
18

总结

1. iter() 调用该对象的__iter__方法，并把__iter__方法返回的结果作为自己的返回值
2. 再使用next()函数来调用__next__方法
3. 取完元素后，__next__方法将引发StopIteration异常

17.3 可迭代对象和迭代器

可迭代对象 iterable

迭代器 iterator

凡是可以for循环的都属于可迭代对象

凡是可以next的都是迭代器

<font color="red">注！！迭代器一定是可迭代对象</font>

1from collections.abc import Iterable,Iterator
2name = "你好啊"
3print(isinstance(name,Iterable)) #是否为可迭代对象
4print(isinstance(name,Iterator)) #是否为迭代器
5
6# 输出结果
7# True
8# False
9
10
11name_iter = iter(name)
12print(isinstance(name_iter,Iterable)) #是否为可迭代对象
13print(isinstance(name_iter,Iterator)) #是否为迭代器
14
15# 输出结果
16# True
17# True
18

总结

1. 可迭代对象可以通过方法变成迭代器对象
2. 如果一个对象拥有iter方法，是可迭代对象；如果一个对象拥有next方法，是迭代器对象
3. 定义可迭代对象，必须实现iter方法；定义迭代器，必须实现iter方法和next方法

17.4 迭代器协议

迭代器对象就是实现了迭代器协议的对象

概念

1. 对象必须提供一个next方法，该方法要么返回迭代器中的下一项，要么就引起StopIteration异常，来终止迭代。

17.5 自定义迭代器类

条件

1. 有iter方法；返回迭代器对象本身(返回实例对象本身即可，self)
2. 有next方法；返回容器的下一个元素或抛出StopIteration异常

1# 定义一个类，初始值是1，
2class Test:
3    
4    def __iter__(self): #返回迭代器对象的实例
5    	self.n = 0
6    	return self  #返回实例对象本身
7    
8    def __next__(self):
9        self.n += 1
10        return self.n # 返回具体的值
11
12te = Test()
13te_iter = iter(te2)
14print(next(te_iter))
15
16
17for i in iter(te): #注意！不是te_iter而是te
18    print(i)
19
20# 输出结果
21# 1
22# 2
23# 3
24# 4
25# ...

1
2class Test:
3    def __init__(self):
4        self.n = 0
5    
6    def __iter__(self):
7        return self #返回的是当前迭代器类的实例对象
8    def __next__(self):
9        self.n += 1
10        if self.n <= 10:
11            return self.n
12        else:
13            raise StopIteration("终止了，不能继续运行")#超过10，就抛出异常
14            
15    
16t = Test()
17print(t.__next__())
18
19
20for i in t:
21    print(i)
22    
23

17.6 生成器 yield

python提供了一种非常简便的语法能让我们来写出自己的迭代对象

只要在def中有yield关键字的 就成为 生成器

生成器表达式：类似于列表推导式

1
2li = [i*10 for i in range(3)] #列表推导式
3print(li)
4
5li2 = (i*10 for i in range(3)) #生成器表达式
6print(li2) #迭代器
7print(next(li2))
8print(next(li2))
9print(next(li2))
10print(next(li2))
11

使用了yield的函数被称为生成器函数(generator)

1 普通函数，返回值用return ； 生成器函数使用yield语句

2 yield语句一次返回一个结果，在每个结果中间，挂起函数,以便下次从它离开的地方继续执行

1
2def funa(val):
3    li = []
4    li.append(val)
5    print("这是列表")
6funa('a')
7funa('b')
8funa('c')
9

yield关键字，会在知道到yield的时候，将函数挂起，下次一调用next()函数时继续执行

1# 生成器函数
2def funb():
3    print("-----开始了--------")
4    yield 'a' 
5    yield 'b' 
6    yield 'c'
7
8fb = funb() # 调用生成器函数，返回的是一个生成器对象
9print(next(fb)) 
10print(next(fb)) #从挂起的地方继续往下执行
11print(next(fb))
12
13
14# 输出结果
15# -----开始了--------
16# a
17# b
18# c
19

1def funa():
2    i = 0
3    while True:
4        print("开始工作---")
5        i += 1
6        yield i
7
8gen = funa() #生成器对象
9print(next(gen))  #执行到yield就暂停函数
10print("********")
11print(next(gen)) #执行到yield就暂停函数
12print("********")
13print(next(gen)) 
14
15
16# 输出结果
17# 开始工作---
18# 1
19# ********
20# 开始工作---
21# 2
22# ********
23# 开始工作---
24# 3

1
2def test2(n):
3    a = 0
4    while a < n:
5        yield a
6        a += 1
7
8for i in test2(10):
9    print(i)
10
11
12# 输出结果：
130
141
152
163
174
185
196
207
218
229
23