Python迭代器案例如何创建迭代器

本文目录导读：

1. 基本迭代器创建方法
2. 自定义迭代器类
3. 使用生成器创建迭代器
4. 实际应用案例
5. 迭代器 vs 可迭代对象
6. 最佳实践建议

我来为你详细介绍Python迭代器的创建方法和案例。

基本迭代器创建方法

使用 iter() 函数

# 将可迭代对象转换为迭代器
my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)
# 使用 next() 获取元素
print(next(my_iter))  # 1
print(next(my_iter))  # 2
print(next(my_iter))  # 3

使用 for 循环（自动处理迭代）

my_list = [1, 2, 3, 4, 5]
for item in my_list:
    print(item)  # 自动迭代每个元素

自定义迭代器类

基础自定义迭代器

class Counter:
    """简单的计数器迭代器"""
    def __init__(self, start, end):
        self.current = start
        self.end = end
    def __iter__(self):
        # 返回迭代器对象本身
        return self
    def __next__(self):
        # 获取下一个元素
        if self.current > self.end:
            raise StopIteration  # 终止迭代
        value = self.current
        self.current += 1
        return value
# 使用自定义迭代器
counter = Counter(1, 5)
for num in counter:
    print(num)  # 输出: 1, 2, 3, 4, 5

高级自定义迭代器 - 斐波那契数列

class FibonacciIterator:
    """斐波那契数列迭代器"""
    def __init__(self, max_count):
        self.max_count = max_count
        self.count = 0
        self.a, self.b = 0, 1
    def __iter__(self):
        return self
    def __next__(self):
        if self.count >= self.max_count:
            raise StopIteration
        # 返回当前值并计算下一个
        if self.count == 0:
            self.count += 1
            return self.a
        self.count += 1
        self.a, self.b = self.b, self.a + self.b
        return self.a
# 生成前10个斐波那契数
fib = FibonacciIterator(10)
for num in fib:
    print(num, end=' ')  # 输出: 0 1 1 2 3 5 8 13 21 34

使用生成器创建迭代器

生成器函数

def simple_generator():
    """简单生成器函数"""
    yield 1
    yield 2
    yield 3
# 使用生成器
gen = simple_generator()
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3

实用生成器案例

def fibonacci_generator(n):
    """生成斐波那契数列的生成器"""
    a, b = 0, 1
    count = 0
    while count < n:
        yield a
        a, b = b, a + b
        count += 1
# 使用生成器
for num in fibonacci_generator(10):
    print(num, end=' ')  # 输出: 0 1 1 2 3 5 8 13 21 34

实际应用案例

读取大文件（内存友好）

class FileLineIterator:
    """逐行读取大文件的迭代器"""
    def __init__(self, filename):
        self.filename = filename
        self.file = None
    def __iter__(self):
        self.file = open(self.filename, 'r', encoding='utf-8')
        return self
    def __next__(self):
        line = self.file.readline()
        if not line:
            self.file.close()
            raise StopIteration
        return line.strip()
# 使用示例（假设有 big_file.txt）
# file_iter = FileLineIterator('big_file.txt')
# for line in file_iter:
#     print(line)

分页数据迭代器

class PaginationIterator:
    """分页数据迭代器"""
    def __init__(self, total_items, page_size=10):
        self.total_items = total_items
        self.page_size = page_size
        self.current_page = 1
        self.total_pages = (total_items + page_size - 1) // page_size
    def __iter__(self):
        return self
    def __next__(self):
        if self.current_page > self.total_pages:
            raise StopIteration
        start = (self.current_page - 1) * self.page_size + 1
        end = min(self.current_page * self.page_size, self.total_items)
        page_data = list(range(start, end + 1))
        self.current_page += 1
        return {
            'page': self.current_page - 1,
            'items': page_data
        }
# 使用示例
pagination = PaginationIterator(25, 10)
for page in pagination:
    print(f"Page {page['page']}: {page['items']}")
# 输出:
# Page 1: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Page 2: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
# Page 3: [21, 22, 23, 24, 25]

无限序列迭代器

class InfiniteCounter:
    """无限计数器（需谨慎使用）"""
    def __init__(self, start=0):
        self.current = start
    def __iter__(self):
        return self
    def __next__(self):
        value = self.current
        self.current += 1
        return value
# 使用 itertools 限制无限迭代
from itertools import islice
infinite = InfiniteCounter()
limited = islice(infinite, 10)  # 只取前10个
for num in limited:
    print(num, end=' ')  # 0 1 2 3 4 5 6 7 8 9

迭代器 vs 可迭代对象

# 可迭代对象
my_list = [1, 2, 3]
print(hasattr(my_list, '__iter__'))  # True
print(hasattr(my_list, '__next__'))  # False
# 迭代器
my_iter = iter(my_list)
print(hasattr(my_iter, '__iter__'))  # True
print(hasattr(my_iter, '__next__'))  # True

最佳实践建议

1. 简单场景使用生成器：比创建完整类更简洁
2. 复杂逻辑使用类：当需要维护复杂状态时
3. 处理大文件使用迭代器：节省内存
4. 注意无限迭代器：确保有退出条件

这些案例涵盖了Python迭代器的主要使用场景,你可以根据具体需求选择合适的方式。