python迭代器详解

Posted 2023-03-30 我爱吃必胜客

不懂的问题：什么是协变、逆变？渐进式？

_T_co = TypeVar("_T_co", covariant=True)  # Any type covariant containers.

• 作者：20岁爱吃必胜客（坤制作人），近十年开发经验, 跨域学习者，目前于海外某世界知名高校就读计算机相关专业。
• 荣誉：阿里云博客专家认证、腾讯开发者社区优质创作者，在CTF省赛校赛多次取得好成绩。
• 跨领域学习，喜欢摄影、弹吉他、咏春拳。文章深入浅出、语言风趣；爱吃必胜客社区创立者，旨在“发现美 欣赏美

---

• 🏆 学习系列专栏
  。🏅 Python学习宝库
  。🏅 网络安全学习宝库

文章目录

• ⭐️迭代器详解
• • 🌟迭代器示例
  • 🌟__iter__()与__next__()方法解释
  • 🌟常用迭代器zip和enumerate
  • 🌟itertools模块提供的各种迭代器类型
  • 🌟 源码
  • 🌟Python迭代器常见的用法
• ⭐️迭代器与生成器的区别
• • 🌟生成器的例子
• ⭐️迭代器的内部实现
• ⭐️总结
• • 🌟__next__(),__iter__()详细解释
  • 🌟 魔法函数实现原理
  • 🌟 我的故事

⭐️迭代器详解

Python迭代器是Python编程语言中非常常用的一种工具。它是访问容器（例如列表、元组等）中的元素的一种方式，可以逐个访问容器中的元素，而不必将整个容器存储在内存中。

Python迭代器可以被定义为：

1. 一个实现了__iter__()方法的对象；
2. 通过调用__next__()方法来逐个访问容器中的元素。

🌟迭代器示例

下面是一个简单的Python迭代器示例：

class MyIterator:
  def __init__(self, lst):
    self.lst = lst# 列表
    self.index = 0# 索引

  def __iter__(self):
    return self

  def __next__(self):
    if self.index < len(self.lst):
      value = self.lst[self.index]
      self.index += 1
      return value
    else:
      raise StopIteration

在这个示例中，我们创建了一个称为"MyIterator"的类，它包含了一个列表和一个索引值。该类还实现了__iter__()和__next__()方法。

🌟__iter__()与__next__()方法解释

__iter__()方法返回该对象本身，因此可以直接对该对象使用for...in...语句进行迭代。__next__()方法则根据当前索引值来获取列表中的下一个元素，如果已经到达列表末尾，则抛出StopIteration异常。

以下是一个使用MyIterator迭代器的示例：

my_list = [1, 2, 3, 4, 5]
my_iter = MyIterator(my_list)
for item in my_iter:
  print(item)

执行结果为：

1
2
3
4
5

这是一个简单的例子，实际上Python迭代器可以应用于许多不同类型的容器，包括列表、元组、字典以及文件等。

🌟常用迭代器zip和enumerate

在Python标准库中，还提供了一些常用的迭代器，例如enumerate()和zip()。

从更深层次上来讲，Python迭代器是支持惰性计算（lazy evaluation）的一种工具。惰性计算指的是在需要时才进行计算，而非提前将所有的计算都执行完毕。对于大型数据集合，惰性计算可以节省内存开销并提高程序性能。
Python迭代器的另一个特点是可逆性（reversibility），也就是说我们可以通过反向迭代器（reverse iterator）来逆序访问容器中的元素。Python标准库中提供了reversed()函数用于创建反向迭代器。以下是一个简单示例：

my_list = [1, 2, 3, 4, 5]
for item in reversed(my_list):
  print(item)

执行结果为：

5
4
3
2
1

🌟itertools模块提供的各种迭代器类型

此外，Python迭代器还支持使用itertools模块提供的各种迭代器类型，例如cycle()、count()和groupby()等。

需要注意的是，Python 2.x版本中的迭代器实现与Python 3.x有所不同，因此在编写跨Python版本的代码时应当谨慎。

总的来说，Python迭代器是Python编程语言中非常强大和灵活的工具，可以应用于各种场景和数据类型，帮助我们更加高效地处理数据和任务。

🌟 源码

class Iterator(Iterable[_T_co], Protocol[_T_co]):
    @abstractmethod
    def __next__(self) -> _T_co: ...
    def __iter__(self) -> Iterator[_T_co]: ...
    
class Iterable(Protocol[_T_co]):
    @abstractmethod
    def __iter__(self) -> Iterator[_T_co]: ...

🌟Python迭代器常见的用法

1. 计算斐波那契数列

斐波那契数列是指从0和1开始，后续的每一项都是前面两项的和。使用Python迭代器可以很方便地计算斐波那契数列。

class Fib:
    def __init__(self, max):
        self.max = max

    def __iter__(self):
        self.a = 0
        self.b = 1
        return self

    def __next__(self):
        fib = self.a
        if fib > self.max:
            raise StopIteration
        self.a, self.b = self.b, self.a + self.b
        return fib

