迭代器

1. 迭代器介绍

迭代器即用来迭代取值的工具，而迭代是重复反馈过程的活动，其目的通常是为了逼近所需的目标或结果，每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代

# 单纯的循环不是迭代
while True:
    name = input()
    print(name)

# 重复且迭代（迭代取值）
l = ['umi', 'rem', 'ram']
i = 0
while i < len(l):
    print(l[i])
    i += 1

# 迭代器设计用来取值的工具，而涉及到把多个值循环取出来的类型
# 有：列表、字符串、元祖、字典、集合、文件

# 上述迭代取值的方式只适合用于有索引的数据类型（有序类型）：列表、字符串。元祖
# 为了解决索引迭代取值的局限性，python必须提供一种不依赖与索引的取值方式，这就是迭代器

通过索引的方式进行迭代取值，实现简单，但仅适用于序列类型：字符串，列表，元组。对于没有索引的字典、集合等非序列类型，必须找到一种不依赖索引来进行迭代取值的方式，这就用到了迭代器。

1.1 可迭代对象

想要了解迭代器为何物，必须事先搞清楚一个很重要的概念：可迭代对象（Iterable）。从语法形式上讲，内置有__iter__方法的对象都是可迭代对象，字符串、列表、元组、字典、集合、打开的文件都是可迭代对象：

sl = ''
sl.__iter__()
l = []
l.__iter__()
t = (1,)
t.__iter__()
d = {'a': 1}
d.__iter__()
set1 = (1, 2, 3)
set1.__iter__()
with open(r'a.txt', mode='r') as f:
    f.__iter__()

# 调用可迭代对象下的__iter__方法会将其转换成迭代器对象
d = {'a': 1, 'b': 2, 'c': 3}
d_iterator = d.__iter__()
# print(d_iterator)
'''
print(d_iterator.__next__())
print(d_iterator.__next__())
print(d_iterator.__next__())
print(d_iterator.__next__()) # 抛出异常StopIteration表示取值取干净了
'''

while True:
    try:
        print(d_iterator.__next__())
    except StopIteration:
        break
print('======》》》')  # 在一个迭代器取值取完的情况下，在对其取值取不到

d_iterator = d.__iter__()
while True:
    while True:
        try:
            print(d_iterator.__next__())
        except StopIteration:
            break

# 对有索引类型进行迭代取值
l = [1, 2, 3, 4, 5]
l_iterator = l.__iter__()

while True:
    try:
        print(l_iterator.__next__())
    except StopIteration:
        break

1.2 迭代器对象

调用obj.iter()方法返回的结果就是一个迭代器对象（Iterator）。迭代器对象是内置有iter和next方法的对象，打开文件的本身就是一个迭代器对象，执行迭代对象.iter()方法得到的仍然是迭代器本身，而执行迭代器.next()方法就会计算出迭代器中的下一个值。迭代器是python提供的一种统一的，不依赖与索引的迭代取值方式，只要存在多个‘值’，无论序列类型还是非序列类型都可以按照迭代器的方式取值

>>> s={1,2,3} # 可迭代对象s
>>> i=iter(s)  # 本质就是在调用s.__iter__(),返回s的迭代器对象i，
>>> next(i) # 本质就是在调用i.__next__()
1
>>> next(i)
2
>>> next(i)
3
>>> next(i)  #抛出StopIteration的异常，代表无值可取，迭代结束

1.3 可迭代对象与迭代器对象

1.3.1 可迭代对象（“可以转换成迭代器的对象”）：内置有__iter__方法的对象

# 可迭代对象.__iter__():得到迭代器对象

1.3.2 迭代器对象：内置有__next__方法并且内置有__iter__方法的对象

# 迭代器对象.__next__():得到迭代器的下一个值
# 迭代器对象.__iter__():得到迭代器本身，简单来说就是调了和没调一样
dic = {'a':1,'b':2,'c':3}

dec_iterator = dic.__iter__()
print(dec_iterator is dec_iterator.__iter__().__iter__().__iter__()) # True

# 可迭代对象：字符串、列表、元祖、字典、集合
# 迭代器对象：文件
'123'.__iter__()

[1,2,3].__iter__()

(1,2,3).__iter__()

{'a':1}.__iter__()

{1,2,3}.__iter__()

with open(r'a.txt',mode='w') as f:
    f.__iter__()
    f.__next__()

2. for循环原理

有了迭代器之后，可以不依赖索引迭代取值了，使用while循环的实现方式如下：

goods = ['mac', 'lenovo', 'acer', 'dell', 'sony']
i = iter(goods) # 每次都需要重新获取一个迭代器对象
while True:
    try:
        print(next(i))
    except StopIteration:
        break

for循环又称为迭代循环，in后可以跟任意可迭代对象，上述while循环可简写为：

goods=['mac','lenovo','acer','dell','sony']
for item in goods:   
    print(item)

for循环在工作时，首先会调用可迭代对象goods内置的iter方法拿到一个迭代器对象，然后再调用该迭代器对象的next方法将取到的值赋值给item，执行循环体完成一个循环，周而复始，直到捕捉StopIteration异常，结束迭代。

3. 迭代器的优缺点

基于索引的迭代取值，所有迭代的状态都保存在了索引中，而基于迭代器实现迭代的方式不再需要索引，所有迭代的状态就保存在迭代器中，然而这种方式优点与缺点并存：

3.1 优点

1. 为序列和非序列类型提供了一种统一的迭代取值的方式

2. 惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都放在内存中，受内存大小的限制，可以放值的个数是有限的。

3.2 缺点

1. 除非取尽，否则无法获取迭代器的长度

2. 只能取下一个值，不能回到开始，更像是‘一次性的’，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某一个位置，等待下一次调用next；若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象，如果有两个或多个循环使用同一个迭代器，必然只会有一个循环能取到值。