Python：可迭代对象与迭代器

相关阅读

Pythonhttps://blog.csdn.net/weixin_45791458/category_12403403.html?spm=1001.2014.3001.5482

        根据Python官方文档，可迭代对象(iterable)是“一种能够逐个返回其成员项的对象”。具体来说，这种对象要么定义了一个返回迭代器(iterator)的魔术方法__iter__()，要么定义了魔术方法__getitem__()，并使用从0开始的整数索引。

        Python中的一些内置类型就是可迭代对象，比如列表(list)、元组(tuple)、range对象、字符串(str)、字典(dict)、集合(set)，下面的例子检测了这些类型是否拥有__iter__()方法或__getitem__()方法：

List  = [1, 2, 3]
Tuple = (1, 2, 3)
Range = range(1, 4)
Str   = 'hello, world!'
Dict  = {'name': 'Alice', 'age': 13, 'gender': 'Female'}
Set   = {1, 2, 3}

# 检测是否包含 __getitem__ 方法
print("List has __getitem__:", hasattr(List, '__getitem__'))
print("Tuple has __getitem__:", hasattr(Tuple, '__getitem__'))
print("Range has __getitem__:", hasattr(Range, '__getitem__'))
print("Str has __getitem__:", hasattr(Str, '__getitem__'))
print("Dict has __getitem__:", hasattr(Dict, '__getitem__'))
print("Set has __getitem__:", hasattr(Set, '__getitem__'))

# 检测是否包含 __iter__ 方法
print("List has __iter__:", hasattr(List, '__iter__'))
print("Tuple has __iter__:", hasattr(Tuple, '__iter__'))
print("Range has __iter__:", hasattr(Range, '__iter__'))
print("Str has __iter__:", hasattr(Str, '__iter__'))
print("Dict has __iter__:", hasattr(Dict, '__iter__'))
print("Set has __iter__:", hasattr(Set, '__iter__'))

        结果显示，它们大多都实现了这两个魔术方法，除了集合没有实现__getitem__()方法，如下所示。

输出：
List has __getitem__: True
Tuple has __getitem__: True
Range has __getitem__: True
Str has __getitem__: True
Dict has __getitem__: True
Set has __getitem__: False
List has __iter__: True
Tuple has __iter__: True
Range has __iter__: True
Str has __iter__: True
Dict has __iter__: True
Set has __iter__: True

        collections.abc.Iterable是一个基类，可以用它检测一个对象是否拥有__iter__()方法，如下所示。

from collections.abc import Iterable
# 检测是否含有__iter__()
print("List is Iterable:", isinstance(List, Iterable))
print("Tuple is Iterable:", isinstance(Tuple, Iterable))
print("Range is Iterable:", isinstance(Range, Iterable))
print("Str is Iterable:", isinstance(Str, Iterable))
print("Dict is Iterable:", isinstance(Dict, Iterable))
print("Set is Iterable:", isinstance(Set, Iterable))
# 输出：
List is Iterable: True
Tuple is Iterable: True
Range is Iterable: True
Str is Iterable: True
Dict is Iterable: True
Set is Iterable: True

        但这不是一个可靠的检测方式，因为如果一个可迭代对象只拥有__getitem__()方法，则这种方式就会失效。一个可靠的方式是使用Python内置函数iter()。

        可迭代对象可以使用内置函数iter()转化为迭代器(iterator)，iter()函数首先会尝试调用可迭代对象的__iter__()方法返回一个迭代器（是否是迭代器是根据返回对象是否拥有__next__方法检测的，如返回的不是迭代器则会产生TypeError异常: iter() returned non-iterator of type ***），如果不存在__iter__()方法，则会寻找是否有索引从0开始的__getitem__()方法并尝试创建一个迭代器，如果仍然不存在，则会引发TypeError异常。

        下面展示了一些内置类型使用iter()函数创建的迭代器，直接使用__iter__()方法也可返回迭代器，但它不检测返回的是否是迭代器，因此最好使用iter()函数。

# 检测迭代器的类型
ListIter = iter(List)    # 直接使用List.__iter__()方法也可返回迭代器
print(type(ListIter))  
TupleIter = iter(Tuple)  # 直接使用Tuple.__iter__()方法也可返回迭代器
print(type(TupleIter))
RangeIter = iter(Range)  # 直接使用Range.__iter__()方法也可返回迭代器
print(type(RangeIter))
StrIter = iter(Str)      # 直接使用Str.__iter__()方法也可返回迭代器
print(type(StrIter))
DictIter = iter(Dict)    # 直接使用Dict.__iter__()方法也可返回迭代器
print(type(DictIter))
SetIter = iter(Set)      # 直接使用Set.__iter__()方法也可返回迭代器
print(type(SetIter))

# 输出：
<class 'list_iterator'>
<class 'tuple_iterator'>
<class 'range_iterator'>
<class 'str_iterator'>
<class 'dict_keyiterator'>
<class 'set_iterator'>

        迭代器拥有__iter__()方法（用于返回自己，因此迭代器本身也是可迭代对象），和__next__()方法（用于迭代）。

        for循环其实就是迭代的过程，首先会调用iter()函数为可迭代对象创建一个未命名的迭代器，再循环的过程中调用__next__()方法进行迭代，直到迭代器耗尽，触发StopIteration异常并停止循环，并销毁未命名的迭代器。

        使用内置函数next()也可以进行迭代，它们之间的差别不大，如下所示。

# 使用列表迭代器
print(next(ListIter))
print(ListIter.__next__()) 
print(next(ListIter))
print(ListIter.__next__()) 

# 输出：
1
2
3
StopIteration Traceback (most recent call last)

        注意从 Python 3.7 开始，字典的遍历顺序一定和输入顺序一样。所以字典迭代器的迭代顺序是确定的，对字典使用iter()函数，默认返回的是针对键的迭代器，可以通过使用values()方法或items()方法明确指定想要遍历的元素，并返回相应的迭代器。

# 使用字典迭代器
print(next(DictIter))
print(next(DictIter))
print(next(DictIter))

ValueIter = iter(Dict.values())
print(next(ValueIter))
print(next(ValueIter))
print(next(ValueIter))

输出：
name
age
gender
Alice
13
Female

        集合迭代器无法保证遍历顺序，因此不应该对此有任何期待。

        下面的例子定义了一个，只含有__getitem__()方法的可迭代对象，并直接使用循环迭代，还创建了一个迭代器并用next()函数进行迭代。

class MyIterable:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, index):
        return self.data[index]

# 示例用法
my_iterable = MyIterable([1, 2, 3, 4, 5])

for item in my_iterable:
    print(item)

my_iterator = iter(my_iterable)
print(next(my_iterator))
print(next(my_iterator))
print(next(my_iterator))

输出：
1
2
3
4
5
1
2
3

        迭代器对象只能按照顺序前行，无法后退，这意味着对于一个迭代器对象，只能遍历一轮，如果想要多轮迭代，可以重新创建迭代器。

        写这篇文章的起因，是接触了神经网络框架Pytorch中的torchvision.datasets包，里面定义了很多数据集，它们是拥有__getitem__()方法的可迭代对象，因此可以使用索引访问，而dataloader是拥有__iter__()方法的可迭代对象，所以不可以使用索引访问。