python迭代器和可迭代对象

我家大宝最可爱

已于 2023-10-03 16:36:58 修改

阅读量2.4k

点赞数 3

分类专栏： python 文章标签： python 开发语言

于 2022-09-24 21:30:55 首次发布

本文链接：https://blog.csdn.net/he_wen_jie/article/details/127016779

版权

python 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1. 迭代器 vs 可迭代对象

python中两个迭代的概念，一个叫做迭代器（Iterator），一个叫做可迭代对象（Iterable），

可迭代对象：英文后缀是able，表示【能够】，【可以】的意思，就是说这个对象是可以迭代的，我觉得表示的是一种状态或者属性。
迭代器：英文后缀是or，表示【做某事的人或者东西】，这个才是我们要实现的内容，把对象实现了迭代器的操作，这个对象就拥有的可迭代的属性，变成了可迭代对象。

我们可以从collections模块中导入

from collections.abc import Iterable,Iterator

当我们实现了迭代器之后，就可以使用for循环进行遍历了。我们平常使用的字符串，列表，元组和字典等，底层都实现了迭代器。我们可以通过instance来判断

from collections.abc import Iterable,Iterator


s = "abcdefgh"
print(isinstance(s,Iterable)) # True
print(isinstance(s,Iterator)) # False

l = [1,2,3,4,5,6,7,8]
print(isinstance(s,Iterable)) # True
print(isinstance(s,Iterator)) # False

t = (1,2,3,4,5,6,7,8)
print(isinstance(s,Iterable)) # True
print(isinstance(s,Iterator)) # False

哈哈，上来就打脸了，发现字符串，列表和元组并不是迭代器，而是迭代对象。不要紧，继续往下看

2. 如何实现迭代器

迭代器的实现非常简单，只需要实现__iter__和__next__这两个魔法函数即可，

调用迭代器对象的 __iter__方法得到还是迭代器对象本身，就跟没调用一样
调用迭代器对象的__next__方法返回下一个值，不依赖索引
可以一直调用__next__直到取干净，最后抛出异常StopIteration（停止迭代）

我们来实现一个斐波那契数列

from collections.abc import Iterable,Iterator

class Fib:
    def __init__(self):
        self.prev = 0
        self.curr = 1
    
    def __iter__(self): # 自身就是迭代器，所以返回自身
        return self
    
    def __next__(self): # 只有实现了__next__函数才是迭代器
    	print('run __next__ func')
        self.prev,self.curr = self.curr,self.curr+self.prev
        return self.curr

fib = Fib()
print(isinstance(fib,Iterator)) # True
print(isinstance(fib,Iterable)) # True
# 通过next函数获取下一个值
print(next(fib)) # 1
print(next(fib)) # 2
print(next(fib)) # 3
print(next(fib)) # 5

索然无味啊，这迭代器好像并没有什么特别的地方。每次调用next函数，就会进入到__next__函数中，然后计算curr的值，返回出来。

上面实现的迭代器是没有终止条件的，只要你愿意就可以一直计算下去，但是一般的迭代器都是有终止条件的，我们修改一下上面的迭代器

from collections.abc import Iterable,Iterator
from operator import index

class Fib:
    def __init__(self, end):
        self.prev = 0
        self.curr = 1
        self.end = end
        self.index = 0
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index < self.end:
            self.prev,self.curr = self.curr,self.curr+self.prev
            self.index += 1
            return self.curr
        else:
            raise StopIteration

fib = Fib(3)

print(next(fib)) # 1
print(next(fib)) # 2
print(next(fib)) # 3

可以看到正常输出了，如果我们再次调用next呢?

next(fib)

Traceback (most recent call last):
File “fib.py”, line 26, in
print(next(fib)) # 5
File “fib.py”, line 19, in next
raise StopIteration
StopIteration

可以看到，我们得到一个异常对象，注意，主动抛出来的是异常对象，而不是异常，说明我们访问结束了。for循环帮我们处理了异常

for v in fib:
    print(v)

for循环实现的逻辑是这样的

# create an iterator object from that iterable
iter_obj = iter(iterable)
 
