Python как инструмент функционального программирования

Расширенные примеры функционального программирования в Python

Композиция функций с помощью compose вручную

Создадим функцию, которая объединяет несколько функций в одну, передавая результат каждой следующей.

# Определяем композицию
def compose(*funcs):
    def inner(arg):
        result = arg
        for f in reversed(funcs):
            result = f(result)
        return result
    return inner

# Функции
def double(x): return x * 2
def increment(x): return x + 1

# Композиция: сначала increment, потом double
double_of_increment = compose(double, increment)
print(double_of_increment(5))  # (5+1)*2 = 12

12

Каррирование с использованием partial и lambda

Каррирование превращает функцию от нескольких аргументов в последовательность функций от одного аргумента.

# Каррированная функция sum
def curried_sum(a):
    def inner(b):
        return a + b
    return inner

add_5 = curried_sum(5)
print(add_5(3))  # 8

# Более компактно с partial
from functools import partial

def add(a, b): return a + b
add_10 = partial(add, 10)
print(add_10(7))  # 17

8
17

Функция-декоратор как инструмент высшего порядка

Декоратор оборачивает функцию, добавляя побочное поведение (логирование, замер времени).

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} заняла {elapsed:.3f} сек")
        return result
    return wrapper

@timer
def slow_long(n):
    return sum(range(n))

print(slow_long(10_000_000))

slow_long заняла 0.345 сек
49999995000000

Использование operator для замены лямбда

Модуль operator предоставляет готовые функции для арифметики и сравнений, что повышает производительность.

from operator import add, mul, gt

numbers = [1, 2, 3, 4, 5]
# Сумма всех элементов
total = reduce(add, numbers)
# Произведение всех элементов
product = reduce(mul, numbers)
# Фильтр чисел > 2
filtered = list(filter(lambda x: gt(x, 2), numbers))
print(total, product, filtered)

15 120 [3, 4, 5]

Ленивая фильтрация с itertools.filterfalse

Функция filterfalse возвращает элементы, для которых предикат даёт False.

from itertools import filterfalse

data = [1, 2, 3, 4, 5, 6]
# Числа, не являющиеся нечётными (т.е. чётные)
evens = list(filterfalse(lambda x: x % 2 == 1, data))
print(evens)

[2, 4, 6]

Транзакция данных через цепочку map и filter (без списковых включений)

Совмещение нескольких преобразований в одной цепочке.

numbers = range(1, 11)
# Взять квадраты чётных чисел
result = list(map(lambda x: x**2,
                  filter(lambda x: x % 2 == 0, numbers)))
print(result)

[4, 16, 36, 64, 100]

Создание бесконечного потока с itertools.count и islice

Пример генерации бесконечной последовательности и взятия её среза.

from itertools import count, islice

# Бесконечный счётчик, начиная с 10, шаг 3
counter = count(10, 3)
first_five = list(islice(counter, 5))
print(first_five)

[10, 13, 16, 19, 22]

Мемоизация с lru_cache для рекурсивных функций

Декоратор lru_cache автоматически запоминает результаты вызовов, ускоряя рекурсию.

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(100))

354224848179261915075

Примечание: lru_cache не решает проблему глубины рекурсии, но предотвращает повторные вычисления.