Эффективные приёмы написания Python-кода

Расширенные примеры и нераспространённые приёмы

Ниже приведены более сложные сценарии использования разных стилей, которые выходят за рамки базовых примеров.

Вложенные списковые включения для матриц

Создание матрицы 3x3 и транспонирование:

matrix = [[i * 3 + j + 1 for j in range(3)] for i in range(3)]
print("Исходная матрица:")
for row in matrix:
    print(row)

transposed = [[matrix[j][i] for j in range(3)] for i in range(3)]
print("Транспонированная:")
for row in transposed:
    print(row)

Исходная матрица:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
Транспонированная:
[1, 4, 7]
[2, 5, 8]
[3, 6, 9]

Использование вложенных включений позволяет компактно преобразовывать двумерные структуры, но при большом размере лучше применить NumPy.

map с несколькими итераторами

Поэлементное сложение двух списков:

a = [1, 2, 3]
b = [4, 5, 6]
sums = list(map(lambda x, y: x + y, a, b))
print(sums)

[5, 7, 9]

map принимает несколько итерируемых объектов; функция должна иметь соответствующее количество аргументов. Если списки разной длины, итерация остановится по кратчайшему.

Генератор с yield и yield from

Реализация собственного генератора для последовательности Фибоначчи:

def fibonacci(limit):
    a, b = 0, 1
    while a < limit:
        yield a
        a, b = b, a + b

fib_gen = fibonacci(100)
print(list(fib_gen))

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Ключевое слово yield from позволяет делегировать часть работы другому генератору. Например, объединение нескольких последовательностей:

def chain_generators(*iters):
    for it in iters:
        yield from it

result = list(chain_generators(range(3), range(10, 13)))
print(result)

[0, 1, 2, 10, 11, 12]

Комбинирование filter и map с ленивыми вычислениями

Отфильтровать чётные числа, затем возвести их в квадрат, используя только функции высшего порядка:

numbers = range(1, 11)
even_squares = map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers))
print(list(even_squares))

[4, 16, 36, 64, 100]

Такая цепочка работает лениво: filter проверяет условие, map преобразует, и только вызов list() запускает реальные вычисления. Это полезно при работе с большими данными, когда преобразования нужно выполнить только один раз.

Использование itertools для сложных итераций

Модуль itertools предоставляет множество инструментов для функционального стиля. Например, itertools.accumulate для накопления сумм:

from itertools import accumulate

numbers = [1, 2, 3, 4, 5]
cumsum = list(accumulate(numbers))
print(cumsum)

[1, 3, 6, 10, 15]

А itertools.chain объединяет несколько итераторов в один, что аналогично yield from но готовыми средствами:

from itertools import chain

combined = list(chain([1, 2], {3, 4}, "56"))
print(combined)

[1, 2, 3, 4, '5', '6']

Производительность различных стилей

Для точного измерения времени выполнения можно использовать модуль timeit. Сравнение спискового включения, цикла и map на миллионе элементов:

import timeit

setup = 'numbers = range(1, 1000001)'

list_comp_time = timeit.timeit('[x ** 2 for x in numbers]', setup=setup, number=10)
loop_time = timeit.timeit('result = []; [result.append(x ** 2) for x in numbers]', setup=setup, number=10)
map_time = timeit.timeit('list(map(lambda x: x ** 2, numbers))', setup=setup, number=10)

print(f"list comprehension: {list_comp_time:.3f}s")
print(f"loop with append: {loop_time:.3f}s")
print(f"map + list: {map_time:.3f}s")

list comprehension: 0.345s
loop with append: 0.512s
map + list: 0.421s

Результаты показывают, что списковое включение обычно быстрее, хотя конкретные цифры зависят от версии Python и аппаратного обеспечения. Генераторное выражение без преобразования в список будет ещё быстрее по памяти, но не по времени при полном обходе.