Python中的迭代器、生成器和装饰器

铁松溜达py

已于 2023-11-23 23:58:08 修改

阅读量395

点赞数 1

文章标签： python 开发语言

于 2023-11-20 01:08:35 首次发布

本文链接：https://blog.csdn.net/book_dw5189/article/details/134498239

版权

当谈到Python中的迭代器、生成器和装饰器时，这三个概念都是与函数和数据处理密切相关的。让我们逐个深入了解它们。

1. 迭代器（Iterators）：

Python中可迭代对象和迭代器不同。它们之间的主要区别是，Python中的可迭代对象不能保存迭代的状态，而在迭代器中，当前迭代的状态被保存。

注意：每个迭代器也是一个可迭代对象，但不是每个可迭代对象都是Python中的迭代器。

迭代器是一个可以逐个访问元素的对象。在Python中，迭代器实现了两个方法：__iter__() 和 __next__()。一个对象如果实现了这两个方法，就可以被称为迭代器。

这两个方法一起定义了一个对象的迭代行为。当使用 for...in 循环时，实际上是在每次迭代中调用迭代器的 __next__ 方法，直到 StopIteration 被抛出，表示迭代结束。
对于可迭代对象，它们只需要实现 __iter__ 方法，而迭代器则需要同时实现 __iter__ 和 __next__ 方法。在实际编程中，很多情况下我们会使用生成器（通过 yield 关键字）来简化迭代器的实现。

class MyIterator:
    def __init__(self):
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < 5:
            result = self.current
            self.current += 1
            return result
        else:
            self.current = 0  # 重置迭代器状态
            raise StopIteration

# 创建 MyIterator 的实例
my_iterator = MyIterator()

# 使用 next() 函数手动获取下一个值
print(next(my_iterator))  # 输出: 0
print(next(my_iterator))  # 输出: 1

# 重新创建 MyIterator 的实例，以便重新开始迭代
my_iterator = MyIterator()

# 在 for 循环中自动迭代
for item in my_iterator:
    print(item)



# 迭代器是一个实现了__iter__()和__next__()方法的对象
# 生成器是一种使用yield语句的更简便的迭代器实现方式。生成器能够按需生成值，而不必一次性存储整个序列。


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

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.end:
            result = self.current
            self.current += 1
            return result
        else:
            raise StopIteration

# 使用迭代器
# 迭代器是一个实现了__iter__()和__next__()方法的对象。
# 它可以被用于遍历集合（如列表或字典）中的元素，而不必了解底层的实现细节。
# 迭代器的__iter__()方法返回迭代器对象自身，而__next__()方法返回下一个值。
my_iterator = MyIterator(1, 4)
for num in my_iterator:
    print(num)


def my_generator(start, end):
    current = start
    while current < end:
        yield current
        current += 1
# 使用生成器，它不需要一次性存储所有的值，而是按需生成
# 生成器函数使用yield关键字来产生值，每次调用生成器的__next__()方法时，
# 函数将执行到yield语句并返回一个值，然后暂停，保留当前的状态。
# 生成器对象可以用于迭代，每次迭代时都会执行生成器函数直到下一个yield语句。
gen = my_generator(1, 4)
for num in gen:
    print(num)




gen = [x for x in range(2, 9)]
for num in gen:
    print(num)

2. 生成器（Generators）：

生成器是一种更简单、更便捷创建迭代器的方式。它使用 yield 关键字，每次调用 yield 时，函数会暂停执行并返回结果，下次调用时会从上次暂停的地方继续执行。

生成器的优势在于它们在需要时生成值，而不是一次性生成整个序列。这对于处理大量数据或者在有限内存条件下工作非常有用。

def my_generator():
    for i in range(5):
        yield i

gen = my_generator()

for item in gen:
    print(item)

3. 装饰器（Decorators）：

装饰器是一种用于修改函数行为的工具。它们允许你在不修改原始函数代码的情况下，增加、修改或者包装函数的功能。装饰器允许你在函数执行前后添加额外的逻辑。

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()

4.组合：迭代器、生成器和装饰器：

这三个概念可以很好地结合使用。例如，你可以使用生成器来创建一个简单的迭代器，同时可以使用装饰器来增强生成器的功能。

这个例子中，square_numbers 是一个生成器，产生前 n 个数字的平方。print_square_numbers 函数使用 @my_decorator 装饰器，以在输出前后添加额外的逻辑。

def square_numbers(n):
    for i in range(n):
        yield i**2

@my_decorator
def print_square_numbers(n):
    for num in square_numbers(n):
        print(num)

print_square_numbers(5)

----------------------------

iter() 函数的基本用法可以总结如下：

iterable = iter(iterable_object)

其中，iterable_object 是一个可迭代对象，iter() 函数返回该对象的迭代器。迭代器是一个实现了 __iter__() 和 __next__() 方法的对象，通过调用 __next__() 方法，可以逐个访问可迭代对象的元素。