# infinite loop
while True:
	try:
		# get the next item
		element = next(iter_obj)
		print(element)
		# do something with element
	except StopIteration:
		# if StopIteration is raised, break from loop
	break

就很有意思，捕获的是StopIteration，那如果我抛出的不是这个异常呢，比如我抛出一个IndexError


import time

class Fib:
    def __init__(self, end):
        self.prev = 0
        self.curr = 1
        self.end = end
        self.index = 0
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index < self.end:
            self.prev,self.curr = self.curr,self.curr+self.prev
            self.index += 1
            time.sleep(0.1)
            print('.',end='',flush=True)
            return self.curr
        else:
            raise IndexError('index > end')

fib = Fib(10)
for v in fib:
    print(v)

Traceback (most recent call last):
File “fib.py”, line 20, in
for v in fib:
File “fib.py”, line 17, in next
raise IndexError(‘index > end’)
IndexError: index > end

可以看到for循环并没有捕获这个异常，而是直接抛出来了。后来我一寻思，觉得理应如此，for循环之需要判断是否完成遍历即可，其他的异常应该交给用户自己处理。

3. 迭代器的好处

回想一下我们平时是怎么实现斐波那契数列的

3.1 每次从头计算（空间换时间）

这种方式非常的耗时，每次都要重头开始计算，但好处是想要获取哪一位的数值直接调用即可，没有任何约束和依赖

import time
def fib(end):
    i = 0
    prev, curr = 0, 1
    print('calc {}th '.format(end),end='')
    while i < end:
        prev, curr = curr, prev + curr
        i += 1
        time.sleep(0.1)
        print('.',end='',flush=True)
    return curr
start = time.perf_counter()
for i in range(10):
	print(fib(i))
end = time.perf_counter()
print('fib cost time {}'.format(end-start))

3.2 结果保存下来（时间换空间）

相对于从头计算，我们可以将所有的结果保存下来，这种方式只需要计算一次，就可以获取之前任意一次的结果，因为所有结果都保存下来了，所以很占空间。

import time
def fib(end):
    print('calc {} '.format(end),end='')
    res = [1]
    i = 0
    prev, curr = 0, 1
    while i < end:
        prev, curr = curr, prev + curr
        i += 1
        res.append(curr)
        time.sleep(0.1)
        print('.',end='',flush=True)
    print('\n')
    return res

start = time.perf_counter()
res = fib(10)
for i in range(10):
	print(res[i])
end = time.perf_counter()
print('fib cost time {}'.format(end-start))

3.3 迭代器实现

迭代器的实现前面已经说过了，很有意思的一点是，我们只有调用了next函数，迭代器才会返回我们下一个结果。如果我想要获取第5个斐波那契数列值，我需要调用5次next函数，每调用一次就会执行一次__next__函数。

import time

class Fib:
    def __init__(self, end):
        self.prev = 0
        self.curr = 1
        self.end = end
        self.index = 0
    def __iter__(self):
        return self
    
    def __next__(self):
        print('calc',end='')
        if self.index < self.end:
            self.prev,self.curr = self.curr,self.curr+self.prev
            self.index += 1
            time.sleep(0.1)
            print('.',end='',flush=True)
            return self.curr
        else:
            raise StopIteration
start = time.perf_counter()
fib = Fib(10)
for v in fib:
    print(v)
end = time.perf_counter()
print('fib cost time {}'.format(end-start))

4 迭代器的局限

迭代器不基于索引的方式获取可迭代对象中的元素。节省了大量的内存，迭代器在内存中相当于只占一个数据的空间。因为每次取值都上一条数据会在内存释放，加载当前的此条数据。惰性机制非常有用，我们平时处理大文件的时候，没有办法一下子读到内存中来，就可以通过迭代器的方式一条一条的读取。
迭代器取值时不走回头路，只能一直向下取值，所以不能直观的查看里面的数据。老实讲，我觉得索引的方式非常的好，想要获取那个位置的数据，直接就可以获取，历史所有的状态都保留了下来，而迭代器则需要一步一步计算过去。所以说，迭代器是一个双刃剑，就看你想要在什么场景下使用

