Использование функций при построении объектно-ориентированных проектов на Python

Расширенные примеры работы с функциями в Python

В этом разделе представлены более сложные и не распространённые случаи использования функций. Каждый пример сопровождается кодом и результатом его выполнения.

Декоратор для измерения времени выполнения

import time
from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} выполнилась за {elapsed:.6f} сек.")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "Готово"

print(slow_function())

slow_function выполнилась за 1.000123 сек.
Готово

Пояснение: декоратор timer замеряет время до и после вызова исходной функции. functools.wraps сохраняет метаданные.

Замыкание для создания счётчика

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

counter_a = make_counter()
counter_b = make_counter()

print(counter_a())  # 1
print(counter_a())  # 2
print(counter_b())  # 1 – независимый счётчик

1
2
1

Пояснение: внутренняя функция counter использует переменную count из внешнего контекста. Ключевое слово nonlocal позволяет изменять захваченную переменную. Каждый вызов make_counter() создаёт собственную копию count.

Частичное применение с functools.partial

from functools import partial

def power(base, exp):
    return base ** exp

square = partial(power, exp=2)
cube = partial(power, exp=3)

print(square(5))  # 25
print(cube(2))    # 8

25
8

Пояснение: partial фиксирует часть аргументов функции, создавая новую функцию с меньшим числом параметров. Это удобно для специализации функций в функциональном стиле.

Мемоизация рекурсивного вычисления чисел Фибоначчи

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(50))  # 12586269025

12586269025

Пояснение: декоратор lru_cache автоматически кеширует результаты вызовов функции. Без кеширования рекурсивный расчёт fib(50) привёл бы к огромному числу повторных вычислений и занял бы очень много времени. lru_cache решает эту проблему.

Бесконечный генератор чисел Фибоначчи

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

fib_gen = fibonacci()
for _ in range(10):
    print(next(fib_gen), end=" ")  # 0 1 1 2 3 5 8 13 21 34

0 1 1 2 3 5 8 13 21 34

Пояснение: генератор fibonacci() производит бесконечную последовательность. Благодаря ленивым вычислениям он не занимает память под все значения сразу. Для остановки достаточно установить условие в вызывающем коде или использовать itertools.islice.

Декоратор с аргументами (параметризованный)

from functools import wraps

def repeat(num_times):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(num_times=3)
def greet(name):
    print(f"Привет, {name}!")

greet("Иван")

Привет, Иван!
Привет, Иван!
Привет, Иван!

Пояснение: декоратор repeat сам принимает аргументы. Он возвращает внутренний декоратор decorator, который уже применяется к функции. Такой подход позволяет настраивать поведение декоратора.

Использование lambda с map и filter для обработки данных

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Преобразование: квадраты чисел
even_squares = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))
print(even_squares)  # [4, 16, 36, 64, 100]

# Сортировка списка кортежей по второму элементу
data = [(1, 'z'), (2, 'a'), (3, 'b')]
sorted_data = sorted(data, key=lambda item: item[1])
print(sorted_data)  # [(2, 'a'), (3, 'b'), (1, 'z')]

[4, 16, 36, 64, 100]
[(2, 'a'), (3, 'b'), (1, 'z')]

Пояснение: лямбда-функции часто применяются в однострочных конструкциях, где не требуется именованная функция. Однако при сложной логике лучше вынести её в отдельную функцию.

Передача функции в качестве аргумента (функции высшего порядка)

def apply_twice(func, arg):
    return func(func(arg))

def increment(x):
    return x + 1

print(apply_twice(increment, 5))  # 7 (5+1+1)

7

Пояснение: функция apply_twice принимает другую функцию и применяет её дважды. Такой паттерн лежит в основе многих функциональных конструкций.