总览：四大数据结构核心特点

先简单回顾四种数据结构的基本特性，这对理解遍历方式很重要：

数据结构	英文	特点
列表	List	有序、可变、元素可重复
元组	Tuple	有序、不可变、元素可重复
集合	Set	无序、可变、元素不可重复
字典	Dictionary	有序（Python 3.7+）、可变、键不可重复

---

1. 列表（List）的遍历方式

列表是最常用的数据结构，遍历方式最多样。

1.1 直接 for 循环遍历元素（最常用）

如果只需要获取列表中的元素，不需要索引，这是最简单的方式。

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 直接遍历元素
for fruit in fruits:
    print(fruit)
# 输出:
# 苹果
# 香蕉
# 橙子
# 葡萄

1.2 通过索引遍历（range(len())）

如果需要通过索引来访问或修改元素（利用列表的可变性），可以用这种方式。

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# len(fruits) 获取列表长度（4），range(4) 生成 0,1,2,3
for i in range(len(fruits)):
    print(f"索引 {i}: {fruits[i]}")
# 输出:
# 索引 0: 苹果
# 索引 1: 香蕉
# 索引 2: 橙子
# 索引 3: 葡萄

1.3 enumerate() 同时获取索引和元素（推荐！）

如果同时需要索引和元素，用 enumerate() 最优雅，不需要手动维护索引。

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# enumerate() 返回 (索引, 元素) 的元组，直接解包给 index 和 fruit
for index, fruit in enumerate(fruits):
    print(f"第 {index+1} 个水果: {fruit}")  # index+1 让序号从1开始
# 输出:
# 第 1 个水果: 苹果
# 第 2 个水果: 香蕉
# 第 3 个水果: 橙子
# 第 4 个水果: 葡萄

1.4 reversed() 反向遍历

从列表末尾开始往前遍历，不改变原列表。

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# reversed() 返回反向迭代器
for fruit in reversed(fruits):
    print(fruit)
# 输出:
# 葡萄
# 橙子
# 香蕉
# 苹果

1.5 sorted() 排序后遍历

按一定规则排序后遍历，不改变原列表，返回新的排序后的列表。

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# 默认升序排序
for num in sorted(numbers):
    print(num, end=" ")  # end=" " 让输出不换行，用空格分隔
# 输出: 1 1 2 3 4 5 6 9

print()  # 换行

# 降序排序（reverse=True）
for num in sorted(numbers, reverse=True):
    print(num, end=" ")
# 输出: 9 6 5 4 3 2 1 1

1.6 zip()遍历两个等长列表

names = ["张三", "李四", "王五"]
ages = [20, 22, 21]
# 用 zip() 把两个列表打包成二元组
for name, age in zip(names, ages):
    print(f"{name} 今年 {age} 岁")

---

---

2. 元组（Tuple）的遍历方式

元组和列表类似，但不可变（不能修改元素），所以遍历方式和列表几乎一致，只是不能通过索引修改元素。

2.1 直接 for 循环遍历元素

colors = ("红色", "绿色", "蓝色")

for color in colors:
    print(color)
# 输出:
# 红色
# 绿色
# 蓝色

2.2 enumerate() 同时获取索引和元素

colors = ("红色", "绿色", "蓝色")

for index, color in enumerate(colors):
    print(f"索引 {index}: {color}")
# 输出:
# 索引 0: 红色
# 索引 1: 绿色
# 索引 2: 蓝色

2.3 reversed() 反向遍历

colors = ("红色", "绿色", "蓝色")

for color in reversed(colors):
    print(color)
# 输出:
# 蓝色
# 绿色
# 红色

2.4 sorted() 排序后遍历

注意：sorted() 对元组排序后，返回的是列表（因为元组不可变）。

numbers = (5, 2, 8, 1, 9)

# sorted() 返回列表
sorted_numbers = sorted(numbers)
print(type(sorted_numbers))  # 输出: <class 'list'>

for num in sorted_numbers:
    print(num, end=" ")
# 输出: 1 2 5 8 9

---

3. 集合（Set）的遍历方式

集合是无序的，所以不能用索引遍历（没有 range(len()) 这种方式），也没有固定的顺序。

3.1 直接 for 循环遍历元素

集合遍历的顺序是不确定的（Python 内部优化决定），但每次遍历的元素是完整的。

animals = {"猫", "狗", "兔子", "猫"}  # 集合会自动去重，所以只有3个元素

for animal in animals:
    print(animal)
# 输出顺序可能是（每次运行可能不同）:
# 猫
# 狗
# 兔子

3.2 sorted() 排序后遍历

如果需要按固定顺序遍历集合，可以用 sorted() 排序，返回列表。

animals = {"cat", "dog", "rabbit", "bird"}

# 按字母顺序排序后遍历
for animal in sorted(animals):
    print(animal)
