当前位置：首页>python>Python之迭代器

Python之迭代器

2026-07-04 02:37:31

第九章 Python之迭代器

1. 迭代器

首先区分两个概念：可迭代对象（iterable），迭代器（iterator）

1.1 可迭代对象（iterable）

概念：能被for循环遍历的对象，就是可迭代对象（iterable）。
如下这些对象都是可迭代对象（iterable）。

names = ['张三', '李四', '王五']
citys = ('北京', '上海', '深圳')
msg = 'hello'

for item in names:
    print(item)

如下这些都不是可迭代对象（iterable）

age = 10
def test():
    pass

for item in test:
    print(item)

# 知识点1：能被for循环遍历的对象，被称为：可迭代对象（iterable）
#region 与下面的endregion配合使用，可以将范围内的代码进行折叠，很好用。
names = ['张三','李四','王五','赵六','田七']
citys = ('北京','上海','广州')
msg = 'Hello Python'
age = 10
def test():
    pass

for item in test:
    print(item)  # TypeError: 'function' object is not iterable不是一个可迭代对象
#endregion

所有的可迭代对象都拥有__iter__内置方法。

# 知识点2：可迭代对象（iterable）能调用到__iter__方法。
names = ['张三','李四','王五','赵六','田七']
citys = ('北京','上海','广州')
msg = 'Hello Python'
age = 10
def test():
    pass

names.__iter__()
citys.__iter__()
msg.__iter__()

# hasattr() 是 Python 内置函数，用于判断对象是否具有指定的属性或方法，返回布尔值 True 或 False‌，语法为hasattr(object, name)，
# 其中 object 为要检查的对象，name 为属性名的字符串。‌‌
print(hasattr(names,'__iter__')) # True
print(hasattr(citys,'__iter__')) # True
print(hasattr(msg,'__iter__')) # True
print(hasattr(age,'__iter__')) # False
print(hasattr(test,'__iter__')) # False

1.2 迭代器（iterator）

调用__iter__方法会得到：迭代器（iterator）
__iter__是一个魔法方法，当调用iter函数时，__iter__会自动调用。
可迭代对象.__iter__()等价于iter(可迭代对象)。
如果iter(obj)能得到一个1迭代器（iterator），那么obj就是可迭代对象。

# 知识点3：调用__iter__方法会得到：迭代器（iterator）
# 1. __iter__是一个魔法方法，当调用iter函数时，__iter__会自动调用。
# 2. 可迭代对象.__iter__() 等价于 iter(可迭代对象。
# 3. 如果iter(obj)能得到一个迭代器(iterator)，那么obj就是可迭代对象。
names = ['张三','李四','王五','赵六','田七']
citys = ('北京','上海','广州')
msg = 'Hello Python'

print(names.__iter__())
print(citys.__iter__())
print(msg.__iter__())

# 执行结果如下：
<list_iterator object at 0x00000124458D5390>
<tuple_iterator object at 0x00000124458D5390>
<str_iterator object at 0x00000124458D5390>
print(iter(names))
print(iter(citys))
print(iter(msg))
# 执行结果如下
<list_iterator object at 0x00000124458D5390>
<tuple_iterator object at 0x00000124458D5390>
<str_iterator object at 0x00000124458D5390>

# 可以很明显的看出来可迭代对象.__iter__() 等价于 iter(可迭代对象。

迭代器（iterator）拥有__next__方法，每次调用都会根据当前的状态，返回下一个元素。
迭代器.__next__()等价于next(迭代器)。
当所有元素全部取出后，若继续使用__next__，Python会抛出StopIteration异常。

# 知识点4：迭代器(iterator)拥有 __next__ 方法，每次调用都会根据当前的状态，返回下一个元素。
# 备注1：迭代器.__next__()  等价于  next(迭代器)。
# 备注2：当所有元素全都取出后，若继续调用 __next__ 方法，Python会抛出 StopIteration 异常。
# region
names = ['张三','李四','王五','赵六','田七']
it = iter(names)
print(it.__next__()) # 张三
print(it.__next__()) # 李四
print(it.__next__()) # 王五
print(it.__next__()) # 赵六
print(it.__next__()) # 田七
# print(it.__next__()) # StopIteration

print(next(it)) # 张三
print(next(it)) # 李四
print(next(it)) # 王五
print(next(it)) # 赵六
print(next(it)) # 田七
# print(next(it)) # StopIteration
# endregion

for循环背后的逻辑

# for循环背后的工作逻辑
# region
names = ['张三','李四','王五','赵六','田七']
# 编写for循环遍历names列表
for item in names:
    print(item)

# 1. 调用[可迭代对象的__iter__方法]获取一个迭代器（iterator）
it = iter(names)
# 2. 开启一个无限循环
while True:
    try:
        # 3. 调用__next__方法，获取下一个元素
        item = next(it)
        print(item)
    except StopIteration:
        # 4. 捕获StopIteration异常，随后结束循环
        break
