python迭代器（Iterator）、生成器(Generator)

清疚 2023-01-20 09:38 218阅读 0赞

### python迭代器（Iterator）、生成器(Generator) ###

**迭代器（**iterator）

官方定义（[https://docs.python.org/zh-cn/3/glossary.html\#term-iterator][https_docs.python.org_zh-cn_3_glossary.html_term-iterator]）：用来表示一连串数据流的对象。重复调用迭代器的 \_\_next\_\_() 方法（或将其传给内置函数 next()）将逐个返回流中的项。当没有数据可用时则将引发 StopIteration 异常。到这时迭代器对象中的数据项已耗尽，继续调用其 \_\_next\_\_() 方法只会再次引发 StopIteration 异常。迭代器必须具有 \_\_iter\_\_() 方法用来返回该迭代器对象自身，因此迭代器必定也是可迭代对象，可被用于其他可迭代对象适用的大部分场合。一个显著的例外是那些会多次重复访问迭代项的代码。容器对象（例如 list）在你每次向其传入 iter() 函数或是在 for 循环中使用它时都会产生一个新的迭代器。如果在此情况下你尝试用迭代器则会返回在之前迭代过程中被耗尽的同一迭代器对象，使其看起来就像是一个空容器。

迭代器指导（tutorial） [https://docs.python.org/zh-cn/3/tutorial/classes.html\#iterators][https_docs.python.org_zh-cn_3_tutorial_classes.html_iterators]

下面解析之。

迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

可迭代对象必须实现\_\_iter\_\_, 迭代器必须实现\_\_iter\_\_和\_\_next\_\_

**如何判断可迭代对象(iterable)和迭代器(iterator)呢？**

可迭代对象（iterable）

官方定义（[https://docs.python.org/zh-cn/3/glossary.html\#term-iterable][https_docs.python.org_zh-cn_3_glossary.html_term-iterable]）：能够逐一返回其成员项的对象。 可迭代对象的例子包括所有序列类型 (例如 list, str 和 tuple) 以及某些非序列类型例如 dict, 文件对象 以及定义了 \_\_iter\_\_() 方法或是实现了 序列 语义的 \_\_getitem\_\_() 方法的任意自定义类对象。  
可迭代对象被可用于 for 循环以及许多其他需要一个序列的地方（zip()、map() ...）。当一个可迭代对象作为参数传给内置函数 iter() 时，它会返回该对象的迭代器。这种迭代器适用于对值集合的一次性遍历。在使用可迭代对象时，你通常不需要调用 iter() 或者自己处理迭代器对象。for 语句会为你自动处理那些操作，创建一个临时的未命名变量用来在循环期间保存迭代器。

☆使用Iterable模块可以判断对象是否是可迭代的：

from collections.abc import Iterable #引入
    s="hello" #定义字符串
    l=[1,2,3,4] #定义列表
    t=(1,2,3) #定义元组
    d={'a':1} #定义字典
    set1={1,2,3,4} #定义集合
    f=open("d://a.txt") #定义文本，注意a.txt需要存在
    # 查看是否都是可迭代的
    print(isinstance(s,Iterable)) #运行结果True
    print(isinstance(l,Iterable)) #运行结果True
    print(isinstance(t,Iterable)) #运行结果True
    print(isinstance(d,Iterable)) #运行结果True
    print(isinstance(set1,Iterable)) #运行结果True
    print(isinstance(f,Iterable)) #运行结果True

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70][]

☆使用Iterator模块可以判断对象是否是迭代器：

from collections.abc import Iterator
    s="hello"
    l=[1,2,3,4]
    t=(1,2,3)
    d={'a':1}
    set1={1,2,3,4}
    f=open("d://a.txt") #定义文本，注意a.txt需要存在
    # 查看是否都是可迭代的
    print(isinstance(s,Iterator)) #运行结果False
    print(isinstance(l,Iterator)) #运行结果False
    print(isinstance(t,Iterator)) #运行结果False
    print(isinstance(d,Iterator)) #运行结果False
    print(isinstance(set1,Iterator)) #运行结果False
    print(isinstance(f,Iterator)) #运行结果True

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1][]

由此可知，只有文件是迭代器，所以可以直接使用next()，而不需要转换成迭代器。

迭代器可以使用函数next()来取值；使用内置函数iter可以将列表转换成一个列表迭代器，使用next()获取值。

**需要注意的是**，可迭代对象(Iterable)不一定是⼀个迭代器(Iterator)，如字符串对象是⼀个可迭代对象，但不是⼀个迭代器，这意味着它⽀持迭代(Iteration)，但我们不能直接对其进⾏迭代操作——不能直接使用内置函数next()，怎样才能对它实施迭代操作呢？使用⼀个内置函数iter()，它将根据⼀个可迭代对象返回⼀个迭代器对象。例如：

my\_string = "Hello"

next(my\_string)  \# 出错

my\_iter = iter(my\_string) \#可用内置函数iter()将?个可迭代对象返回?个迭代器对象

next(my\_iter) \# 不会出错

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2][]

