Python中字符串,列表,元组,集合及字典常见的遍历方式汇总

目录

• 字符串遍历
• 1. 直接遍历字符
• 2. 同时获取索引和值
• 3. 反向遍历
• 4. 切片遍历
• 列表遍历
• 1. 基本遍历
• 2. enumerate 遍历（推荐）
• 3. while 循环遍历
• 4. 列表推导式遍历
• 5. zip 遍历多个列表
• 6. 反向遍历
• 元组遍历
• 集合遍历
• 1. 基本遍历
• 2. 遍历并转换为有序
• 3. 遍历并检查成员
• 字典遍历
• 1. 遍历键（keys）
• 2. 遍历值（values）
• 3. 遍历键值对（items） – 最常用
• 4. enumerate 遍历字典
• 5. 遍历排序后的字典
• 6. 字典推导式遍历
• 7. 同时遍历多个字典
• 高级遍历技巧
• 1. filter 函数过滤遍历
• 2. map 函数映射遍历
• 3. 生成器表达式遍历
• 4. itertools 模块高级遍历
• 遍历方式对比表

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]}")

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}")

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])

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

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]}")

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}")

my_list = [1, 2, 3, 4, 5]
i = 0
while i < len(my_list):
    print(my_list[i])
    i += 1

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]

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}分")

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)

my_set = {1, 2, 3, 4, 5}

# 直接遍历（集合无序，遍历顺序不确定）
for item in my_set:
    print(item)

# 注意：集合没有索引，不能使用索引遍历

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

my_set = {'apple', 'banana', 'cherry'}

# 遍历时检查
for fruit in my_set:
    if 'a' in fruit:
        print(f"{fruit} 包含字母'a'")

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}")

my_dict = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

# 遍历值
for value in my_dict.values():
    print(f"值: {value}")

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

my_dict = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}

# 遍历items并获取索引
for i, (key, value) in enumerate(my_dict.items()):
    print(f"第{i}项: {key} = {value}")

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]}")

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}

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]}")

# 列表过滤遍历
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

# 列表映射遍历
numbers = [1, 2, 3]
for num in map(lambda x: x**2, numbers):
    print(num)  # 1 4 9

# 内存友好的大列表遍历
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

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字符串,列表,元组,集合及字典遍历的资料请关注风君子博客其它相关文章！

您可能感兴趣的文章:

• python遍历字符串中每一个字符的4种方式
• python列表和字符串的三种逆序遍历操作
• Python之字符串的遍历的4种方式
• Python openpyxl 遍历所有sheet 查找特定字符串的方法
• python 遍历字符串(含汉字)实例详解