【无标题】

迭代器与生成器在Python中是非常重要的概念，本文将详细介绍这两者的定义和使用方法。

一、迭代器

1.1 定义

迭代器（Iterator）是访问集合元素的一种方式，它可以记住遍历的位置，并且能够提供一个统一的接口来访问该集合中的元素。迭代器对象从集合的第一个元素开始访问，直到所有元素被访问完毕。

1.2 迭代器方法

Python 中，迭代器是一种机制，即所有对象都可以通过__iter__ 和 next 方法转换成可迭代对象，从而成为一个迭代器。

其中：

• iter() 返回当前对象的迭代器对象。
• next() 返回序列中下一个元素或引发 StopIteration 异常。

1.3 实现自己的迭代器

我们可以利用 Python 中类和方法来实现自己的迭代器：

class MyIterator:
    def __init__(self, start, end):
        self.value = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.value > self.end:
            raise StopIteration
        current_value = self.value
        self.value += 1
        return current_value

    
myiterator = MyIterator(0, 5)
for i in myiterator:
    print(i)

以上代码实现了一个简单的迭代器，它会从0开始输出直到5，输出结果为：

0
1
2
3
4
5

二、生成器

2.1 定义

生成器（Generator）是一种特殊的迭代器，它不是通过一次性生成所有元素并储存到内存中，而是利用 yield 关键字来生成序列中的每个元素。当程序需要访问下一个元素时，Python 解释器会自动恢复执行 yield 语句之后的代码，并将 yield 后面的值作为返回值返回。

2.2 使用方法

在 Python 中，可以使用 yield 关键字来定义一个生成器。例如：

def my_generator(start, end):
    while start <= end:
        yield start
        start += 1

mygenerator = my_generator(0, 5)
for i in mygenerator:
    print(i)

以上代码实现了一个简单的生成器，它会从0开始输出直到5，输出结果为：

0
1
2
3
4
5

可以看到，在调用该函数时，并没有立即执行函数内部代码。而是先建立了一个 generator 对象（也就是 iterable），然后在每次循环中调用__next__() 方法 ，遇到yield关键字时返回并暂停状态，下次循环时从当前位置继续执行。

2.3 实现斐波那契数列

若需生成大量数据时，使用生成器的优势得以发扬光大，因为该方法不像迭代器一般需要在内存中储存所有元素。

下面我们用斐波那契数列来演示如何实现和使用生成器：

def fibonacci(n):
    """生成斐波那契数列"""
    a, b = 0, 1
    for i in range(n):
        yield a
        a, b = b, a + b

mygenerator = fibonacci(10)
for i in mygenerator:
    print(i)

以上代码实现了一个输出前10个斐波那契数列的生成器。

三、迭代器和生成器的区别

总结来说，迭代器和生成器都可以访问序列中的元素。但是，在实现方式上二者有所不同：

• 迭代器是一种访问集合元素的方式，其遍历顺序是固定的；
• 生成器则是一种可自定义元素访问顺序的实现方法，使用了yield关键字来暂停函数并记录当前状态。

此外，当需要处理海量数据时，利用生成器实现函数可以在不占用过多内存的情况下更快地完成任务。

迭代器

1. 遍历列表

我们可以利用迭代器遍历列表：

mylist = [1, 2, 3]
myiterator = iter(mylist)

while True:
    try:
        element = next(myiterator)
        print(element)
    except StopIteration:
        break

以上代码会输出列表中的每个元素：

1
2
3

2. 遍历字符串

同样地，我们也可以使用迭代器遍历字符串：

mystring = "Hello World!"
myiterator = iter(mystring)

while True:
    try:
        element = next(myiterator)
        print(element)
    except StopIteration:
        break

以上代码会输出字符串中的每个字符：

H
e
l
l
o
 
W
o
r
l
d
!

3. 自定义迭代器

我们也可以自定义一个迭代器类来实现遍历操作。例如，下面是一个简单的迭代器类，它可以遍历斐波那契数列前 n 项：

class FibonacciIterator:
    def __init__(self, n):
        self.n = n
        self.a, self.b = 0, 1
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.n > 0:
            self.a, self.b = self.b, self.a + self.b 
            self.n -= 1            
            return self.a 
        else:
            raise StopIteration

myiterator = FibonacciIterator(10)
for i in myiterator:
    print(i)

以上代码输出斐波那契数列前 10 项：

1
1
2
3
5
8
13
21
34
55

生成器

1. 自定义生成器

在 Python 中，我们可以使用 yield 关键字来定义生成器。下面是一个简单的生成器函数，用于生成斐波那契数列的前 n 项：

def fibonacci_generator(n):
    a, b = 0, 1
    
    while n > 0:
        yield a 
        a, b = b, a + b 
        n -= 1 

mygenerator = fibonacci_generator(10)
for i in mygenerator:
    print(i)

以上代码输出斐波那契数列前 10 项：

0
1
1
2
3
5
8
13
21
34

2. 处理海量数据

由于生成器每次只会产生一个值，并且只有当需要时才进行计算，因此它非常适合处理海量数据。

例如，我们可以使用生成器对大型文件进行逐行读取并处理：

def read_file(filename):
    with open(filename) as f:
        for line in f:
            yield line.strip()

for line in read_file("large_file.txt"):
    # 处理每一行数据的代码...
    pass 

以上代码会逐行读取 large_file.txt 文件，并对每行数据进行处理。

总之，生成器是 Python 中非常强大的特性之一，它可以有效地处理海量数据，并且能够节约内存资源。

总结，注意事项：

1. 迭代器是一种访问集合元素的方式，可以按需推送元素而不是事先将整个数据加载到内存中。生成器是一种特殊的迭代器，在需要时生成值。

2. 迭代器可以通过定义一个带有__iter__()和__next__()方法的类来创建。在Python中，也可以通过生成器函数或生成器表达式来创建生成器。生成器函数使用yield语句来逐个返回值。

3. 生成器在内存使用上比列表等序列类型更加节省，因为它不会一次性把所有的值都存储到内存中。

4. 生成器可以用于处理大量数据、按需处理数据、节省内存等场景下。

5. 在迭代器/生成器中不能直接修改元素值，只能通过抛出异常让调用者进行修改操作。

6. 使用迭代器时需要注意是否已经遍历完毕，否则会引发StopIteration异常。

7. 在使用生成器时需要注意yield语句的作用和使用方法，以及如何编写含有yield语句的函数。

8. 可以通过itertools模块提供的工具函数来实现迭代器/生成器的组合、排列、过滤等高级功能。

9. 迭代工具还有zip()、map()、filter()等函数可供使用。这些函数都可以接受迭代对象作为参数，并返回一个新的迭代对象。

10. 在使用迭代器/生成器时需要谨防内存泄露等问题，并注意程序的运行效率。当数据量较大时，应该考虑如何优化算法来提高程序的执行效率。