# endregion

迭代器（iterator）也拥有__iter__方法，并且其返回值是迭代器自身。
这样设计的原因：让for循环也能遍历迭代器（即：为了让iter（迭代器）不出错）。

# 知识点5：迭代器(iterator)也拥有 __iter__ 方法，并且其返回值是迭代器自身。
# 这么设计的原因如下：让 for 循环也能遍历迭代器（即：为了让 iter(迭代器) 不出错）。
# region
names = ['张三','李四','王五','赵六','田七']
it = iter(names)
print(it) # <list_iterator object at 0x0000028D6E826DD0>

result = iter(it)
print(result) # <list_iterator object at 0x0000028D6E826DD0>

x = iter(result)
print(x) # <list_iterator object at 0x0000028D6E826DD0>

it = iter(names)
for item in it:
    print(item)
# endregion

迭代器协议：一个对象如果同时满足如下规范，那该对象就是一个迭代器：
能被iter()接受。
能被next()一步一步取值。

2. 手写迭代器

迭代器是一次性的，状态只会向前推进（可以理解成象棋中的过河卒，只能向前，不能后退），且不会自动重置（迭代器在遍历的过程中会被消耗）

# 迭代器是一次性的，状态只会向前推进（可以理解成象棋中的过河卒，只能向前，不能后退），且不会自动重置（迭代器在遍历的过程中会被消耗）
# region
names = ['张三', '李四', '王五']
it1 = iter(names)
it2 = iter(names)

# 打印的是两个不同的迭代对象，可以从内存地址中看出来
print(it1) # <list_iterator object at 0x0000015B89C56DD0>
print(it2) # <list_iterator object at 0x0000015B89C56DD0>

print(next(it1)) # 张三
print(next(it1)) # 李四
print(next(it1)) # 王五

print(next(it2)) # 张三
print(next(it2)) # 李四
print(next(it2)) # 王五

for item in it1: # 此处在遍历it1会发现什么都没有打印，证明了迭代器在遍历的过程中会被消耗
    print(item)

for item in it2: # 此处在遍历it2会发现什么都没有打印，证明了迭代器在遍历的过程中会被消耗
    print(item)
# endregion

需求：让迭代器可以遍历Person的实例对象。因为Person不是一个迭代器对象，所以，我们需要手写迭代器的实现，完成次需求。

# 需求：让for循环可以遍历Person的实例对象。
# 实现方式1：
# region
class Person:
    def __init__(self, name, age, gender, address):
        self.name = name
        self.age = age
        self.gender = gender
        self.address = address

    def __iter__(self):
        return PersonIterator(self) # 此处的self是Person的实例对象

# 自己实现迭代器的功能
class PersonIterator:
    def __init__(self, p):# 此处的p接受的就是上面的Person实例对象
        # 将外部传入的数据保存好
        self.p = p
        # 设置迭代器的初始化状态（指针位置）
        self.index = 0
        # 配置好需要遍历的Person实例的内容
        self.attrs = [p.name, p.age, p.gender, p.address]

    # 迭代器__iter__方法会返回迭代器自身
    def __iter__(self):
        return self

    # 每次调用__next__方法，会根据当前的状态，返回下一个元素
    def __next__(self):
        # 如果指针的位置超出范围，那就抛出StopIteration异常
        if self.index >= len(self.attrs):
            raise StopIteration
        # 获取要返回的内容
        value = self.attrs[self.index]
        # 更新迭代器状态（指针位置）
        self.index += 1
        # 返回value值
        return value

# 调用目标方法:
p1 = Person('张三', 28, '男', '北京')

for item in p1:
    print(item)

# 执行结果如下：
# 张三
# 28
# 男
# 北京

for item in p1:
    print(item)

# 执行结果如下：
# 张三
# 28
# 男
# 北京

# endregion

# 实现方式2：此种方式不用单独定义一个迭代器对象，而是在Person类内部实现迭代器的功能。
# region
class Person:
    def__init__(self, name, age, gender, address):
        self.name = name
        self.age = age
        self.gender = gender
        self.address = address
        # 设置迭代器的初始化状态（指针位置)
        self.__index = 0# 此处将index设置私有，是不希望通过外部能访问修改次变量
        # 配置好要遍历的内容
        self.__attrs = [name, age, gender, address] # 此处__attrs同上

    def __iter__(self):
        # 这个地方很重要，当多次调用时Person实例对象，需要将指针重置为0，不然迭代器被消耗掉了，第二次for循环不会打印内容
        self.__index = 0
        return self

    def __next__(self):
        # 如果指针的位置超出范围，那就抛出StopIteration异常
        if self.__index >= len(self.__attrs):
            raise StopIteration
        # 获取要返回的内容
        value = self.__attrs[self.__index]
        # 更新迭代器的状态（指针位置）
        self.__index += 1
        # 返回value
        return value