**迭代器的创建**

☆可以利用内置函数iter()和一个序列（如字符串等）来创建。例如：

i = iter("abcd")

from collections.abc import Iterator \#使用Iterator模块可以判断对象是否是迭代器

print(isinstance(i,Iterator)) \# True，是迭代器

next(i) \#可以使用内置函数next()来遍历迭代器的元素

参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3][]

下面使用内置函数iter可以将列表转换成一个列表迭代器，使用next()获取值，一次值取一个值，当值取完了，再使用一次next()的时候，会报异常StopIteration，可以通过异常处理的方式来避免，try-except-else就是一个最常用的异常处理结构，例如：

my_list=[1,2,3]
    li=iter(my_list) #将列表转换成一个列表迭代器
    while True:
       try:
          print(next(li))
       except StopIteration:
          print("Over")
          break
       else:
          print("get!")

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4][]

☆自定义迭代器类  
把一个类作为一个迭代器使用需要在类中实现两个方法 \_\_iter\_\_() 与 \_\_next\_\_() 。  
下面给出一个数数的例子：

class MyCounter():
        def __init__(self, start, stop):
            self.start = start
            self.stop = stop 
            
        def __iter__(self):
            return self
     
        def __next__(self):
            if self.start <= self.stop:
                  x = self.start
                  self.start += 1
            else:
                raise StopIteration
            return x
     
    C = MyCounter(10,12)
    print(next(C))
    print(next(C))

请注意，有了def \_\_iter\_\_(self)和 def \_\_next\_\_(self)，类 MyCounter 就是迭代器了。

运行输出：

10  
11

从字面意思，迭代就是重复反馈过程的活动，其目的通常是为了比较所需目标或结果，在python中可以用迭代器来实现。

优点：

迭代器在取值的时候是不依赖于索引的，这样就可以遍历那些没有索引的对象，比如字典和文件

迭代器与列表相比，迭代器是惰性计算，更节省内存

缺点：

无法获取迭代器的长度，没有列表灵活

只能往后取值，不能倒着取值

**生成器**（generator）

官方定义（[https://docs.python.org/zh-cn/3/glossary.html\#term-generator][https_docs.python.org_zh-cn_3_glossary.html_term-generator]）：返回一个 generator iterator 的函数。它看起来很像普通函数，不同点在于其包含 yield 表达式以便产生一系列值供给 for-循环使用或是通过 next() 函数逐一获取。

通常是指生成器函数，但在某些情况下也可能是指 生成器迭代器。如果需要清楚表达具体含义，请使用全称以避免歧义。

生成器指导（tutorial）[https://docs.python.org/zh-cn/3/tutorial/classes.html\#generators][https_docs.python.org_zh-cn_3_tutorial_classes.html_generators]

在 Python 中，使用了 yield语句 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值。并在下一次执行 next() 方法时从当前位置继续运行。

关于yield语句 参见 [https://docs.python.org/zh-cn/3/reference/simple\_stmts.html\#the-yield-statement][https_docs.python.org_zh-cn_3_reference_simple_stmts.html_the-yield-statement]

下面解析之。

下面来看一个简单的生成器

def my_yield():
        print('first')
        yield 1
    g=my_yield()
    print(g)

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 5][]

生成器也是一个迭代器，测试上面简单的生成器是否是迭代器代码如下：

from collections.abc import Iterator
    def my_yield():
        print('first')
        yield 1
    g=my_yield() #
    print(isinstance(g,Iterator)) #运行结果True

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 6][]

生成器的执行过程

下面给出一个长点的例子，由此了解执行流程

def my_yield():
        print('first')
        yield 1
        print('second')
        yield 2
        print('Third')
        yield 3
    g=my_yield()
    next(g)
    next(g)
    next(g)

运行之，参见下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 7][]

1.定义生成器my\_yield，并将其赋值给了g

def my\_yield():

g=my\_yield()

