17可迭代对象

list 是一个迭代对象

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

li = [1,2,3]

for i in li:
    print(i)

17.1 什么是可迭代对象

可迭代对象

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

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

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

for工作原理

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

判断对象是否可以迭代？

  1. 使用函数 isinstance() isinstance(对象，Iterable)
from collections.abc import Iterable
# 这个Iterable再python3.3-python3.9中弃用了，所以需要添加collections.abc

print(isinstance(123, Iterable)) #判断123是否是可迭代对象
print(isinstance("python",Iterable)) #判断"python"是否为可迭代对象

17.2 迭代器、iter和next

迭代器只能往前不会后退

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

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

li = ['zs','lisi','wangwu','zhaoliu'] #列表是可迭代对象

name_iter = iter(li) #获得迭代器对象

print(next(name_iter))
print(next(name_iter))
print(next(name_iter))
print(next(name_iter))
print(next(name_iter))    #取完元素后，还取值就会抛异常



#============等价于==================
name_iter = li.__iter__()

print(name_iter.__next__())

总结

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

17.3 可迭代对象和迭代器

可迭代对象 iterable

迭代器 iterator

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

凡是可以next的都是迭代器

注！！迭代器一定是可迭代对象

from collections.abc import Iterable,Iterator
name = "你好啊"
print(isinstance(name,Iterable)) #是否为可迭代对象
print(isinstance(name,Iterator)) #是否为迭代器

# 输出结果
# True
# False


name_iter = iter(name)
print(isinstance(name_iter,Iterable)) #是否为可迭代对象
print(isinstance(name_iter,Iterator)) #是否为迭代器

# 输出结果
# True
# True

总结

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

17.4 迭代器协议

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

概念

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

17.5 自定义迭代器类

条件

  1. 有iter方法；返回迭代器对象本身(返回实例对象本身即可，self)
  2. 有next方法；返回容器的下一个元素或抛出StopIteration异常
# 定义一个类，初始值是1，
class Test:
    
    def __iter__(self): #返回迭代器对象的实例
    	self.n = 0
    	return self  #返回实例对象本身
    
    def __next__(self):
        self.n += 1
        return self.n # 返回具体的值

te = Test()
te_iter = iter(te2)
print(next(te_iter))


for i in iter(te): #注意！不是te_iter而是te
    print(i)

# 输出结果
# 1
# 2
# 3
# 4
# ...
class Test:
    def __init__(self):
        self.n = 0
    
    def __iter__(self):
        return self #返回的是当前迭代器类的实例对象
    def __next__(self):
        self.n += 1
        if self.n <= 10:
            return self.n
        else:
            raise StopIteration("终止了，不能继续运行")#超过10，就抛出异常
            
    
t = Test()
print(t.__next__())


for i in t:
    print(i)

17.6 生成器 yield

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

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

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

li = [i*10 for i in range(3)] #列表推导式
print(li)

li2 = (i*10 for i in range(3)) #生成器表达式
print(li2) #迭代器
print(next(li2))
print(next(li2))
print(next(li2))
print(next(li2))

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

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

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

def funa(val):
    li = []
    li.append(val)
    print("这是列表")
funa('a')
funa('b')
funa('c')

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

# 生成器函数
def funb():
    print("-----开始了--------")
    yield 'a' 
    yield 'b' 
    yield 'c'

fb = funb() # 调用生成器函数，返回的是一个生成器对象
print(next(fb)) 
print(next(fb)) #从挂起的地方继续往下执行
print(next(fb))


# 输出结果
# -----开始了--------
# a
# b
# c
def funa():
    i = 0
    while True:
        print("开始工作---")
        i += 1
        yield i

gen = funa() #生成器对象
print(next(gen))  #执行到yield就暂停函数
print("********")
print(next(gen)) #执行到yield就暂停函数
print("********")
print(next(gen)) 


# 输出结果
# 开始工作---
# 1
# ********
# 开始工作---
# 2
# ********
# 开始工作---
# 3
def test2(n):
    a = 0
    while a < n:
        yield a
        a += 1

for i in test2(10):
    print(i)


# 输出结果：
0
1
2
3
4
5
6
7
8
9