Python循环是代码中出现频率最高的结构之一，但写法不同，性能差距可达10倍。以下5种模式覆盖从基础迭代到高阶函数式编程的完整光谱，每种都有明确的适用场景。
写法一：enumerate替代手动索引计数
需要同时访问元素和索引时，enumerate比range(len())更Pythonic且更安全。
from typing import List, Tupleusers = ["alice", "bob", "charlie"]for i in range(len(users)): print(f"{i}: {users[i]}")for idx, user in enumerate(users, start=1): # start=1让序号从1开始 print(f"{idx}: {user}")def find_first_match(items: List[str], predicate) -> Tuple[int, str]: """返回第一个匹配项的索引和值，找不到返回(-1, None)""" for idx, item in enumerate(items): if predicate(item): return idx, item return -1, Noneidx, user = find_first_match(users, lambda u: u.startswith("b"))print(f"找到位置: {idx}, 值: {user}") # 找到位置: 1, 值: bob
enumerate的优势：避免手动索引维护、支持自定义起始值、代码意图更清晰。
写法二：zip并行迭代多序列
需要同时遍历多个列表时，zip是最简洁且内存友好的方案。
from itertools import zip_longestnames = ["Alice", "Bob", "Charlie"]ages = [25, 30, 35]cities = ["Beijing", "Shanghai"]for name, age in zip(names, ages): print(f"{name}: {age}岁")for name, age, city in zip_longest(names, ages, cities, fillvalue="未知"): print(f"{name}: {age}岁, {city}")keys = ["name", "age", "city"]values = ["Alice", 25, "Beijing"]profile = dict(zip(keys, values))print(profile) # {'name': 'Alice', 'age': 25, 'city': 'Beijing'}pairs = list(zip(names, ages))print(pairs) # [('Alice', 25), ('Bob', 30), ('Charlie', 35)]unzipped_names, unzipped_ages = zip(*pairs)print(unzipped_names) # ('Alice', 'Bob', 'Charlie')
zip的隐藏技巧：解包（zip(\matrix)实现矩阵转置）是数据处理中的高频操作。
写法三：生成器表达式替代列表推导（大数据场景）
数据量大时，生成器表达式比列表推导节省内存，因为结果是惰性求值的。
import syslog_lines = [f"2026-01-{i%30+1:02d} User{i} Action" for i in range(1_000_000)]filtered_list = [line for line in log_lines if "Error" in line]print(f"列表推导内存: {sys.getsizeof(filtered_list):,} bytes")filtered_gen = (line for line in log_lines if "Error" in line)print(f"生成器内存: {sys.getsizeof(filtered_gen):,} bytes")def process_logs(log_lines): """日志处理流水线：过滤→解析→统计""" error_logs = (line for line in log_lines if "ERROR" in line) parsed = (parse_timestamp(line) for line in error_logs) hourly_counts = ( (hour, sum(1 for _ in group)) for hour, group in groupby(parsed, key=lambda x: x.hour) ) return hourly_counts
生成器vs列表的核心权衡：内存（生成器胜）vs 可复用性（列表胜）。
写法四：itertools替代手动循环逻辑
itertools模块提供C语言实现的高效迭代工具，比手写循环快且可靠。
from itertools import chain, groupby, islice, cycle, compresslogs_day1 = ["error: disk full", "info: backup started"]logs_day2 = ["error: timeout", "info: backup completed"]logs_day3 = ["warning: high memory"]all_logs = []for day_logs in [logs_day1, logs_day2, logs_day3]: for log in day_logs: all_logs.append(log)all_logs = list(chain(logs_day1, logs_day2, logs_day3))from operator import itemgetterevents = [ ("2026-06-01", "click"), ("2026-06-01", "view"), ("2026-06-02", "click"), ("2026-06-02", "click"), ("2026-06-02", "purchase"),]events.sort(key=itemgetter(0)) # 先按日期排序for date, group in groupby(events, key=itemgetter(0)): actions = list(group) print(f"{date}: {len(actions)} 次交互")numbers = range(100)first_10 = list(islice(numbers, 10))middle = list(islice(numbers, 20, 30))every_3rd = list(islice(numbers, 0, None, 3))selectors = [True, False, True, False, True]data = ["A", "B", "C", "D", "E"]filtered = list(compress(data, selectors))print(filtered) # ['A', 'C', 'E']pool = ["server1", "server2", "server3"]round_robin = cycle(pool)for _ in range(5): print(next(round_robin))
itertools的价值：C实现的高效算法、减少手写循环的错误、代码意图更 declarative。
写法五：递归与迭代的选择：何时用递归，何时必须转迭代
Python没有尾递归优化，递归深度默认限制1000层。理解何时用递归、何时转迭代，是工程化编程的关键判断。
import sysfrom functools import lru_cachefrom typing import Iteratorclass TreeNode: def __init__(self, value: str, children: list = None): self.value = value self.children = children or []def traverse_recursive(node: TreeNode, depth: int = 0): """递归遍历，适合深度确定的树""" print(" " * depth + node.value) for child in node.children: traverse_recursive(child, depth + 1)def traverse_iterative(root: TreeNode): """迭代遍历，用显式栈替代调用栈，适合深度不确定的树""" stack = [(root, 0)] # (节点, 深度) while stack: node, depth = stack.pop() print(" " * depth + node.value) for child in reversed(node.children): stack.append((child, depth + 1))def traverse_generator(node: TreeNode, depth: int = 0) -> Iterator[Tuple[str, int]]: """生成器遍历，适合流水线处理""" yield (node.value, depth) for child in node.children: yield from traverse_generator(child, depth + 1)for value, depth in traverse_generator(root_node): if depth > 5: # 只处理深层节点 process_deep_node(value)def fib_recursive(n: int) -> int: if n <= 1: return n return fib_recursive(n - 1) + fib_recursive(n - 2)@lru_cache(maxsize=None)def fib_memoized(n: int) -> int: if n <= 1: return n return fib_memoized(n - 1) + fib_memoized(n - 2)def fib_iterative(n: int) -> int: if n <= 1: return n a, b = 0, 1 for _ in range(2, n + 1): a, b = b, a + b return bdef fib_generator() -> Iterator[int]: a, b = 0, 1 while True: yield a a, b = b, a + bfib = fib_generator()first_20 = [next(fib) for _ in range(20)]
循环写法影响的不只是性能，是代码的可维护性
代码审查中，循环写法是高频讨论点。不是因为性能差异（现代硬件上小数据量差别不大），是因为可读性和意图表达：
enumerate比range(len())更易读，因为意图是"同时需要索引和元素"zip- 生成器比列表推导更节省内存，但代价是只能迭代一次——这个trade-off需要在代码中显式表达
- itertools比手写循环更可靠，因为C实现经过了充分测试
循环写法的演进方向：从"告诉计算机怎么做"（手动索引、嵌套循环）到"告诉计算机要什么"（zip、生成器、itertools）。这种declarative风格的代码，在团队协作中更容易被理解和维护。
选择循环写法的决策树：
- 并行遍历多序列 → zip / zip\_longest
10个月宝宝每天需要喝多少奶粉？