以上代码定义了一个Fib类，实现了__iter__和__next__两个方法，该类实现了一个迭代器，可以使用for-in语句遍历所有小于max的斐波那契数列元素。

2. 读取大型文件数据

当我们需要处理大量数据时，将整个数据集加载到内存中可能会导致程序崩溃或效率低下。使用Python迭代器来处理大型文件数据非常理想，这种方式只在内存中维护当前处理的数据块，而不需要一次性读取整个文件。

with open('large_file.txt', 'r') as f:
    for line in f:
        process_line(line)

以上代码打开一个大型文件并使用for-in语句迭代遍历每一行数据，可以在不占用太多内存的情况下逐行处理文件。

3. 实现生成器函数

除了使用类来定义迭代器，Python还支持使用生成器函数（generator function）来实现迭代器。生成器函数可以通过yield语句来产生值，当生成器被调用时，它将返回一个可迭代对象，使用for-in语句可以遍历这个可迭代对象。

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

for item in my_generator(5):
    print(item)

以上代码定义了一个生成器函数my_generator，使用yield语句来产生0~max-1的数字。使用for-in语句可以遍历这个生成器函数产生的可迭代对象，输出结果为：

0
1
2
3
4

⭐️迭代器与生成器的区别

在Python中，除了迭代器外，还有一种非常常见的工具就是生成器（generator）。两者都可以用yield语句实现，但它们有一些区别。

• 迭代器必须实现__iter__和__next__方法，而生成器只需要实现一个yield语句即可。
• 生成器可以保存状态，每次调用yield语句时会自动保存当前的局部变量和执行位置，并在下一次调用时恢复执行状态，从而实现了迭代器的功能。
• 生成器的主要作用是生成序列，而迭代器则可以用于各种数据结构的遍历，包括序列、映射、文件等。

🌟生成器的例子

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

以上代码定义了一个名为fibonacci的生成器，它可以按照斐波那契数列的规律不断生成新的数值。我们可以使用for-in语句来迭代这个生成器，也可以使用next函数单独获取它的下一个值：

f = fibonacci()
print(next(f))  # 输出 0
print(next(f))  # 输出 1
print(next(f))  # 输出 1
print(next(f))  # 输出 2

⭐️迭代器的内部实现

Python中的迭代器实际上是基于协议（protocol）实现的，它需要满足两个条件：

• 实现__iter__方法并返回self；
• 实现__next__方法，并在每次调用时返回下一个值，如果没有下一个值则抛出StopIteration异常。

在Python中，任意对象只要满足以上两个条件就可以作为迭代器使用。以下是一个简单的自定义迭代器的例子：

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

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

以上代码定义了一个名为MyIterator的迭代器类，它包含了一个列表作为数据源，

⭐️总结

__iter__():迭代器，生成迭代对象时调用，返回值必须是对象自己,然后for可以循环调用next方法

__next__():每一次for循环都调用该方法（必须存在）

🌟__next__(),iter()详细解释

在 Python 中，使用 __next__() 和 __iter__() 方法可以创建一个迭代器对象。迭代器是一种特殊的对象，它允许我们逐个访问容器中的元素，而不必预先将整个容器加载到内存中。

下面是 __next__() 和 __iter__() 的代码和讲解：

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        #@summary: 迭代器，生成迭代对象时调用，
        #返回值必须是对象自己,然后for可以循环调用next方法

        return self

    def __next__(self):
    #  @summary: 每一次for循环都调用该方法（必须存在）
        if self.index >= len(self.data):
            # 抛出 StopIteration 异常，表示迭代结束
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value

在上面的代码中，创建了一个名为 MyIterator 的迭代器类。该迭代器类包含以下两个方法：

• __init__(self, data)：构造函数，接受一个参数 data，即需要遍历的数据。
• __iter__(self)：实现可迭代协议，返回当前对象的迭代器对象，即返回 self。
• __next__(self)：实现迭代器协议，返回容器中的下一个元素，如果没有更多元素，则抛出 StopIteration 异常。

现在，我们可以使用这个迭代器来遍历任何可迭代对象（如列表、元组、字典等）。下面是使用 MyIterator 迭代器来遍历一个列表的示例代码：

my_list = [1, 2, 3, 4, 5]
my_iterator = MyIterator(my_list)

for i in my_iterator:
    print(i)

在上面的代码中，我们首先创建了一个包含 5 个元素的列表 my_list。然后，我们创建了一个 MyIterator 对象 my_iterator，并将 my_list 作为参数传递给它。最后，我们使用 for 循环来遍历这个迭代器，从而遍历 my_list 中的所有元素。

通过上述示例代码可以看出，使用 __next__() 和 __iter__() 方法可以创建一个自定义的迭代器对象，并用于遍历任何可迭代的对象。

🌟 魔法函数实现原理

Python中的“魔法函数”是一种特殊的函数，其名称以双下划线“__”开头和结尾，例如“init”，“call”等，这些函数在Python的类定义中起到了特殊的作用。魔法函数的实现原理是利用了Python语言的一些特性，即“特殊方法解释器”（SPECIAL METHOD LOOKUP）。

