py_18 迭代器
迭代器
可迭代对象
内置有__iter__方法的对象都是可迭代对象。如：`字符串、列表、元组、字典、集合、文件对象`
可迭代对象.__iter__() :得到一个迭代器对象
迭代器对象
内置有__next__和__iter__方法的对象
迭代器对象.__next__():得到一个迭代器的下1个值
迭代器对象.__iter__()：得到迭代器本身，说白了调了跟没调一样
for循环原理
1.调用可迭代对象.__inter__()得到一个迭代器对象
2. 迭代器对象.__next__()拿到一个返回值，然后将返回值赋值给in前面的接收变量
3.循环往复步骤2，知道抛出异常`StopIteration`
迭代器的优缺点
优点
1.为序列和非序列类型提供了一种统一的迭代取值方式。
2.不占内存，迭代一次取1个值，同一时刻内存只有1个值。
缺点
1.无法通过索引取值
2.只能取下一个值，不能回到开始。如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值
【Xmind】
image.png
一 迭代器介绍
迭代器即用来迭代取值的工具，而迭代是重复的过程，每次重复都是基于上一次的结果而继续的，单纯的重复并不是迭代。
while True:
msg = input('>>: ').strip()
print(msg)
下述while循环才是一个迭代过程，不仅满足重复，而且以每次重新赋值后的index值作为下一次循环中新的索引进行取值，反复迭代，最终可以取尽列表中的值
goods=['mac','lenovo','acer','dell','sony']
index=0
while index < len(goods):
print(goods[index])
index+=1
1.1 可迭代对象
通过索引的方式进行迭代取值，实现简单，但仅适用于序列类型：字符串，列表，元组。对于没有索引的字典、集合等非序列类型，必须找到一种不依赖索引来进行迭代取值的方式，这就用到了迭代器。
什么是可迭代对象：内置有__iter__方法的对象都是可迭代对象，字符串、列表、元组、字典、集合、文件对象都是可迭代对象：文件对象同时又是迭代器对象，他有__iter__和__next__
goods=['mac','lenovo','acer','dell','sony']
print(goods.__iter__())
print([i for i in dir(dict) if i.startswith("__")and i.endswith("__")])
print([i for i in dir(set) if i.startswith("__")and i.endswith("__")])
dict1 = [i for i in dir(dict) if i.startswith("__")and i.endswith("__")]
set1 = [i for i in dir(set) if i.startswith("__")and i.endswith("__")]
if "__iter__" in dict1:
print(f"dict1是个迭代对象")
if "__iter__" in set1:
print(f"set1是个迭代对象")
结果：
<list_iterator object at 0x000000000298B240>
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__']
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__']
dict1是个迭代对象
set1是个迭代对象
1.2 迭代器对象
调用obj.__iter__()方法返回的结果就是一个迭代器对象(Iterator)。迭代器对象是内置有__iter__和__next__方法的对象，打开的文件本身就是一个迭代器对象，执行迭代器对象.__iter__()方法得到的仍然是迭代器本身，而执行迭代器.__next__()方法就会计算出迭代器中的下一个值。 迭代器是Python提供的一种统一的、不依赖于索引的迭代取值方式，只要存在多个“值”，无论序列类型还是非序列类型都可以按照迭代器的方式取值
goods=['mac','lenovo','acer','dell','sony']
g = goods.__iter__()
print(g.__next__()) # mac
print(g.__next__()) # lenovo
print(g.__next__()) # acer
print(g.__next__()) # dell
print(g.__next__()) # sony
print(g.__next__()) # 取完在调，报错StopIteration，代表无值可取，迭代结束
while True:
try:
print(g.__next__())
except StopIteration as e:
break
print("----".center(50,"-"))
# 在一个迭代器取值干净的情况下，再继续取值，会取不到。要想重新取值，需要再次生成迭代器
# g = goods.__iter__() 这行代码注释会取不到值
while True:
try:
print(g.__next__())
except StopIteration as e:
break
1.3 可迭代对象与迭代器对象详解
1.可迭代对象：内置有iter方法
可迭代对象.iter() :得到一个迭代器对象
2.迭代器对象：内置有next和iter方法的对象
迭代器对象.next():得到一个迭代器的下1个值
迭代器对象.iter()：得到迭代器本身，说白了调了跟没调一样
二 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循环干了那些事情
1.调用goods.__inter__()得到一个迭代器对象
2. 迭代器对象.__next__()拿到一个返回值，然后将返回值赋值给k
3.循环往复步骤2，知道抛出异常`StopIteration`
# dedai.txt 文件内容有4行，第一行 1 第2行 2 第三行 3 第4行 4
with open("dedai.txt",mode="rt",encoding="utf-8") as f:
f.__next__()
# 文件对象是迭代器对象
for line in f:
print(line) # 上面调用了1个next，所以会少第一行直接没打印
结果： 2 3 4 第一行没取到
for 循环在工作时，首先会调用可迭代对象goods内置的__iter__方法拿到一个迭代器对象，然后再调用该迭代器对象的__next__方法将取到的值赋给item,执行循环体完成一次循环，周而复始，直到捕捉StopIteration异常，结束迭代
三 迭代器的优缺点
基于索引的迭代取值，所有迭代的状态都保存在了索引中，而基于迭代器实现迭代的方式不再需要索引，所有迭代的状态就保存在迭代器中，然而这种处理方式优点与缺点并存：
3.1 优点：
1、为序列和非序列类型提供了一种统一的迭代取值方式。
2、惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。
3.2 缺点：
1、除非取尽，否则无法获取迭代器的长度
2、只能取下一个值，不能回到开始，更像是‘一次性的’，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用next；若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象，如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值。
最后感觉今天有点傻屌，我知道from collections import Iterable, Iterator 导入Iterable, Iterator。通过内置函数isinstance(obj,Iterable)是能判断是不是可迭代对象或者是迭代器对象。 我感觉麻烦导入了还要调isinstance方法，我自己有去封装了一个类要处理是否是迭代对象还是 迭代器对象。 是不是有点傻屌，明明有现成的还去封装1个。 心里崩腾啊。。。。
# -*- coding: utf-8 -*-
"""
===========================
# @Time : 2020/8/16 19:17
# @File : CheckIter.py
# @Author: adeng
# @Date : 2020/8/16
============================
"""
class CheckIter:
"""
处理对象可迭代对象还是 迭代器对象
"""
@staticmethod
def check_obj(x) -> (bool):
try:
x.__iter__
except Exception as e:
return False, False
else:
try:
x.__next__
return True, True
except Exception as er:
return True, False
@staticmethod
def check_iterator(x):
"""
是否是迭代器对象
"""
if all(CheckIter.check_obj(x)):
return True
else:
return False
@staticmethod
def check_iterable(x):
"""
是否是可迭代对象
"""
if any(CheckIter.check_obj(x)):
return True
else:
return False
if __name__ == '__main__':
print(CheckIter.check_iterable([])) # True
print(CheckIter.check_iterator([])) # False
list_able = range(5)
print(CheckIter.check_iterator(list_able)) # False
print(list(list_able)) # [0, 1, 2, 3, 4]
print(CheckIter.check_iterable(iter(range(5)))) # True
from collections import Iterable, Iterator
print('---'.center(50, "-"))
print(isinstance(list_able,Iterable)) # True
print(isinstance(list_able,Iterator)) # False
print(isinstance(list_able.__iter__(),Iterator)) # True