# 目标：
# 下面的p1既是可迭代对象，又是迭代器
p1 = Person('张三', 28, '男', '北京')

for item in p1:
    print(item)

# 执行结果如下：
# 张三
# 28
# 男
# 北京

for item in p1:
    print(item)

# 执行结果如下：
# 张三
# 28
# 男
# 北京
# endregion

# 进阶：迭代器最重要的方法就是__next__，迭代器最终玩的也是这个方法。
from cn2an import an2cn
class Person:
    def __init__(self, name, age, gender, address):
        self.name = name
        self.age = age
        self.gender = gender
        self.address = address
        # 设置迭代器的初始化状态（指针位置）
        self.__index = 0
        # 配置好要遍历的内容
        self.__attrs = [name, age, gender, address]

    def __iter__(self):
        self.__index = 0
        return self

    def __next__(self):
        # 如果指针的位置超出范围，那就抛出StopIteration异常
        if self.__index >= len(self.__attrs):
            raise StopIteration
        # 获取要返回的内容
        value = self.__attrs[self.__index]
        # 在__next__方法中可以自定义实现很多逻辑和效果，这也体现了迭代器玩的就是__next__方法
        # 将字符串转为大写
        if isinstance(value, str):
            value = value.upper()
        # 将数字转换为汉语形式
        if isinstance(value, int):
            value = an2cn(value)
        # 更新迭代器的状态（指针位置）
            self.__index += 1
        # 返回value
        return value

# 目标：
# 下面的p1既是可迭代对象，又是迭代器
p1 = Person('zhangsan', 28, '男', '北京')

for item in p1:
    print(item)

# 执行结果如下：
ZHANGSAN
二十八
男
北京

以上三段代码就是手写迭代器的实际案例，不理解的道友，可以多敲几遍，先熟悉下，然后配合ai工具解读下就明白了。

3. 迭代器的优势

迭代器是惰性计算，不会一次性生成所有的结果，所以能显著的降低内存占用。
当数据量很大，不确定要用多少结果时，推荐使用迭代器。

# 1.迭代器是惰性计算，不会一次性生成所有结果，所以能显著降低内存占用。
# 2.当数据量很大，不确定要用多少结果时，推荐使用迭代器。

# 使用迭代器实现：斐波那契数列
# 斐波那契数列是指这样一个数列：0，1，1，2，3，5，8，13，21，34，55，89……这个数列从第3项开始 ，每一项都等于前两项之和。
import tracemalloc
class Fibo:
    def __init__(self, total):
        # 要生成多少个数
        self.total = total
        # 当前生成到第几个了（计数器，指针）
        self.index = 0
        # 初始化的两个值
        self.pre = 1
        self.cur = 1

    def __iter__(self):
        return self

    def __next__(self):
        # 当生成足够数量后，抛出StopIterator异常
        if self.index >= self.total:
            raise StopIteration
        # 前两项都是1
        if self.index < 2:
            value = 1
        else:
            # 新的结果等于前两项的和
            value = self.pre = self.cur
            # 更新下pre和cur
            self.pre = self.cur
            self.cur = value

            # 计数器+1
            self.index += 1
            # 返回value
          return value

    # 不用迭代器实现：斐波那契数列
    def fibo(total):
        if total <= 0:
            return []
        if total == 1:
            return [1]
        nums = [1, 1]
        for i in range(2, total):
            nums.append(nums[-1] + nums[-2])
        return  nums

分析内存占用情况：

分别运行如下两段代码后，可以很明显的发现迭代器实现明显更节约内存。

# 看内存占用
tracemalloc.start()
f1 = Fibo(0)
print(f1)
m = tracemalloc.get_traced_memory()[1]
print(f'内存占用是：{m / 1024 / 1024}MB')

tracemalloc.start()
f1 = fibo(0)
m = tracemalloc.get_traced_memory()[1]
print(f'内存占用是：{m / 1024 / 1024}MB')

本文来自网友投稿或网络内容，如有侵犯您的权益请联系我们删除，联系邮箱：wyl860211@qq.com 。

1.2 迭代器（iterator）

2. 手写迭代器

3. 迭代器的优势

Python之迭代器

第九章 Python之迭代器

1. 迭代器

1.1 可迭代对象（iterable）

最新文章

热门文章

随机文章

Python之迭代器

第九章 Python之迭代器

1. 迭代器

1.1 可迭代对象（iterable）

1.2 迭代器（iterator）

2. 手写迭代器

3. 迭代器的优势

Python 列表完全指南:从入门到精通|《Think Python》第9章

Python + RobotFramework 测试框架分享二(WiFi/BT测试工具)

最新文章

热门文章

随机文章