我要评论字符串遍历
1. 直接遍历字符
s = "hello"
# 方式1: for循环直接遍历
for char in s:
print(char) # h e l l o
# 方式2: 使用索引遍历
for i in range(len(s)):
print(f"索引{i}: {s[i]}")
2. 同时获取索引和值
s = "hello"
# enumerate() 获取索引和值
for index, char in enumerate(s):
print(f"位置{index}: {char}")
# 从指定索引开始
for index, char in enumerate(s, start=1):
print(f"第{index}个字符: {char}")
3. 反向遍历
s = "hello"
# reversed() 反向遍历
for char in reversed(s):
print(char) # o l l e h
# 使用索引反向
for i in range(len(s)-1, -1, -1):
print(s[i])
4. 切片遍历
s = "hello world"
# 遍历部分字符串
for char in s[6:]: # 从第6个字符开始
print(char) # w o r l d
# 步长遍历
for char in s[::2]: # 每隔一个字符
print(char) # h l o w r d
列表遍历
1. 基本遍历
my_list = [1, 2, 3, 4, 5]
# 直接遍历
for item in my_list:
print(item)
# 使用索引遍历
for i in range(len(my_list)):
print(f"索引{i}: {my_list[i]}")
2. enumerate 遍历（推荐）
my_list = ['apple', 'banana', 'cherry']
for index, value in enumerate(my_list):
print(f"第{index}个水果: {value}")
# 指定起始索引
for index, value in enumerate(my_list, start=1):
print(f"水果{index}: {value}")
3. while 循环遍历
my_list = [1, 2, 3, 4, 5]
i = 0
while i < len(my_list):
print(my_list[i])
i += 1
4. 列表推导式遍历
my_list = [1, 2, 3, 4, 5] # 遍历并处理（创建新列表） squares = [x**2 for x in my_list] print(squares) # [1, 4, 9, 16, 25] # 带条件的遍历 evens = [x for x in my_list if x % 2 == 0] print(evens) # [2, 4]
5. zip 遍历多个列表
names = ['alice', 'bob', 'charlie']
scores = [85, 92, 78]
# 同时遍历两个列表
for name, score in zip(names, scores):
print(f"{name}: {score}分")
# 使用enumerate + zip
for i, (name, score) in enumerate(zip(names, scores)):
print(f"第{i+1}名: {name} - {score}分")
6. 反向遍历
my_list = [1, 2, 3, 4, 5]
# reversed() 反向遍历
for item in reversed(my_list):
print(item) # 5 4 3 2 1
# 使用切片反向
for item in my_list[::-1]:
print(item) # 5 4 3 2 1
元组遍历
元组遍历与列表几乎相同（元组是不可变的列表）
my_tuple = (1, 2, 3, 4, 5)
# 直接遍历
for item in my_tuple:
print(item)
# enumerate遍历
for i, item in enumerate(my_tuple):
print(f"第{i}个元素: {item}")
# 反向遍历
for item in reversed(my_tuple):
print(item)
集合遍历
1. 基本遍历
my_set = {1, 2, 3, 4, 5}
# 直接遍历（集合无序，遍历顺序不确定）
for item in my_set:
print(item)
# 注意：集合没有索引，不能使用索引遍历
2. 遍历并转换为有序
my_set = {5, 3, 1, 4, 2}
# 排序后遍历
for item in sorted(my_set):
print(item) # 1 2 3 4 5
# 反向排序遍历
for item in sorted(my_set, reverse=true):
print(item) # 5 4 3 2 1
3. 遍历并检查成员
my_set = {'apple', 'banana', 'cherry'}
# 遍历时检查
for fruit in my_set:
if 'a' in fruit:
print(f"{fruit} 包含字母'a'")
字典遍历
1. 遍历键（keys）
my_dict = {'name': 'alice', 'age': 25, 'city': 'beijing'}
# 直接遍历键（默认方式）
for key in my_dict:
print(f"键: {key}")
# 显式使用keys()
for key in my_dict.keys():
print(f"键: {key}")
2. 遍历值（values）
my_dict = {'name': 'alice', 'age': 25, 'city': 'beijing'}
# 遍历值
for value in my_dict.values():
print(f"值: {value}")
3. 遍历键值对（items） - 最常用
my_dict = {'name': 'alice', 'age': 25, 'city': 'beijing'}
# 同时获取键和值
for key, value in my_dict.items():
print(f"{key}: {value}")
# 输出：
# name: alice
# age: 25
# city: beijing
4. enumerate 遍历字典
my_dict = {'name': 'alice', 'age': 25, 'city': 'beijing'}
# 遍历items并获取索引
for i, (key, value) in enumerate(my_dict.items()):
print(f"第{i}项: {key} = {value}")
5. 遍历排序后的字典
my_dict = {'b': 2, 'a': 1, 'c': 3}
# 按键排序遍历
for key in sorted(my_dict):
print(f"{key}: {my_dict[key]}")
# 按值排序遍历
for key in sorted(my_dict, key=my_dict.get):
print(f"{key}: {my_dict[key]}")
# 反向排序遍历
for key in sorted(my_dict, reverse=true):
print(f"{key}: {my_dict[key]}")
6. 字典推导式遍历
my_dict = {'a': 1, 'b': 2, 'c': 3}
# 遍历并创建新字典
squared = {k: v**2 for k, v in my_dict.items()}
print(squared) # {'a': 1, 'b': 4, 'c': 9}
# 带条件的遍历
filtered = {k: v for k, v in my_dict.items() if v > 1}
print(filtered) # {'b': 2, 'c': 3}
7. 同时遍历多个字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 10, 'b': 20}
# 遍历相同的键
for key in dict1:
if key in dict2:
print(f"{key}: {dict1[key]} + {dict2[key]} = {dict1[key] + dict2[key]}")
高级遍历技巧
1. filter 函数过滤遍历
# 列表过滤遍历
numbers = [1, 2, 3, 4, 5, 6]
for num in filter(lambda x: x % 2 == 0, numbers):
print(num) # 2 4 6
# 字典过滤遍历
my_dict = {'a': 1, 'b': 2, 'c': 3}
for k, v in filter(lambda item: item[1] > 1, my_dict.items()):
print(f"{k}: {v}") # b: 2, c: 3
2. map 函数映射遍历
# 列表映射遍历
numbers = [1, 2, 3]
for num in map(lambda x: x**2, numbers):
print(num) # 1 4 9
3. 生成器表达式遍历
# 内存友好的大列表遍历
numbers = range(1000000) # 不立即创建列表
# 使用生成器表达式
sum_squares = sum(x**2 for x in numbers if x % 2 == 0)
print(sum_squares)
# 遍历生成器
for square in (x**2 for x in range(5)):
print(square) # 0 1 4 9 16
4. itertools 模块高级遍历
from itertools import chain, product, permutations
# 连接多个可迭代对象
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
for item in chain(list1, list2):
print(item) # 1 2 3 a b c
# 笛卡尔积
colors = ['红', '蓝']
sizes = ['s', 'm']
for color, size in product(colors, sizes):
print(f"{color}{size}") # 红s 红m 蓝s 蓝m
# 排列
for p in permutations('abc', 2):
print(p) # ('a', 'b') ('a', 'c') ('b', 'a') ('b', 'c') ('c', 'a') ('c', 'b')
遍历方式对比表
| 数据类型 | 常用遍历方式 | 特点 | 示例 |
|---|---|---|---|
| 字符串 | for char in s: | 遍历字符 | for c in “hello”: |
| enumerate(s) | 带索引遍历 | for i, c in enumerate(s): | |
| 列表 | for item in list: | 直接遍历元素 | for x in [1,2,3]: |
| enumerate(list) | 带索引遍历 | for i, x in enumerate(lst): | |
| zip(list1, list2) | 多列表同时遍历 | for a,b in zip(l1,l2): | |
| 元组 | 同列表 | 不可变列表 | for x in (1,2,3): |
| 集合 | for item in set: | 无序遍历 | for x in {1,2,3}: |
| sorted(set) | 有序遍历 | for x in sorted(s): | |
| 字典 | dict.keys() | 遍历键 | for k in d.keys(): |
| dict.values() | 遍历值 | for v in d.values(): | |
| dict.items() | 遍历键值对 | for k,v in d.items(): |
1. 优先使用 for-in 直接遍历：最简洁，性能好
2. 需要索引时用 enumerate：比 range(len()) 更优雅
3. 字典遍历用 items()：同时获取键值，效率高
4. 大数据用生成器：节省内存，适合大数据处理
5. 复杂遍历用 itertools：python标准库，功能强大
以上就是python中字符串,列表,元组,集合及字典常见的遍历方式汇总的详细内容，更多关于python字符串,列表,元组,集合及字典遍历的资料请关注代码网其它相关文章！
发表评论