Какие знаешь парадигмы разработки в Python?

Парадигмы разработки в Python

Python поддерживает несколько парадигм программирования. Каждая имеет свои преимущества.

1. Объектно-ориентированная (OOP)

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        pass

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

dog = Dog("Rex")
print(dog.speak())  # Woof!

Фокус на объектах и их взаимодействии.

2. Функциональная (FP)

from functools import reduce

numbers = [1, 2, 3, 4, 5]

# Map
squares = list(map(lambda x: x ** 2, numbers))

# Filter
evens = list(filter(lambda x: x % 2 == 0, numbers))

# Reduce
total = reduce(lambda a, b: a + b, numbers)

Фокус на функциях и неизменяемости данных.

3. Императивная

# Пошаговые инструкции
result = []
for i in range(10):
    if i % 2 == 0:
        result.append(i ** 2)

print(result)  # [0, 4, 16, 36, 64]

Инструктирование компьютера ШТО делать и КАК.

4. Декларативная

# Описание ТОГО, ЧТО нужно, а не КАК
result = [i ** 2 for i in range(10) if i % 2 == 0]
print(result)  # [0, 4, 16, 36, 64]

Записываем результат, Python решает как это вычислить.

5. Процедурная

def calculate(data):
    # Последовательность процедур
    cleaned = clean_data(data)
    processed = process(cleaned)
    validated = validate(processed)
    return validated

result = calculate(raw_data)

Фокус на функциях и процедурах.

6. Метапрограммирование

# Код, который генерирует код
class Meta(type):
    def __new__(mcs, name, bases, attrs):
        attrs['hello'] = lambda self: "Hello"
        return super().__new__(mcs, name, bases, attrs)

class MyClass(metaclass=Meta):
    pass

obj = MyClass()
print(obj.hello())  # Hello

7. Асинхронная / Реактивная

import asyncio

async def fetch_data(url):
    await asyncio.sleep(1)
    return "data"

async def main():
    result = await fetch_data('url')
    print(result)

asyncio.run(main())

Фокус на событиях и асинхронном выполнении.

8. Обобщённое программирование (Generic)

from typing import TypeVar, Generic, List

T = TypeVar('T')

class Container(Generic[T]):
    def __init__(self, items: List[T]):
        self.items = items
    
    def get(self, index: int) -> T:
        return self.items[index]

int_container = Container([1, 2, 3])
str_container = Container(['a', 'b', 'c'])

9. Логическая парадигма (Prolog-style)

# Очень редко в Python, но возможна
# Используется в специальных библиотеках
from pyswip import Prolog

prolog = Prolog()
prolog.assertz("parent(tom, bob)")
prolog.assertz("parent(tom, liz)")

for solution in prolog.query("parent(tom, X)"):
    print(solution["X"])  # bob, liz

10. Контрактное программирование

from contracts import contract

@contract(x='int,>=0', returns='int,>0')
def factorial(x):
    if x == 0:
        return 1
    return x * factorial(x - 1)

print(factorial(5))  # 120
print(factorial(-1))  # ContractError!

Комбинированный подход

class DataProcessor:
    """Комбинирует OOP, FP и async"""
    
    def __init__(self, data):
        self.data = data
    
    async def process(self):
        # Декларативно-функциональный подход
        result = [
            item * 2 
            for item in self.data
            if item > 0
        ]
        return result
    
    def map_data(self, func):
        """Функциональный подход"""
        return list(map(func, self.data))

# Использование
processor = DataProcessor([1, -2, 3, -4, 5])
result = processor.map_data(lambda x: x ** 2)
print(result)  # [1, 4, 9, 16, 25]

Когда использовать какую

pardigms = {
    'OOP': 'Большие системы, сложная логика',
    'FP': 'Data processing, transformations',
    'Async': 'I/O-bound операции, веб-приложения',
    'Declarative': 'List/dict comprehensions',
    'Imperative': 'Простые скрипты',
    'Generic': 'Переиспользуемые компоненты',
}

Лучшие практики

# 1. Используй подходящую парадигму
class User:  # OOP для модели
    def __init__(self, name):
        self.name = name

def process_users(users):  # FP для обработки
    return list(map(lambda u: u.name.upper(), users))

# 2. Комбинируй парадигмы
users = [User('john'), User('jane')]
names = [u.name for u in users if u]  # OOP + declarative

# 3. Не переусложняй
# ❌ Избыточно сложно
result = reduce(lambda a, b: a + list(map(lambda x: x ** 2, b)), ...)

# ✅ Просто и понятно
result = [x ** 2 for sublist in data for x in sublist]

Вывод: Python — мультипарадигменный язык. Лучше выбирать правильную парадигму для каждой задачи, часто комбинируя несколько.