可迭代对象

可迭代对象就非常简单了，迭代器需要实现两个函数，一个是__next__用来计算下一个值，一个是__iter__返回自身，因为自身就是迭代器。可迭代对象只需要实现一个__iter__函数就可以了，这个函数返回一个迭代器。

from collections.abc import Iterable,Iterator
from operator import index

class Fib:
    def __init__(self, end):
        self.prev = 0
        self.curr = 1
        self.end = end
        self.index = 0
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index < self.end:
            self.prev,self.curr = self.curr,self.curr+self.prev
            self.index += 1
            return self.curr
        else:
            raise StopIteration


class Fibable:
    def __init__(self, end):
        self.end = end
    
    def __iter__(self):
        return Fib(self.end)

fib = Fibable(10)
print(isinstance(fib,Iterable)) # True 是可迭代对象
print(isinstance(fib,Iterator)) # False 不是迭代器
for i in fib:
    print(i)

但是可迭代对象没有实现__next__函数，因此无法通过next来获取下一个元素，只能通过for循环获取数据，如果调用next函数则会报错，而且可以看到，报的是类型错误，next函数只能接受迭代器。

next(fib)

Traceback (most recent call last):
File “fib.py”, line 38, in
next(fib)
TypeError: ‘Fibable’ object is not an iterator

自定义可迭代数据

python中还提供了一个魔法函数__getitem__，实现这个函数之后，就可以使用for循环遍历了，pytorch中的dataloader就是这种方式，先举个简单的例子。

from collections.abc import Iterable,Iterator

class Fib:
    def __init__(self) -> None:
        self.res = [0,1,1,2,3,5,8,13,21,35,56,91]

    def __getitem__(self,index):
    	print('run fib func...')
        return self.res[index]

fib = Fib()
print(isinstance(fib,Iterable)) # False 不是可迭代对象
print(isinstance(fib,Iterator)) # False 不是迭代器
for v in fib: # 啥也不是，但就是可以for循环
    print(v)

Fib既不是可迭代对象，也不是迭代器，但是可以使用for循环来遍历数据。而且发现__getitem__还有一个入参index，这说明我们其实可以直接通过索引遍历数据。看看斐波那契数列如何实现

from collections.abc import Iterable,Iterator

class Fib:
    def __init__(self) -> None:
        pass

    def __getitem__(self,index):
        i = 0
        prev, curr = 0, 1
        while i < index:
            print('calc fib...')
            prev, curr = curr, prev + curr
            i += 1
        return curr

fib = Fib()
print(isinstance(fib,Iterable)) # False 不是可迭代对象
print(isinstance(fib,Iterator)) # False 不是迭代器

print(fib[3])

上面实现了斐波那契数列，我们没有保存结果，每次读取结果，每次重头开始计算。简直是无话可说，这就相当于第一种最耗时的方案，非常的愚蠢。我可以稍作修改，变成第二种方式，把所有的结果再初始化的时候都计算一遍然后保存下来，而且可以随意索引，就是占空间。

from collections.abc import Iterable,Iterator

class Fib:
    def __init__(self, end):
    	# 初始化的时候将所有的结果计算一遍，然后保存下来
        self.res = []
        i = 0
        prev, curr = 0, 1
        while i < end:
            prev, curr = curr, prev + curr
            i += 1
            self.res.append(curr)

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

fib = Fib(10)
print(isinstance(fib,Iterable)) # False 不是可迭代对象
print(isinstance(fib,Iterator)) # False 不是迭代器

# 可以使用for循环
for v in fib:
    print(v)

print(fib[3]) # 可以通过索引随意取值

其实我觉得这就是一个单纯的get方法而已，因为其实还有一个方法，叫做__setitem__，这不就是平时使用的@pro和@name.setter吗？
python提供了iter函数，可以将__getitem__转变称迭代器

fib = Fib(10)
print(isinstance(fib,Iterable)) # False 不是可迭代对象
print(isinstance(fib,Iterator)) # False 不是迭代器

