十python沉淀之路--迭代器

Posted 2020-11-02 遥望那月

一、迭代器

1、什么是迭代器协议：对象必须提供一个next方法，执行该方法要返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代（只能往后走，不能往前走）。

2、可迭代对象：实现了迭代协议的对象，（如何实现：对象内部定义了一个__iter__()方法）。

3、协议是一种约定，可迭代对象实现迭代器协议，python的内部工具（如for循环，sum,min,max函数等）使用迭代器协议访问对象。

4、python种强大的for循环机制：

       for循环的本质：循环所有对象，全部是使用迭代器协议。

       正本溯源：
很多人会想，for循环的本质就是遵循迭代器协议去访问对象，那么for循环的对象肯定都是迭代器了啊，没错，那既然这样，for循环可以遍历（字符串、列表、元组、字典、集合、文件对象），那这些类型的数据肯定都是可以迭代对象的？但是，为什么定义一个列表 li = [1,2,3,4,5]没有next()的方法呢。

（字符串，列表，元组，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环时，调用他们内部的__iter__()方法，把他们变成了可迭代对象。然后for循环调用迭代对象的__next__()方法取值，而且for循环会捕捉StopIteration异常，以终止迭代。

5、for循环访问方式：
for循环本质就是遵循了迭代器协议的访问方式，先调用iter_li = li.__iter__()方法，或者直接iter_li=iter(li),然后依次执行iter_li.next(),直到for循环捕捉到stopiteration 终止循环。for循环所有对象的本质都是一样的原理。
6、铺垫

1 x = ‘hello‘
2 # print(dir(x))
3 iter_test = x.__iter__()        
4 print(iter_test)
5 print(iter_test.__next__())
6 print(iter_test.__next__())
7 print(iter_test.__next__())
8 print(iter_test.__next__())
9 print(iter_test.__next__())

1 li = [1,2,3,4]
2 iter_li = li.__iter__() #遵行可迭代协议，故生成了可迭代对象
3 print(iter_li.__next__())
4 print(iter_li.__next__())

7、l针对 list  应用  ，以及for 循环和 while循环的对比

1 li = [1,2,3,4]
2 for i in li:  # 因为li具有__iter__()属性，所以它具有了__next__()的属性，可以进行迭代
3     print(i)          #for 循环具有普遍适用性
4 
5 index = 0
6 while index < len(li):    # 这种方法只适用于列表、字符串、元素，这些具有可迭代属性的类型，超出了这些，这种办法就不能用了
7     print(li[index])
8     index+=1

1 1
2 2
3 3
4 4
5 1
6 2
7 3
8 4

8、针对 set 应用

1 se = {1,2,3,4,5,6}
2 for i in se:
3     print(i)
4 se_iter = se.__iter__()
5 print(se_iter.__next__())
6 print(se_iter.__next__())
7 print(se_iter.__next__())

1 1
2 2
3 3
4 4
5 5
6 6
7 1
8 2
9 3

9、针对 dict 应用

1 di = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
2 iter_di = di.__iter__()
3 print(iter_di.__next__())
4 print(iter_di.__next__())
5 print(iter_di.__next__())

1 a
2 b
3 c

10、用迭代 打开文件

1 f = open(‘test.txt‘,‘r+‘,encoding=‘utf-8‘)
2 iter_f = f.__iter__()
3 print(iter_f)
4 print(iter_f.__next__(),end=‘‘)
5 print(iter_f.__next__(),end=‘‘)
6 print(iter_f.__next__(),end=‘

1 <_io.TextIOWrapper name=‘test.txt‘ mode=‘r+‘ encoding=‘utf-8‘>
2 12344556
3 abcdef
4 ABCDEFG

11、异常操作:try     和   except

1 li = [1,2,3,4,5]
2 diedai_li = li.__iter__()
3 
4 while True:
5     try:
6         print(diedai_li.__next__())
7     except StopIteration:
8         print(‘迭代完成，循环已终止‘)
9         break

1 1
2 2
3 3
4 4
5 5
6 迭代完成，循环已终止

12、迭代器走向：（只能往后走，不能往前走）。

1 ll = [‘爷爷‘,‘爸爸‘,‘儿子‘,‘孙子‘,‘重孙‘]
2 iter_ll = iter(ll)            # ll.__iter__()  等价于  iter(ll)
3 print(iter_ll.__next__())
4 print(next(iter_ll))
5 print(iter_ll.__next__())
6 print(next(iter_ll))

1 爷爷
2 爸爸
3 儿子
4 孙子

 二、为什么要有for循环？
基于上面列表的三种访问方式，我们可以知道，它们是通过下标的方式遍历来访问，序列类型字符串、列表、元组、都有下表，这些都可以用下标访问。但是，非序列类型象字典、集合、文件等，都是没有下标的，而for循环就是基于迭代器协议提供了一个同意的可以遍历所有对象的方法，即遍历前，先调用对象的__iter__()方法，
将其转换成一个迭代器，然后哦使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for 循环嘞遍历了。而且我们看到的效果也是这样的。