2.开始第一次执行next()，开始执行生产器函数 ，打印第一语句，遇到yileld的时候暂停，并返回一个1，如果你想打印返回值的话，这里会显示1

print('first')

yield 1

3.再执行2次，打印字符串（每执行一次都会暂停一下）

print('second')

yield 2

print('Third')

yield 3

4.如果再加一次next()就会报出StopIteration异常了

**总之**，用简单的话讲，迭代(Iteration)就是从某个地方（比如一个列表）取出一个元素的过程。当我们使用一个循环来遍历某个东西时，这个过程本身就叫迭代。

生成器(Generators)也是一种迭代器，但是你只能对其迭代一次。这是因为它们并没有把所有的值存在内存中（这样做会消耗大量资源），而是在运行时生成值。若想通过遍历来使用它们，要么用一个"for"循环，要么将它们传递给任意可以进行迭代的函数或结构。大多数时候生成器是以函数来实现的。然而，它们并不返回一个值，而是yield(生出、产生)一个值。

下面，以计算斐波那契数列为例，说明是否用生成器的区别

先看使用生成器

#计算斐波那契数列，使用生成器版
    def fibon(n):
        a =	b = 1
        for	i in range(n):
            yield a
            a, b =	b, a + b
    #现在可以这样使用生成器
    for x in fibon(5000):
        print(x)

用这种使用生成器方式，我们可以不用担心它会使用大量资源（内存）。下面是不使用生成器方式

#计算斐波那契数列，不用生成器版
    def fibon(n):
        a =	b = 1
        result = []
        for	i in range(n):
            result.append(a)
            a, b =	b, a + b
        return result
    #现在可以这样使用生成器，思考当调用时输入的参数很大时可能发生的问题
    for x in fibon(5000):
        print(x)

思考当调用时输入的参数很大时可能发生的问题——它会使用大量资源（内存）。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 8][]

进一步学习：

Python迭代器详解[ https://blog.51cto.com/nxlhero/2480488][https_blog.51cto.com_nxlhero_2480488]

python 基础系列--可迭代对象、迭代器与生成器 [https://mp.weixin.qq.com/s/--zEhMcQ6nzwzFguOVxaVg][https_mp.weixin.qq.com_s_--zEhMcQ6nzwzFguOVxaVg]

生成器(generator) [https://www.cnblogs.com/mswei/p/9283386.html][https_www.cnblogs.com_mswei_p_9283386.html]

[https_docs.python.org_zh-cn_3_glossary.html_term-iterator]: https://docs.python.org/zh-cn/3/glossary.html#term-iterator
[https_docs.python.org_zh-cn_3_tutorial_classes.html_iterators]: https://docs.python.org/zh-cn/3/tutorial/classes.html#iterators
[https_docs.python.org_zh-cn_3_glossary.html_term-iterable]: https://docs.python.org/zh-cn/3/glossary.html#term-iterable
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70]: /images/20221021/1086527e5a7c4f2c9dea8f99f5fc4d6a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 1]: /images/20221021/d00af30314b84e7598cce50b8944be99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 2]: /images/20221021/a76ec3cfb33944e182bc0e2824ce6019.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 3]: /images/20221021/ba7a74f498b94b35a54180a0c03772b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 4]: /images/20221021/95476460192d4dc0a15eec638afbe2d2.png
[https_docs.python.org_zh-cn_3_glossary.html_term-generator]: https://docs.python.org/zh-cn/3/glossary.html#term-generator
[https_docs.python.org_zh-cn_3_tutorial_classes.html_generators]: https://docs.python.org/zh-cn/3/tutorial/classes.html#generators
[https_docs.python.org_zh-cn_3_reference_simple_stmts.html_the-yield-statement]: https://docs.python.org/zh-cn/3/reference/simple_stmts.html#the-yield-statement
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 5]: /images/20221021/c052d8dbac8c4e24a954359144c54fd8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 6]: /images/20221021/233d9fc61ca348c69de609f24407ce48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 7]: /images/20221021/12cc44b03cbd4bc181806d861c55c324.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70 8]: /images/20221021/8bd2696322584002bf19b4dd3c15937d.png
[https_blog.51cto.com_nxlhero_2480488]: https://blog.51cto.com/nxlhero/2480488
[https_mp.weixin.qq.com_s_--zEhMcQ6nzwzFguOVxaVg]: https://mp.weixin.qq.com/s/--zEhMcQ6nzwzFguOVxaVg
[https_www.cnblogs.com_mswei_p_9283386.html]: https://www.cnblogs.com/mswei/p/9283386.html