В чем разница между функциональным программированием и ООП?

Разница между функциональным программированием и ООП

Функциональное программирование (ФП) и объектно-ориентированное программирование (ООП) — это два принципиально разных подхода к организации кода и решению задач. Python поддерживает оба парадигмы, что делает его мультипарадигменным языком, но важно понимать их фундаментальные различия.

Основные философии

ООП (Object-Oriented Programming) строится вокруг концепции объектов — сущностей, которые содержат данные (состояние) и методы (поведение). Основной принцип — инкапсуляция: объект скрывает внутреннее состояние и предоставляет интерфейс для взаимодействия.

Функциональное программирование рассматривает программу как последовательность трансформаций данных. Основной принцип — неизменяемость (immutability): данные не меняются, вместо этого создаются новые версии.

Состояние и данные

Вот критическое различие:

# ООП: объект содержит состояние
class BankAccount:
    def __init__(self, balance: float):
        self.balance = balance  # состояние
    
    def deposit(self, amount: float):
        self.balance += amount  # изменяем состояние
        return self.balance

account = BankAccount(1000)
account.deposit(500)  # balance теперь 1500

# ФП: функции трансформируют данные, не меняя исходные
def deposit(balance: float, amount: float) -> float:
    return balance + amount  # возвращаем новое значение

old_balance = 1000
new_balance = deposit(old_balance, 500)  # old_balance остался 1000

Управление сложностью

ООП борется со сложностью через инкапсуляцию и наследование:

• Разбивает проблему на объекты
• Каждый объект отвечает за свое состояние
• Наследование позволяет переиспользовать код
• Полиморфизм обеспечивает гибкость

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

ФП борется со сложностью через композицию функций и малые, чистые функции:

• Разбивает проблему на функции
• Каждая функция делает одно
• Функции композируются для создания сложного поведения
• Отсутствие побочных эффектов делает код предсказуемым

from functools import reduce
from typing import Callable

def compose(f: Callable, g: Callable) -> Callable:
    return lambda x: f(g(x))

add_five = lambda x: x + 5
multiply_two = lambda x: x * 2

result = compose(add_five, multiply_two)(3)  # (3 * 2) + 5 = 11

Побочные эффекты

ООП часто допускает побочные эффекты (изменение состояния объекта, вызов внешних систем).

ФП минимизирует побочные эффекты через чистые функции — функции, которые:

• Зависят только от входных параметров
• Не изменяют внешнее состояние
• Всегда возвращают одинаковый результат для одних входных данных

# ООП: побочный эффект (изменение состояния)
class Logger:
    def __init__(self):
        self.messages = []
    
    def log(self, msg: str) -> None:
        self.messages.append(msg)  # побочный эффект

# ФП: чистая функция
def log(messages: list[str], msg: str) -> list[str]:
    return messages + [msg]  # возвращаем новый список

Тестируемость

Чистые функции ФП легче тестировать:

# ФП — легко тестировать
def add(a: int, b: int) -> int:
    return a + b

assert add(2, 3) == 5

ООП требует больше подготовки (моки, фиксчеры), так как объекты содержат состояние.

Практический пример: обработка данных

# ООП подход
class DataProcessor:
    def __init__(self, data: list[int]):
        self.data = data
    
    def filter_even(self) -> 'DataProcessor':
        self.data = [x for x in self.data if x % 2 == 0]
        return self
    
    def double(self) -> 'DataProcessor':
        self.data = [x * 2 for x in self.data]
        return self

processor = DataProcessor([1, 2, 3, 4, 5])
result = processor.filter_even().double().data  # [4, 8]

# ФП подход
from functools import reduce

filter_even = lambda lst: [x for x in lst if x % 2 == 0]
double = lambda lst: [x * 2 for x in lst]

data = [1, 2, 3, 4, 5]
result = double(filter_even(data))  # [4, 8]

Когда использовать что

Используй ООП:

• Моделирование сложных объектов реального мира
• Большие системы с множеством взаимодействующих компонентов
• Когда нужна инкапсуляция состояния
• Веб-фреймворки, GUI приложения

Используй ФП:

• Обработка данных и трансформации
• Параллельное/асинхронное программирование (безопасность)
• Когда побочные эффекты должны быть минимальны
• Вычисления и аналитика

Python: гибридный подход

Реальный Python код часто комбинирует оба подхода:

from dataclasses import dataclass
from typing import Callable

@dataclass(frozen=True)  # неизменяемый объект
class User:
    name: str
    age: int

def get_adults(users: list[User]) -> list[User]:
    return [u for u in users if u.age >= 18]

users = [User("Alice", 25), User("Bob", 16)]
adults = get_adults(users)

Это демонстрирует гибридный подход: используются объекты для структурирования данных (User), но с функциональными принципами неизменяемости и чистыми функциями для обработки.