Чем list comprehension отличается от generator expression с точки зрения использования памяти?

List comprehension vs generator expression: основное отличие

• List comprehension [x for x in iterable]: вычисляет все элементы немедленно, создаёт список в памяти.
• Generator expression (x for x in iterable): создаёт объект-генератор, вычисляет элементы лениво по мере запроса.

import sys

# List comprehension — всё в памяти сразу
lst = [x ** 2 for x in range(1_000_000)]
print(sys.getsizeof(lst))   # ~8 MB

# Generator expression — только итератор
gen = (x ** 2 for x in range(1_000_000))
print(sys.getsizeof(gen))   # ~112 байт

Когда выбирать list comprehension

• Результат нужен несколько раз (генератор одноразовый).
• Нужен len(), индексирование, срезы.
• Объём данных небольшой и помещается в память.
• Нужно передать список в функцию, которая ожидает последовательность (например, json.dumps).

Когда выбирать generator expression

• Большие или потенциально бесконечные данные.
• Результат используется только один раз (pipeline обработки).
• Передаётся в функции, принимающие итерируемые объекты: sum(), max(), any(), all().

from pathlib import Path

# Подсчёт строк в большом файле — никогда не загружаем в память
def count_lines(path: Path) -> int:
    with open(path) as f:
        return sum(1 for _ in f)

# Pipeline: читаем CSV, фильтруем, агрегируем — лениво
def total_salary(records):
    return sum(
        float(r["salary"])
        for r in records
        if r.get("active") == "true" and r.get("salary")
    )

# Конвейер генераторов
def read_lines(path: Path):
    with open(path) as f:
        yield from f

def parse_csv_rows(lines):
    import csv
    reader = csv.DictReader(lines)
    yield from reader

def active_only(rows):
    for row in rows:
        if row["status"] == "active":
            yield row

# Вся цепочка работает в O(1) памяти
pipeline = active_only(parse_csv_rows(read_lines(Path("data.csv"))))
for row in pipeline:
    process(row)

Производительность: детали

import timeit

# List comprehension быстрее для малых данных (создаётся один раз)
time_list = timeit.timeit('[x*2 for x in range(100)]', number=100_000)
time_gen = timeit.timeit('list(x*2 for x in range(100))', number=100_000)
# list comprehension обычно на 5-15% быстрее при материализации

# Но для sum() генератор не медленнее
time1 = timeit.timeit('sum([x*2 for x in range(1000)])', number=10_000)
time2 = timeit.timeit('sum(x*2 for x in range(1000))', number=10_000)
# Примерно одинаково, генератор экономит память

Подводные камни

• Генератор одноразовый: после исчерпания второй проход даёт пустой результат — типичная ошибка при передаче генератора в несколько функций.
• Трудная отладка: исключение внутри генератора возникает лениво — стек-трейс указывает на место потребления, не создания.
• Потеря длины: len(generator) вызывает TypeError — нужно или материализовать в список, или считать отдельно.
• late binding в замыканиях: переменная в generator expression захватывает значение лениво — может привести к неожиданному результату в цикле.
• Вложенные генераторы и исключения: GeneratorExit при досрочном прекращении итерации — нужен try/finally для ресурсов.
• Передача в json.dumps: json.dumps(x for x in data) вызывает TypeError — json ожидает list.

• Описывать list comprehension vs generator expression только как термин и не показывать механизм на минимальном примере.
• Игнорировать ошибки, пустые данные, конкурентный доступ или границы транзакции.
• Не связывать поведение с официальным контрактом Python и реальной эксплуатацией.

• Объясняет list comprehension vs generator expression через последовательность действий, а не через набор ключевых слов.
• Приводит короткий кодовый пример или production-сценарий с ожидаемым поведением.
• Называет хотя бы один риск: производительность, безопасность, транзакции, память или сопровождение.