fib_iter = iter(fib)
print(isinstance(fib_iter,Iterable)) # True 是可迭代对象
print(isinstance(fib_iter,Iterator)) # True 是迭代器

胡乱测试

可迭代对象只实现了__iter__，如果我再实现了__next__会不会变成迭代器

from collections.abc import Iterable,Iterator
from operator import index

class Fib:
    def __init__(self, end):
        self.prev = 0
        self.curr = 1
        self.end = end
        self.index = 0
    def __iter__(self): # 本身就是迭代器，直接返回自己
        return self
    
    def __next__(self):
        if self.index < self.end:
            self.prev,self.curr = self.curr,self.curr+self.prev
            self.index += 1
            return self.curr
        else:
            raise StopIteration


class Fibable:
    def __init__(self, end):
        self.end = end
    
    def __iter__(self): # 要求返回一个迭代器
        return Fib(self.end)

    def __next__(self):
        print('next func ...')

fib = Fibable(10)
print(isinstance(fib,Iterable)) # True 可迭代对象
print(isinstance(fib,Iterator)) # True 不是迭代器
for i in fib:
    print(i)

万万没想到，竟然真的变成迭代器了，而且可以正常打印出结果。这说明，在迭代的过程中并没有调用__next__，而是调用了__iter__函数。这说明如果同时存在的话，会优先调用__iter__。再尝试使用next执行看看

next(fib) # next func ...
next(fib) # next func ...
next(fib) # next func ...

输出的是__next__的结果，而不是__iter__的结果。

如果同时存在__getitem__和__next__会怎么样呢？

from collections.abc import Iterable,Iterator
from operator import index

class Fib:
    def __init__(self):
        pass

    def __iter__(self):
        return self
    
    def __next__(self):
        print('next func')

    def __getitem__(self,index):
        print('getitem func {}'.format(index))


fib = Fib()
print(isinstance(fib,Iterable)) # True 是可迭代对象
print(isinstance(fib,Iterator)) # True 是迭代器
i = 0
for v in fib:
    if i > 10:break
    i += 1

next(fib)
next(fib)
next(fib)

fib[3]

for会发现优先调用__next__函数，使用next函数调用__next__函数，使用索引调用__getitem__函数

总结

迭代器：实现__iter__和__next__两个魔法函数，可以使用for循环和next
可迭代对象：只能实现__iter__函数，并且这个函数返回的是一个迭代器，可以使用for，由于没有实现__next__函数，所以不能使用next
自定义可迭代数据：实现__getitem__函数，有一个入参index，意味着我们可以通过索引访问，所以也就意味着需要保存较多的数据在内存中，通过iter函数可以将自定义的迭代数据转换成迭代器

个人的一些见解
老实讲，我觉得迭代器还是比较鸡肋的，为了计算下一个状态，需要保存上下文，然后通过处理得到新的状态。如果我们想要实现的就是在循环中不断往下迭代，不需要之前的状态，那么可以使用迭代器，如果想要通过索引来快速得到想要的结果，最好还是使用自定义的迭代对象。

应用举例

我能想到使用迭代器的场景，一般会满足两个条件

数据集非常的大，无法一下子加载到内存中
顺序的消耗数据，一般不会有状态的跳跃

例如我们想要处理1T的数据，不会直接加载到内存中，而是一条一条的加载，这个时候我们就可以把所有的路径加载进来，然后读取每个路径的文件，迭代的对这些数据进行处理。

我家大宝最可爱

关注

3
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
python迭代器和可迭代对象

迭代器：实现__iter__和__next__两个魔法函数，可以使用for循环和next可迭代对象：只能实现__iter__函数，并且这个函数返回的是一个迭代器，可以使用for，由于没有实现__next__函数，所以不能使用next自定义可迭代数据：实现函数，有一个入参index，意味着我们可以通过索引访问，所以也就意味着需要保存较多的数据在内存中个人的一些见解老实讲，我觉得迭代器还是比较鸡肋的，为了计算下一个状态，需要保存上下文，然后通过处理得到新的状态。
复制链接

扫一扫

专栏目录