17 手撕迭代器

1、迭代器特点：

• 只能向前不能后退

• 迭代器是一次性的

• 迭代完成后就失效了

2、使用建议：

• 能用for循环就用for循环（最简单直观）
• 需要索引时用enumerate
• 多列表对应时用zip
• 字典操作记住items()方法

3、手撕zip

zip函数的工作方式就像拉链一样，将多个可迭代对象中对应位置的元素"拉"在一起：

names = ['张三', '李四', '王五']
ages = [18, 19, 20]
cities = ['北京', '上海', '广州']

# zip的结果相当于：
[('张三', 18, '北京'), ('李四', 19, '上海'), ('王五', 20, '广州')]

基本概念：

• zip就像拉链，把多个列表对应位置的元素组合在一起

• 结果是一个迭代器，每个元素是一个元组

使用特点：

• 惰性计算：只在需要时才生成下一个值

• 长度以最短的输入为准

• 一次性使用：迭代完就不能再用

"""
Python迭代详解

迭代的概念：
1. 迭代是访问集合元素的一种方式
2. 迭代器是一个可以记住遍历的位置的对象
3. 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束

可迭代对象：
1. 列表、元组、字符串、集合、字典等都是可迭代对象
2. 可以直接作用于for循环的对象都是可迭代对象
"""

# 1. 判断对象是否可迭代
from collections.abc import Iterable

print("1. 判断对象是否可迭代：")
print(f"字符串是否可迭代：{isinstance('hello', Iterable)}")      # True
print(f"列表是否可迭代：{isinstance([1,2,3], Iterable)}")       # True
print(f"整数是否可迭代：{isinstance(123, Iterable)}")           # False
print("-" * 50)

# 2. 最基本的迭代
print("2. 基本迭代示例：")
fruits = ['苹果', '香蕉', '橙子']
for fruit in fruits:
    print(f"水果：{fruit}")
print("-" * 50)

# 3. 使用enumerate同时迭代索引和元素
print("3. enumerate示例（同时获取索引和元素）：")
for i, fruit in enumerate(fruits):
    print(f"索引：{i}, 水果：{fruit}")
print("-" * 50)

# 4. 字典的迭代方式
print("4. 字典迭代的三种方式：")
info = {
    'name': '张三',
    'age': 18,
    'city': '北京'
}

print("方式1：迭代键")
for key in info:
    print(f"键：{key}")

print("\n方式2：迭代值")
for value in info.values():
    print(f"值：{value}")

print("\n方式3：同时迭代键和值")
for key, value in info.items():
    print(f"键：{key}, 值：{value}")
print("-" * 50)

# 5. 多个列表的并行迭代（zip详解）
print("5. zip函数详解：")

# 5.1 基本用法
names = ['张三', '李四', '王五']
ages = [18, 19, 20]
cities = ['北京', '上海', '广州']

print("zip的工作原理：")
# zip会将传入的可迭代对象中对应位置的元素打包成元组
zipped = zip(names, ages, cities)
print(f"zip对象：{zipped}")  # 这是一个zip对象
print(f"转为列表：{list(zipped)}")  # 转换后可以看到内部结构：[('张三', 18, '北京'), ('李四', 19, '上海'), ('王五', 20, '广州')]

# 5.2 使用zip进行并行迭代
print("\n并行迭代示例：")
for name, age, city in zip(names, ages, cities):
    print(f"姓名：{name}, 年龄：{age}, 城市：{city}")

# 5.3 不等长列表的zip
print("\n不等长列表的zip：")
names2 = ['张三', '李四', '王五', '赵六']  # 比其他列表多一个元素
ages2 = [18, 19]  # 比其他列表少一个元素
cities2 = ['北京', '上海', '广州']
print("zip默认截断到最短的列表长度：")
for name, age, city in zip(names2, ages2, cities2):
    print(f"姓名：{name}, 年龄：{age}, 城市：{city}")

# 5.4 使用zip创建字典
print("\nzip创建字典示例：")
keys = ['name', 'age', 'city']
values = ['张三', 18, '北京']
info_dict = dict(zip(keys, values))
print(f"使用zip创建的字典：{info_dict}")