特殊方法解释器的工作方式为：当对象接收到一个消息，但在该对象上没有对应的方法时，会自动查找并调用该对象所在类中的特殊方法，从而实现对该消息的处理。因此，魔法函数的作用就是为Python对象提供了默认的行为或操作，从而方便我们对对象进行操作或控制。

下面以一个简单的例子说明魔法函数的实现原理：

class MyClass:
    def __init__(self, x):
        self.x = x

    def __str__(self):
        return "MyClass with x = ".format(self.x)

# 创建一个MyClass对象
obj = MyClass(10)

# 调用__str__魔法函数
print(obj)

上述代码定义了一个名为MyClass的类，其中包含了__init__和__str__两个魔法函数。__init__用于初始化对象的属性，__str__用于返回对象的字符串表示形式。在创建MyClass对象并输出时，会自动调用__str__函数并返回对象的字符串表示形式。

这就是魔法函数的实现原理：当创建对象时，会自动调用__init__魔法函数进行初始化操作；当需要获取对象的字符串表示时，会自动调用__str__函数。通过使用魔法函数，我们可以很方便地对Python对象进行操作和控制，从而提高程序的效率和可维护性。

除了__init__和__str__这两个常见的魔法函数外，Python语言内置了大量的其他魔法函数，例如：

• call(self, *args, **kwargs): 使对象可以像函数一样被调用；
• getitem(self, key): 实现对象的索引访问；
• setitem(self, key, value): 实现对象的索引赋值；
• len(self): 返回对象的长度；
• add(self, other): 实现对象的加法运算；
• eq(self, other): 判断两个对象是否相等；
• …

通过定义这些内置的魔法函数，我们可以非常方便地实现自己的对象类型，支持各种操作和控制。例如，我们可以自定义一个矩阵类型，并实现其加法、乘法、转置等操作：

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

    def __add__(self, other):
        result = []
        for i in range(len(self.data)):
            row = []
            for j in range(len(self.data[i])):
                row.append(self.data[i][j] + other.data[i][j])
            result.append(row)
        return Matrix(result)

    def __mul__(self, other):
        result = []
        for i in range(len(self.data)):
            row = []
            for j in range(len(other.data[0])):
                s = 0
                for k in range(len(self.data[i])):
                    s += self.data[i][k] * other.data[k][j]
                row.append(s)
            result.append(row)
        return Matrix(result)

    def transpose(self):
        result = []
        for i in range(len(self.data[0])):
            row = []
            for j in range(len(self.data)):
                row.append(self.data[j][i])
            result.append(row)
        return Matrix(result)

    def __str__(self):
        s = ""
        for i in range(len(self.data)):
            for j in range(len(self.data[i])):
                s += str(self.data[i][j]) + " "
            s += "\\n"
        return s

# 创建两个矩阵
m1 = Matrix([[1, 2], [3, 4]])
m2 = Matrix([[5, 6], [7, 8]])

# 执行加法和乘法操作
print(m1 + 

🌟 我的故事

python学习之路任重而道远，要想学完说容易也容易，说难也难。 很多人说python最好学了，但扪心自问，你会用python做什么了？
刚开始在大学学习c语言，写一个飞行棋的小游戏，用dos界面来做，真是出力不讨好。 地图要自己一点一点画出来，就像这样：

================
|				|
|				|
|===============

从此讨厌编程，不想继续学下去。每次作业应付。
算法考试，数据结构考试随便背代码，只求通过。
最后呢？我学会变成了吗？只能对一些概念侃侃而谈，但真的会几行代码，能写出实用工具吗？
答案变得模糊。
所以我们要从现在开始，学好python，不要再糊弄下去！！！

python-迭代器详解

本来在写生成器，但是生成器就是一种特殊的迭代器，所以我觉得还是先把迭代器写一下。

什么是迭代

可以直接作用于for循环的对象统称为可迭代对象(Iterable)。

可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)。

所有的Iterable均可以通过内置函数iter()来转变为Iterator

迭代类型：

1，for循环：可用于任何可迭代的对象，实际上对python中所以会从左到右扫描对象的迭代工具而且都是如此，这些迭代工具包括了for循环，列表解析，in成员关系测试以及map内置函数等。

2.文件迭代器：因为文件对象就是自己的迭代器，优点是：（减少内存的使用，不需要把所以内容都加载到内存中）

3,手动迭代：iter和next

   通过for循环开始时，会通过它传给iter内置函数，以便从可迭代对象中获取一个跌打器，返回的对象含有需要的next方法（这一步对于文件来说不是必须的，因为文件对象就是自己的迭代器）

例如：

#文件
>>> import tab
>>> f=open("test","r")
>>> iter(f) is f
True
#序列字符串
>>> a=[1,2,3,4]
>>> iter(a) is a
False

liefs

本文出自 “王小酸” 博客，请务必保留此出处http://wangaimin.blog.51cto.com/8499946/1908361