#title: 迭代 description:Python 迭代(Iteration)教程

#Python 迭代(Iteration)教程

大家好！今天我们来聊一聊 Python 里最常用、最基础的概念之一 —— 迭代。掌握了它，你可以用最简短的代码，轻松遍历列表、字典、字符串等各种数据，写起程序来不但顺手，还特别“Pythonic”。

#什么是迭代？

迭代，简单来说就是一次一个地把元素从“一串东西”里取出来处理的过程。
很多语言要通过手动维护索引、写 while 循环来挨个访问元素，而 Python 给了我们一个非常优雅的语法：

for 变量 in 可迭代对象:
    处理变量

这就是 for...in 循环。有了它，你不需要关心索引、不用担心越界，只需关注“我想对每一个元素做什么”。

#基础迭代：从最常见的序列开始

Python 内置的 list、tuple 都是“可迭代对象”，直接放进 for...in 里就能用。

#1. 列表

假设你有一个水果列表：

fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(f"I love {fruit}!")

运行后，你会依次看到：

I love apple!
I love banana!
I love orange!

完全不用写 fruits[0]、fruits[1] 这样的下标。

#2. 元组

元组也一样，用同样的方式就可以逐个访问：

colors = ('red', 'green', 'blue')
for color in colors:
    print(color)

#特殊迭代：字典的三种“打开方式”

字典也是可迭代对象，但默认只遍历它的键（key）。Python 还为大家准备了 .values() 和 .items() 两个方法，让你能灵活遍历值或键值对。

#1. 只遍历键（默认行为）

person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
for key in person:
    print(f"Key: {key}")

#2. 只遍历值：.values()

for value in person.values():
    print(f"Value: {value}")

#3. 键值一起遍历：.items() + 元组解包

这是最常用的字典迭代方式，一次拿到键和值：

for key, value in person.items():
    print(f"{key}: {value}")

这里的 key, value 实际上是利用了后面会介绍的元组解包，非常方便。

#隐藏技能：字符串也可以迭代

字符串本质上就是“字符的序列”，因此直接放进 for...in 里就能逐个取出每个字符：

text = "Python"
for char in text:
    print(char)

你会一个字母一个字母地看到输出：P、y、t、h、o、n。

#进阶1：判断一个对象能不能迭代

整数、浮点数这类“单个数值”不能迭代——如果你尝试 for i in 123，程序会报错。
如果不确定某个对象是否可迭代，可以用 collections.abc 模块里的 Iterable 做检测：

from collections.abc import Iterable

print(isinstance('abc', Iterable))  # True  字符串可迭代
print(isinstance([1,2,3], Iterable))# True  列表可迭代
print(isinstance(123, Iterable))    # False 整数不可迭代

这个技巧在编写函数、检查参数时格外有用。

#进阶2：带着索引一起迭代 —— enumerate()

有时候你既需要元素本身，又需要它的位置（例如更新原列表的某个值）。
enumerate() 会帮你生成 (索引, 元素) 的配对：

fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
    print(f"Index {index}: {fruit}")

输出：

Index 0: apple
Index 1: banana
Index 2: orange

#进阶3：同时迭代多个序列

Python 支持两种优雅的“多序列同时迭代”方式。

#1. 元组解包 —— 当序列里本身就是元组

很多数据天然是以配对的形式存在的，比如坐标 (x, y)：

coordinates = [(1, 2), (3, 4), (5, 6)]
for x, y in coordinates:
    print(f"x: {x}, y: {y}")

每次循环，x 和 y 分别绑定到元组中的两个值，这叫元组解包。

#2. zip() —— 把多个独立序列“打包”在一起

如果数据分散在几个不同的列表里，可以用 zip() 把它们“拉链”一样合并成一组元组，再解包：

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

⚠️ 注意：如果各个序列长度不一致，zip() 会以最短的那个为准，超出的部分会被静默忽略。

#进阶4：反向迭代和排序后迭代

Python 有两个内置函数帮你轻松改变遍历的顺序。

#1. 反向迭代 reversed()

把序列倒过来遍历：

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

#2. 排序后迭代 sorted()

sorted() 会生成一个新的有序序列，原数据不会被修改：

numbers = [3, 1, 4, 1, 5, 9, 2]
for num in sorted(numbers):
    print(num)

#实践练习：查找列表中最小值和最大值

学会迭代之后，可以试着写一个函数，输入一个数字列表，返回它的最小值和最大值。
如果列表为空，返回 (None, None)。

def findMinAndMax(L):
    if not L:  # 空列表情况
        return (None, None)

    min_val = max_val = L[0]
    for num in L:
        if num < min_val:
            min_val = num
        if num > max_val:
            max_val = num
    return (min_val, max_val)

# 简单的单元测试
if findMinAndMax([]) != (None, None):
    print('测试失败!')
elif findMinAndMax([7]) != (7, 7):
    print('测试失败!')
elif findMinAndMax([7, 1]) != (1, 7):
    print('测试失败!')
elif findMinAndMax([7, 1, 3, 9, 5]) != (1, 9):
    print('测试失败!')
else:
    print('🎉 测试成功!')

你可以故意改成错误的返回值，看看测试是否生效。

#总结

• Python 通过 for...in 语法实现迭代，安全又直观
• list、tuple、dict、str 都是可迭代对象，可以直接放进循环
• 字典默认迭代键，可用 .values()、.items() 分别遍历值和键值对
• enumerate() 能同时拿到索引和元素
• zip() 可以捆绑多个独立序列一起迭代
• reversed() 和 sorted() 能轻松改变遍历顺序
• collections.abc.Iterable 可以判断一个对象是否可迭代

掌握了这些迭代技巧，你写出的代码会更加简洁、灵活，也更接近 Python 的精髓。希望这篇教程能帮你打牢基础，继续愉快地学习 Python！