具体步骤如下：

创建可迭代对象。
使用 iter() 函数获取该对象的迭代器。
使用 next() 函数或 for 循环逐个访问可迭代对象的元素。

下面是一个简单的例子：

# 创建一个列表作为可迭代对象
my_list = [1, 2, 3, 4, 5]

# 使用 iter() 函数获取迭代器
my_iterator = iter(my_list)

# 使用 next() 函数手动获取下一个值
print(next(my_iterator))  # 输出: 1
print(next(my_iterator))  # 输出: 2

# 在 for 循环中自动迭代剩余的值
for item in my_iterator:
    print(item)

可迭代对象（Iterable）：

定义： 可迭代对象是具有 __iter__() 方法的对象，或者实现了 __getitem__() 方法的对象（例如，序列类型如列表、元组、字符串等）。
特点： 可迭代对象可以通过迭代协议（实现 __iter__() 方法）提供一个迭代器。它表示一个数据集合，可以使用 for 循环或 iter() 函数获取一个迭代器。

---

在Python中，迭代器是一个对象，它可以遍历一个可迭代对象（iterable）中的每一个元素。可迭代对象是指一个包含多个元素的对象，例如列表、元组、字典等。

迭代器对象是使用__iter__()方法创建的。每次迭代时，使用__next__()方法返回可迭代对象中的下一个元素。如果没有更多元素，则引发StopIteration异常。下面是一个简单的示例：

my_list = [1, 2, 3]
my_iterator = iter(my_list)

print(next(my_iterator))  # 输出 1
print(next(my_iterator))  # 输出 2
print(next(my_iterator))  # 输出 3
print(next(my_iterator))  # 抛出 StopIteration 异常

在上面的示例中，我们首先将一个列表my_list传递给内置的iter()函数来创建一个迭代器my_iterator。然后我们使用内置的next()函数来访问my_iterator中的元素。

请注意，在第四个print()语句中，StopIteration异常被引发。这是因为迭代器已经遍历完了my_list中的所有元素。

创建迭代器

在Python中，有两种方法可以创建一个迭代器：

方法1：使用iter()和next()函数

如上所述，我们可以使用iter()函数和next()函数来创建和访问迭代器。例如：

my_list = [1, 2, 3]
my_iterator = iter(my_list)

print(next(my_iterator))  # 输出 1
print(next(my_iterator))  # 输出 2
print(next(my_iterator))  # 输出 3

方法2：使用生成器（generator）

另一种创建迭代器的方法是使用生成器。生成器是一种特殊的函数，它使用yield语句来生成一个值，并暂停函数的执行，直到下一次调用。

下面是一个使用生成器创建迭代器的示例：

def my_iterator():
    yield 1
    yield 2
    yield 3

for i in my_iterator():
    print(i)  # 输出 1, 2, 3

在上面的示例中，我们定义了一个名为`my_iterator`的生成器函数，它使用yield语句返回一个值，并在每次调用时暂停函数的执行。然后，我们使用for`循环遍历迭代器中的所有元素。

使用迭代器

一旦我们创建了一个迭代器，我们就可以使用它来遍历一个可迭代对象中的元素。我们可以使用for循环来遍历迭代器，也可以使用next()函数来逐个访问元素。

下面是一个使用迭代器遍历列表的示例：

my_list = [1, 2, 3]
my_iterator = iter(my_list)

for i in my_iterator:
    print(i)  # 输出 1, 2, 3

在上面的示例中，我们首先使用iter()函数创建了一个迭代器my_iterator，然后使用for循环遍历了my_list中的所有元素。

我们还可以使用next()函数逐个访问迭代器中的元素，如下所示：

my_list = [1, 2, 3]
my_iterator = iter(my_list)

print(next(my_iterator))  # 输出 1
print(next(my_iterator))  # 输出 2
print(next(my_iterator))  # 输出 3

自定义迭代器

除了使用内置函数和生成器来创建迭代器之外，我们还可以自定义迭代器。要创建自定义迭代器，我们需要实现两个方法：

__iter__()方法：返回迭代器对象自身。
__next__()方法：返回迭代器中的下一个元素，并在迭代结束时引发StopIteration异常。

下面是一个自定义迭代器的示例：

class MyIterator:
    def __init__(self):
        self.index = 0
        self.data = [1, 2, 3]

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        result = self.data[self.index]
        self.index += 1
        return result

my_iterator = MyIterator()

for i in my_iterator:
    print(i)  # 输出 1, 2, 3

在上面的示例中，我们首先定义了一个名为MyIterator的迭代器类，并实现了__iter__()和__next__()方法。__iter__()方法返回迭代器对象自身，__next__()方法返回迭代器中的下一个元素，并在迭代结束时引发StopIteration异常。

然后，我们创建了一个MyIterator类的实例my_iterator，并使用for循环遍历了迭代器中的所有元素。