Python循环的5种高效写法:从for-in到生成器表达式的性能与可读性权衡

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风格的代码，在团队协作中更容易被理解和维护。

选择循环写法的决策树：

• 需要索引+元素 → enumerate
• 并行遍历多序列 → zip / zip\_longest
• 大数据量/流水线 → 生成器表达式
• 复杂迭代逻辑 → itertools
• 树形结构/不确定深度 → 显式栈迭代
• 需要随机访问/重复迭代 → 列表推导