成都网站建设高端刷单做任务的网站
从生活场景理解核心概念
想象你在超市买零食：
- 如果你把整箱零食全抱回家（一次性加载所有数据），占地方还累 —— 这就像列表、字典等可迭代对象。
- 如果你每次只拿一包，吃完再拿下一包（用一个取一个），既省空间又轻松 —— 这就是迭代器和生成器的 "懒加载" 思想。
核心区别一句话总结：
- 迭代器：是一种 "工具"，能逐个返回数据，需要手动实现遍历逻辑（像自己做了个取零食的机器）。
- 生成器：是特殊的迭代器，用更简单的语法实现（像买了个现成的自动取零食机，不用自己做）。
1.迭代器 - Iterator
迭代器提供了一种惰性（lazy evaluation）获取数据的方法，它的核心是按需返回数据，使得我们能够逐步访问序列中的元素，而无需一次性加载所有数据。其主要优点包括节省内存、提高性能、支持自定义遍历逻辑等。
1.1特点
惰性计算：按需生成数据，节省内存。
实现协议：
__iter__()：返回自身。__next__()：返回下一个元素；如果没有更多元素，则抛出StopIteration异常。
可迭代对象（Iterable）与迭代器不同：
可迭代对象实现
__iter__()方法，返回一个迭代器。迭代器既实现
__iter__()又实现__next__()。
1.2迭代器的创建
迭代器只能往前取值,不会后退
用iter函数可以返回一个可迭代对象的迭代器
# 示例 可迭代对象
L = [1, 3, 5, 7]
it = iter(L) # 从L对象中获取迭代器
next(it) # 1 从迭代器中提取一个数据
next(it) # 3
print(next(it)) # 5
next(it) # 7
# 示例2 生成器函数
It = iter(range(1, 10, 3))
next(It) # 1
print(next(It)) # 4
next(It) # 71.3自定义迭代器
# 自定义迭代器类
class MyIterator:def __init__(self, data):self.data = dataself.index = 0def __iter__(self):return self # 迭代器返回自身def __next__(self):if self.index < len(self.data):result = self.data[self.index]self.index += 1return resultelse:raise StopIteration # 数据迭代结束# 使用自定义迭代器
my_iter = MyIterator([1, 2, 3])
for item in my_iter:print(item)1.4 可迭代对象 vs 迭代器：别搞混了！
很多人分不清 "可迭代对象" 和 "迭代器"，其实简单说：
- 可迭代对象：是能产生迭代器的对象（如列表、字符串、range），它只实现了
__iter__()方法。 - 迭代器：是能直接取数据的对象，同时实现了
__iter__()和__next__()方法。
举例区分：
# 列表是可迭代对象（不是迭代器）
my_list = [1, 2, 3]
print(hasattr(my_list, '__iter__')) # 输出：True（有__iter__）
print(hasattr(my_list, '__next__')) # 输出：False（没有__next__）# 用iter()把可迭代对象转成迭代器
my_iter = iter(my_list)
print(hasattr(my_iter, '__iter__')) # 输出：True
print(hasattr(my_iter, '__next__')) # 输出：True（是迭代器）# 用next()取数据
print(next(my_iter)) # 输出：1
print(next(my_iter)) # 输出：22.生成器 - Generator
生成器是一种特殊的迭代器，通过函数定义，用 yield 语句生成值。生成器可以自动实现迭代协议，无需手动实现 __iter__() 和 __next__()。
2.1特点
简洁：比手动实现迭代器更易写。
惰性计算：生成器在每次调用 next()时生成一个值，而不是一次性生成所有值。
yield：暂停函数执行并返回值，保留函数的状态，以便下一次继续执行。
- 普通函数用
return返回值，返回后函数结束。 - 生成器函数用
yield返回值，返回后会 "暂停"，下次调用时从暂停的地方继续。
def num_generator():print("准备生成1")yield 1 # 返回1，然后暂停print("准备生成2")yield 2 # 返回2，然后暂停print("准备生成3")yield 3print("准备生成4")yield 4print("准备生成5")yield 5# 创建生成器（调用函数不会执行，只返回生成器对象）
gen = num_generator()# 用next()触发执行
print(next(gen)) # 输出：准备生成1 → 1
print(next(gen)) # 输出：准备生成2 → 2
print(next(gen)) # 输出：准备生成3 → 3运行流程解析：
- 第一次调用
next(gen)：函数执行到yield 1，返回 1，然后 "暂停"（记住当前位置）。 - 第二次调用
next(gen)：从上次暂停的地方继续，执行到yield 2，返回 2，再暂停。 - 直到所有
yield执行完，再次调用会抛出StopIteration。
示例：
def Descendorder(n):while n > 0:yield nn -= 1# 创建生成器对象
generator = Descendorder(5)# 通过迭代生成器获取值
print(next(generator)) #5
print(next(generator)) #4# 使用 for 循环迭代生成器
for i in generator:print('for循环：', i) #3 2 12.2生成器表达式
生成器可以用表达式形式定义，类似列表推导式，但使用小括号 ()。
语法：（ 表达式 for 变量 in 可迭代对象 [ if 真值表达式 ] ）
# 列表推导式：一次性生成所有数据（占内存）
list_expr = [x*2 for x in range(5)]
print(list_expr) # 输出：[0, 2, 4, 6, 8]# 生成器表达式：按需生成（省内存）
gen_expr = (x*2 for x in range(5))
print(gen_expr) # 输出：<generator object <genexpr> at 0x...>（不是直接返回数据）# 用next()取数据
print(next(gen_expr)) # 输出：0
print(next(gen_expr)) # 输出：2
for num in gen_expr:print(num) # 输出：4 → 6 → 8核心区别：
- 列表推导式
[x*2 ...]：立即计算所有结果，存到内存。 - 生成器表达式
(x*2 ...)：不计算，等next()或for循环时才计算，适合大数据。
2.3生成器的经典应用：处理大数据
比如读取 10GB 的大文件，用生成器一行行读，而不是一次性加载到内存：
def read_large_file(file_path):with open(file_path, 'r', encoding='utf-8') as f:for line in f: # 逐行读取（本身就是迭代器）yield line.strip() # 返回一行内容，暂停# 使用生成器读大文件
for line in read_large_file('big_file.txt'):print(line) # 一行行处理，不占大量内存2.4 练习
代码实现斐波那契数列前十个
参考代码：
def fibonacci(n):a, b = 0, 1for _ in range(n):yield ba, b = b, a + bfib_seq = fibonacci(10)for i in fib_seq:print(i, end=" ")# 运行结果
# 1 1 2 3 5 8 13 21 34 552.5应用场景
数据流处理：处理大文件或流式数据，避免内存耗尽。
无限序列生成：如斐波那契数列、素数序列。
管道化数据处理：与
itertools模块结合使用。
参考代码：
def read_large_file(file_path):with open(file_path, 'r') as file:for line in file:yield line.strip()for line in read_large_file('large_file.txt'):print(line)3. 区别对比
| 特性 | 迭代器 | 生成器 |
|---|---|---|
| 实现 | 通过类实现，手动定义方法 | 使用函数和 yield 定义，自动实现迭代协议 |
| 代码简洁性 | 代码较复杂 | 代码简单 |
| 状态管理 | 手动管理状态 | 自动保存函数的运行状态 |
| 惰性计算 | 支持 | 支持 |
| 示例应用 | 自定义复杂的迭代逻辑 | 简单的数据流生成 |
总结：懒加载是精髓
迭代器和生成器的核心思想都是"懒加载"——不提前准备所有数据，而是用的时候再生成。这种思想在处理大数据、流式数据时尤为重要，能帮你避免内存溢出，提高程序效率。
简单说：如果你需要一个"取数工具"，优先用生成器（简单）；如果生成器满足不了复杂需求，再自己实现迭代器（灵活）。