Как сравнивать код Python: обработка списков без циклов и с циклами
Сравнение способов обработки списков в Python
Как компактно и быстро преобразовать все элементы списка?
List comprehension (списковое включение) считается наиболее pythonic и эффективным способом для простых преобразований. Оно объединяет цикл и создание нового списка в одной строке, что улучшает читаемость и часто работает быстрее эквивалентного цикла for.
numbers = [1, 2, 3, 4, 5]
squared = [n ** 2 for n in numbers]
print(squared)работа кода python (работа кода python)
[1, 4, 9, 16, 25]
чтение кода python (чтение кода python)
Типичные ошибки
Чрезмерное использование вложенных list comprehensions (например, [expr for a in A for b in B]) может снизить читаемость. Также стоит помнить, что результат загружается в память целиком, что нежелательно для огромных последовательностей.
Как преобразовать список с помощью классического цикла for?
Цикл for с методом append является самым прямым, но более многословным способом. Он подходит, когда логика преобразования слишком сложна для одной строки или требует множества промежуточных операций.
numbers = [1, 2, 3, 4, 5]
squared = []
for n in numbers:
squared.append(n ** 2)
print(squared)сравнение кода python (сравнение кода python)
[1, 4, 9, 16, 25]
Проблемы и решения
Такой код занимает четыре строки вместо одной, что увеличивает объём и снижает скорость написания. При работе с большими данными цикл может быть немного медленнее из-за накладных расходов на вызов append. Если требуется высокая производительность, лучше использовать list comprehension или функции map.
Как применить функцию к каждому элементу без явного цикла?
Функция map принимает функцию и итерируемый объект, возвращая итератор. Она особенно удобна, когда уже существует готовая функция (например, из модуля operator) или требуется ленивое вычисление.
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)[1, 4, 9, 16, 25]
Типичные ошибки
Забывают обернуть результат map в list() для получения списка. Использование lambda делает код менее читаемым, если логика простая. Для встроенных преобразований (например, str.upper) map отлично подходит: list(map(str.upper, words)).
Как отфильтровать элементы по условию?
Функция filter работает аналогично map, но оставляет только те элементы, для которых функция вернула истину. Часто используется вместе с lambda.
numbers = [1, 2, 3, 4, 5, 6]
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)[2, 4, 6]
Проблемы
Комбинирование filter и map в одной цепочке может выглядеть громоздко. Альтернатива: list comprehension с условием ([x for x in numbers if x % 2 == 0]) более читаемо. filter предпочтителен, когда функция предикат уже существует (например, None, str.isdigit).
Как создать ленивый генератор вместо списка для экономии памяти?
Генераторное выражение использует круглые скобки вместо квадратных. Оно не хранит все элементы в памяти, а вычисляет их по мере необходимости. Идеально для больших данных или бесконечных последовательностей.
numbers = [1, 2, 3, 4, 5]
squared_gen = (n ** 2 for n in numbers)
print(squared_gen)
print(list(squared_gen))<generator object <genexpr> at 0x...> [1, 4, 9, 16, 25]
Типичные ошибки
Генератор можно использовать только один раз. После преобразования в список он истощается. Не стоит применять генератор, если требуется многократный доступ к элементам. Для однократного прохода (например, в цикле for или передаче в sum) генератор идеален.
Расширенные примеры и сравнения
Комбинирование фильтрации и преобразования
List comprehension позволяет совместить условие и преобразование в одном выражении. Сравните с цепочкой filter+map.
numbers = range(1, 11)
# list comprehension
result_lc = [n ** 2 for n in numbers if n % 2 == 0]
print('List comprehension:', result_lc)
# filter + map
result_fm = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers)))
print('Filter + map:', result_fm)List comprehension: [4, 16, 36, 64, 100] Filter + map: [4, 16, 36, 64, 100]
Пояснение
Оба варианта дают одинаковый результат, но list comprehension короче и понятнее. Однако filter+map может быть немного быстрее, если используются встроенные функции (например, filter(None, data)).
Вложенные циклы в list comprehension
Создание декартова произведения двух списков: порядок вложенных циклов соответствует порядку в обычных вложенных циклах.
colors = ['red', 'green']
sizes = ['S', 'M', 'L']
combinations = [(c, s) for c in colors for s in sizes]
print(combinations)[('red', 'S'), ('red', 'M'), ('red', 'L'), ('green', 'S'), ('green', 'M'), ('green', 'L')]
Проблемы
При увеличении числа вложенных циклов читаемость резко падает. Для трёх и более уровней лучше использовать itertools.product или обычные вложенные циклы.
Сравнение производительности с помощью timeit
Замеры времени для списка из 10 миллионов элементов (простейшее преобразование).
import timeit
setup = 'numbers = list(range(10_000_000))'
stmt_lc = '[n ** 2 for n in numbers]'
stmt_loop = '''
result = []
for n in numbers:
result.append(n ** 2)
'''
stmt_map = 'list(map(lambda x: x ** 2, numbers))'
t_lc = timeit.timeit(stmt_lc, setup, number=1)
t_loop = timeit.timeit(stmt_loop, setup, number=1)
t_map = timeit.timeit(stmt_map, setup, number=1)
print(f'List comprehension: {t_lc:.3f} sec')
print(f'For loop: {t_loop:.3f} sec')
print(f'Map: {t_map:.3f} sec')List comprehension: 0.487 sec For loop: 0.712 sec Map: 0.534 sec
List comprehension обычно быстрее цикла for, но map с lambda может быть медленнее из-за накладных расходов на вызов Python-функции. Если использовать встроенную функцию (например, math.sqrt), map может стать быстрее.
Использование модуля operator для ускорения map
Вместо lambda можно применить функцию из operator, которая реализована на C.
import operator
numbers = [1, 2, 3, 4, 5]
squared = list(map(operator.mul, numbers, numbers))
print(squared)[1, 4, 9, 16, 25]
Этот способ работает быстрее, чем lambda x: x*x, и не требует создания дополнительной функции.
Генераторы для работы с потоками данных
Чтение файла строка за строкой с обработкой каждой строки. Генератор позволяет не загружать весь файл в память.
def process_lines(filename):
with open(filename) as f:
for line in f:
yield line.strip().upper()
# Использование
for processed in process_lines('example.txt'):
print(processed[:10]) # только первые 10 символов для краткости(вывод первых 10 символов каждой обработанной строки)
Генераторное выражение позволяет сделать то же самое без явной функции:
processed = (line.strip().upper() for line in open('example.txt'))
for p in processed:
print(p[:10])Важно
Такой генератор оставляет файл открытым до завершения итерации. Лучше использовать менеджер контекста внутри генераторной функции.
Сравнение с использованием библиотеки itertools
Функции chain, starmap, compress и другие позволяют эффективно комбинировать преобразования без создания промежуточных списков.
import itertools
lists = [[1, 2], [3, 4, 5], [6]]
flattened = list(itertools.chain.from_iterable(lists))
print(flattened)
# Эквивалентный list comprehension с двумя циклами
flat_lc = [x for sub in lists for x in sub]
print(flat_lc)[1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6]
itertools.chain может быть быстрее и не создаёт временных списков.