В чем разница между парадигмой и паттерном?

Различия между парадигмой и паттерном

Это два совершенно разных понятия, хотя часто их путают. Парадигма — это фундаментальный подход к программированию, а паттерн — это решение конкретной задачи.

Парадигма (Paradigm) — философия программирования

Назначение: парадигма определяет, как ты думаешь о программировании и как структурируешь код на самом высоком уровне.

# ПАРАДИГМА 1: Императивное программирование
# "Скажи компьютеру ШАГ ЗА ШАГОМ, что делать"

def calculate_square(numbers):
    result = []
    for num in numbers:  # Явные шаги
        result.append(num * num)
    return result

print(calculate_square([1, 2, 3, 4]))  # [1, 4, 9, 16]

# ПАРАДИГМА 2: Функциональное программирование
# "Опиши ЧТО ты хочешь получить"

def calculate_square_fp(numbers):
    return list(map(lambda x: x * x, numbers))

print(calculate_square_fp([1, 2, 3, 4]))  # [1, 4, 9, 16]

# ПАРАДИГМА 3: Объектно-ориентированное программирование
# "Моделируй реальный мир через объекты и их взаимодействия"

class Calculator:
    def calculate_square(self, numbers: list[int]) -> list[int]:
        return [num * num for num in numbers]

calc = Calculator()
print(calc.calculate_square([1, 2, 3, 4]))  # [1, 4, 9, 16]

Ключевые парадигмы:

• Императивная: как достичь результата (шаги)
• Декларативная: что нужно получить (результат)
• Функциональная: функции и их композиция
• ООП: объекты, классы, наследование
• Логическая: факты и правила (Prolog)
• Реактивная: потоки данных и их трансформация

Характеристики парадигмы:

• Самый высокий уровень абстракции
• Определяет менталитет разработчика
• Влияет на архитектуру программы
• Может быть несколько одновременно

Паттерн (Pattern) — решение задачи

Назначение: паттерн — это проверенное решение для конкретной задачи/проблемы. Рецепт, который можно применить в разных ситуациях.

# ПАТТЕРН 1: Singleton (Одиночка)
# Проблема: нужен только один объект класса

class DatabaseConnection:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

db1 = DatabaseConnection()
db2 = DatabaseConnection()
print(db1 is db2)  # True (один и тот же объект)

# ПАТТЕРН 2: Factory (Фабрика)
# Проблема: создание объектов разных типов по одному интерфейсу

class FileFactory:
    @staticmethod
    def create_reader(file_type: str):
        if file_type == "csv":
            return CSVReader()
        elif file_type == "json":
            return JSONReader()
        else:
            raise ValueError(f"Unknown type: {file_type}")

reader = FileFactory.create_reader("csv")

# ПАТТЕРН 3: Observer (Наблюдатель)
# Проблема: оповещение множества объектов об изменении

class EventEmitter:
    def __init__(self):
        self.listeners = []
    
    def subscribe(self, callback):
        self.listeners.append(callback)
    
    def emit(self, event):
        for callback in self.listeners:
            callback(event)

emitter = EventEmitter()
emitter.subscribe(lambda e: print(f"Listener 1: {e}"))
emitter.subscribe(lambda e: print(f"Listener 2: {e}"))
emitter.emit("User logged in")

Характеристики паттерна:

• Конкретное решение задачи
• Повторяемо (можно применить в разных проектах)
• Известно имя (Singleton, Factory и т.д.)
• Может быть в любой парадигме
• Решает одну или несколько проблем

Сравнение на примере

# ПАРАДИГМА: Объектно-ориентированное программирование
# "Мир состоит из объектов, которые взаимодействуют"

class Animal:  # Класс = объект
    def make_sound(self):
        pass

class Dog(Animal):  # Наследование
    def make_sound(self):
        return "Woof"

# ПАТТЕРН (внутри ООП): Strategy
# "Выбирай алгоритм на лету"

class PaymentProcessor:
    def __init__(self, strategy):
        self.strategy = strategy  # Стратегия = алгоритм
    
    def process(self, amount):
        return self.strategy.pay(amount)

class CreditCardStrategy:
    def pay(self, amount):
        return f"Paid {amount} via credit card"

class PayPalStrategy:
    def pay(self, amount):
        return f"Paid {amount} via PayPal"

# Использование
processor = PaymentProcessor(CreditCardStrategy())
print(processor.process(100))

processor.strategy = PayPalStrategy()  # Переключили стратегию
print(processor.process(100))

Таблица сравнения

Классификация паттернов (в ООП)

Creational (Создание объектов):

• Singleton — один объект
• Factory — создание по интерфейсу
• Builder — пошаговое создание
• Prototype — клонирование
• Abstract Factory — семейства объектов

Structural (Структура):

• Adapter — совместимость интерфейсов
• Decorator — добавление функционала
• Facade — упрощение интерфейса
• Proxy — контролируемый доступ
• Bridge — разделение абстракции

Behavioral (Поведение):

• Observer — оповещение об изменениях
• Strategy — выбор алгоритма
• Command — инкапсуляция команды
• State — изменение поведения
• Iterator — последовательный доступ

Практический пример

# ПАРАДИГМА: ООП
# ПАТТЕРН: Builder + Strategy

class ReportBuilder:
    def __init__(self, formatter_strategy):
        self.formatter = formatter_strategy
        self.data = []
    
    def add_section(self, title, content):
        self.data.append((title, content))
        return self  # Fluent interface
    
    def build(self):
        return self.formatter.format(self.data)

class PDFFormatter:
    def format(self, data):
        return f"PDF Report: {data}"

class HTMLFormatter:
    def format(self, data):
        return f"<html>{data}</html>"

# Использование
report = (ReportBuilder(PDFFormatter())
    .add_section("Introduction", "Welcome")
    .add_section("Content", "Details")
    .build())

print(report)

Вывод

Парадигма — это МИРОВОЗЗРЕНИЕ (как ты думаешь)

Паттерн — это ИНСТРУМЕНТ (как ты решаешь задачу)