# 5.5 解压zip
print("\nzip的解压操作：")
pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
numbers, letters = zip(*pairs)  # 解压（unzip）操作
print(f"解压后的数字：{numbers}")  # (1, 2, 3)
print(f"解压后的字母：{letters}")  # ('a', 'b', 'c')

print("-" * 50)

"""
zip函数的重点说明：

1. zip的本质：
   - zip是一个迭代器，它将多个可迭代对象打包成一个元组的迭代器
   - 每个元组包含所有可迭代对象中对应位置的元素

2. zip的特点：
   - 惰性求值：只有在迭代时才会计算下一个值
   - 长度截断：以最短的可迭代对象为准
   - 一次性：迭代完后就不能再次使用

3. 常见用法：
   - 并行迭代多个列表
   - 创建字典
   - 矩阵转置
   - 配对数据处理

4. 使用场景：
   - 同时处理多个相关的列表
   - 将键和值列表转换为字典
   - 数据的打包和解包
"""

# 6. 列表推导式（一种优雅的迭代方式）
print("6. 列表推导式示例：")
# 生成1-10的平方
squares = [x**2 for x in range(1, 11)]
print(f"1-10的平方：{squares}")

# 带条件的列表推导式
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(f"1-10中偶数的平方：{even_squares}")
print("-" * 50)

# 7. 迭代器的特点演示
print("7. 迭代器特点演示：")
# 创建迭代器对象
numbers = [1, 2, 3]
iter_obj = iter(numbers)

# 使用next()逐个访问
print("使用next()访问迭代器：")
print(next(iter_obj))  # 1
print(next(iter_obj))  # 2
print(next(iter_obj))  # 3
# print(next(iter_obj))  # 如果继续调用会抛出StopIteration异常

"""
快速记忆要点：

1. 基本for循环
   for item in items:
       处理item

2. 带索引的迭代
   for i, item in enumerate(items):
       处理i和item

3. 字典迭代
   for key in dict:         # 迭代键
   for value in dict.values():    # 迭代值
   for key, value in dict.items(): # 迭代键值对

4. 多列表并行迭代
   for x, y, z in zip(list1, list2, list3):
       处理x, y, z

5. 列表推导式
   [表达式 for 变量 in 可迭代对象 if 条件]

注意事项：
1. 迭代器只能往前不会后退
2. 迭代器是一次性的
3. 迭代是Python最常用的功能之一
4. 字典的key是无序的，如果需要有序，可以先对key排序
"""

1. 判断对象是否可迭代：
字符串是否可迭代：True
列表是否可迭代：True
整数是否可迭代：False
--------------------------------------------------
2. 基本迭代示例：
水果：苹果
水果：香蕉
水果：橙子
--------------------------------------------------
3. enumerate示例（同时获取索引和元素）：
索引：0, 水果：苹果
索引：1, 水果：香蕉
索引：2, 水果：橙子
--------------------------------------------------
4. 字典迭代的三种方式：
方式1：迭代键
键：name
键：age
键：city

方式2：迭代值
值：张三
值：18
值：北京

方式3：同时迭代键和值
键：name, 值：张三
键：age, 值：18
键：city, 值：北京
--------------------------------------------------
5. zip函数详解：
zip的工作原理：
zip对象：<zip object at 0x10ec5fb40>
转为列表：[('张三', 18, '北京'), ('李四', 19, '上海'), ('王五', 20, '广州')]

并行迭代示例：
姓名：张三, 年龄：18, 城市：北京
姓名：李四, 年龄：19, 城市：上海
姓名：王五, 年龄：20, 城市：广州

不等长列表的zip：
zip默认截断到最短的列表长度：
姓名：张三, 年龄：18, 城市：北京
姓名：李四, 年龄：19, 城市：上海

zip创建字典示例：
使用zip创建的字典：{'name': '张三', 'age': 18, 'city': '北京'}

zip的解压操作：
解压后的数字：(1, 2, 3)
解压后的字母：('a', 'b', 'c')
--------------------------------------------------
6. 列表推导式示例：
1-10的平方：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
1-10中偶数的平方：[4, 16, 36, 64, 100]
--------------------------------------------------
7. 迭代器特点演示：
使用next()访问迭代器：
1
2
3