# 输出（固定顺序）:
# bird
# cat
# dog
# rabbit

---

4. 字典（Dictionary）的遍历方式（重点！）

字典是键值对（key-value）结构，Python 3.7+ 后字典有序（按插入顺序存储）。遍历方式主要针对键、值或键值对。

4.1 直接 for 循环（默认遍历键）

直接遍历字典时，默认遍历的是键（key）。

student = {
    "name": "小明",
    "age": 20,
    "major": "计算机科学",
    "grade": 90
}

# 默认遍历键
for key in student:
    print(key)
# 输出:
# name
# age
# major
# grade

4.2 遍历键：keys()

显式遍历键，和直接遍历效果一样，但更清晰。

student = {
    "name": "小明",
    "age": 20,
    "major": "计算机科学",
    "grade": 90
}

# keys() 返回键的视图对象
for key in student.keys():
    print(f"键: {key}")
# 输出:
# 键: name
# 键: age
# 键: major
# 键: grade

4.3 遍历值：values()

如果只需要获取字典中的值（value），用 values()。

student = {
    "name": "小明",
    "age": 20,
    "major": "计算机科学",
    "grade": 90
}

# values() 返回值的视图对象
for value in student.values():
    print(f"值: {value}")
# 输出:
# 值: 小明
# 值: 20
# 值: 计算机科学
# 值: 90

4.4 遍历键值对：items()（最常用！）

如果同时需要键和值，用 items()，直接解包为 key 和 value。

student = {
    "name": "小明",
    "age": 20,
    "major": "计算机科学",
    "grade": 90
}

# items() 返回 (键, 值) 的元组，解包给 key 和 value
for key, value in student.items():
    print(f"{key}: {value}")
# 输出:
# name: 小明
# age: 20
# major: 计算机科学
# grade: 90

我们把它拆开来看：

1. for ... in ...:

• • 这是 Python 的循环语法，表示“对后面可迭代对象里的每一个元素，依次执行循环体里的代码”。
  • 这里的循环会逐个取出字典里的键值对。

1. student

• • 这是一个字典变量名（你可以自己命名，比如 student_dict、user_info 等）。
  • 字典是 Python 里存储“键-值”（key-value）映射关系的数据结构，比如 {"苹果": 5, "香蕉": 3}。

1. .items()

• • 这是字典的内置方法，作用是把字典里所有的“键-值对”转换成可遍历的序列。
  • 比如 {"a": 1, "b": 2}.items() 会得到 [("a", 1), ("b", 2)] 这样的元组列表。
  • 每个元组都包含两个元素：第一个是键（key），第二个是值（value）。

1. key, value

• • 这是解包赋值：从 .items() 生成的每个元组里，把第一个元素赋值给变量 key，第二个元素赋值给变量 value。
  • 你可以用任意合法变量名，比如 k, v、name, count 等，只要语义清晰即可。

4.5 按插入顺序遍历（Python 3.7+）

Python 3.7 及以上版本，字典默认按插入顺序存储，所以直接遍历就是插入顺序。

# 按顺序插入键值对
info = {}
info["b"] = 2
info["a"] = 1
info["d"] = 4
info["c"] = 3

# 遍历顺序就是插入顺序
for key, value in info.items():
    print(f"{key}: {value}")
# 输出:
# b: 2
# a: 1
# d: 4
# c: 3

4.6 排序后遍历

如果需要按键的顺序遍历，可以用 sorted() 对键或键值对排序。

info = {"b": 2, "a": 1, "d": 4, "c": 3}

# 1. 按键升序排序后遍历键值对
for key in sorted(info.keys()):
    print(f"{key}: {info[key]}")
# 输出:
# a: 1
# b: 2
# c: 3
# d: 4

print()  # 换行

# 2. 直接对 items() 排序（按键排序）
for key, value in sorted(info.items()):
    print(f"{key}: {value}")
# 输出和上面一样

4.7 带索引的遍历（enumerate）

如果你需要同时拿到“序号、键、值”，可以用 enumerate()：

for idx, (key, value) in enumerate(count_s_dict.items()):
    print(f"第{idx+1}项：{key} → {value}")

enumerate() 作用于字典时，默认遍历的是字典的键，并为每个键添加索引；如果需要同时获取「索引 + 键 + 值」，需要结合 items() 使用。

---

总结：四大数据结构遍历方式对比

数据结构	支持的遍历方式	是否支持索引遍历	是否有序
列表	直接遍历、索引遍历、enumerate()、reversed()、sorted()	✅ 是	✅ 是
元组	直接遍历、enumerate()、reversed()、sorted()	✅ 是（但不能修改）	✅ 是
集合	直接遍历、sorted()	❌ 否	❌ 否
字典	直接遍历（键）、keys()、values()、items()、排序后遍历	❌ 否（但可通过键访问值）	✅ 是（Python 3.7+）