Какой фреймворк под какую задачу подходит?

Выбор фреймворков по типам задач

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

1. Web Framework для REST API

FastAPI — для современных асинхронных APIs

# Идеально для:
# - REST APIs с современным Python
# - Асинхронные I/O операции (БД, HTTP)
# - OpenAPI/Swagger документация из коробки
# - Type hints для валидации
# - Высокая производительность

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import asyncio

app = FastAPI(title="Modern API")

class User(BaseModel):
    name: str
    email: str

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    # Асинхронный код
    return {"id": user_id, "name": "John"}

@app.post("/users")
async def create_user(user: User):
    # Автоматическая валидация JSON
    return {"id": 1, "name": user.name}

# Запуск: uvicorn app:app --reload
# Документация: http://localhost:8000/docs

Django — для полноценных web приложений

# Идеально для:
# - Full-stack приложения (frontend + backend)
# - ORM (Django ORM) встроена
# - Admin панель из коробки
# - Встроенная аутентификация и permissions
# - Большие проекты с развитой архитектурой

from django.http import JsonResponse
from django.views.decorators.http import require_http_methods
from django.contrib.auth.models import User

@require_http_methods(["GET"])
def get_user(request, user_id):
    try:
        user = User.objects.get(id=user_id)
        return JsonResponse({"id": user.id, "name": user.username})
    except User.DoesNotExist:
        return JsonResponse({"error": "Not found"}, status=404)

# Django преимущества:
# - Admin: http://localhost:8000/admin (встроена)
# - Permissions: @permission_required
# - Middleware система
# - Form validation
# - Templates

Flask — лёгкий и гибкий микрофреймворк

# Идеально для:
# - Простых и средних проектов
# - Максимальной гибкости
# - Микросервисов
# - Когда не нужна встроенная ORM

from flask import Flask, request, jsonify
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

@app.route("/users/<int:user_id>", methods=["GET"])
def get_user(user_id):
    return jsonify({"id": user_id, "name": "John"})

@app.route("/users", methods=["POST"])
def create_user():
    data = request.get_json()
    return jsonify({"id": 1, "name": data["name"]}), 201

if __name__ == "__main__":
    app.run(debug=True)

# Flask преимущества:
# - Минимальный overhead
# - Легко добавить нужные компоненты
# - Документация clara

GraphQL фреймворки — для сложных запросов к данным

# Ideal для:
# - Complex data relationships
# - Client-specified data requirements
# - Real-time subscriptions

import graphene
from graphene import ObjectType, String, Int, Schema

class UserType(ObjectType):
    id = Int()
    name = String()
    email = String()

class Query(ObjectType):
    user = graphene.Field(UserType, id=Int(required=True))
    
    def resolve_user(self, info, id):
        # Fetch user from DB
        return UserType(id=id, name="John", email="john@example.com")

schema = Schema(query=Query)

# GraphQL преимущества:
# - Клиент запрашивает только нужные поля
# - Автоматическая документация
# - Мощная система типов

2. Async фреймворки

Starlette — низкоуровневый асинхронный ASGI фреймворк

# Идеально для:
# - Максимальной производительности
# - WebSockets
# - Полного контроля
# - Лёгкого приложения

from starlette.applications import Starlette
from starlette.routing import Route
from starlette.responses import JSONResponse
import asyncio

async def get_user(request):
    user_id = request.path_params["user_id"]
    return JSONResponse({"id": user_id, "name": "John"})

async def websocket_endpoint(websocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"Message: {data}")

routes = [
    Route("/users/{user_id}", get_user),
    # WebSocket support
]

app = Starlette(routes=routes)

# Starlette преимущества:
# - Очень быстрый
# - WebSockets из коробки
# - Минимальный overhead

Sanic — асинхронный микрофреймворк

# Идеально для:
# - Высокопроизводительных микросервисов
# - Real-time приложений
# - Streaming responses

from sanic import Sanic, json

app = Sanic("myapp")

@app.route("/users/<user_id:int>")
async def get_user(request, user_id):
    return json({"id": user_id, "name": "John"})

@app.websocket("/ws")
async def ws_handler(request, ws):
    while True:
        data = await ws.recv()
        await ws.send(f"Echo: {data}")

if __name__ == "__main__":
    app.run()

3. ORM фреймворки

SQLAlchemy — универсальный ORM

# Идеально для:
# - Любых приложений требующих ORM
# - Сложных запросов с joinами
# - Database-agnostic кода
# - Может быть sync или async

from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

engine = create_engine("postgresql://localhost/mydb")
Session = sessionmaker(bind=engine)
session = Session()

# Запрос
users = session.query(User).filter(User.email.endswith("@example.com")).all()

# Асинхронный SQLAlchemy
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession

engine = create_async_engine("postgresql+asyncpg://localhost/mydb")
Async_session = sessionmaker(engine, class_=AsyncSession)

async with Async_session() as session:
    result = await session.execute(select(User))
    users = result.scalars().all()

Tortoise ORM — асинхронный ORM для modern Python

# Идеально для:
# - Асинхронных приложений
# - Разработки "с нуля"
# - FastAPI приложений

from tortoise import fields
from tortoise.models import Model

class User(Model):
    id = fields.IntField(pk=True)
    name = fields.CharField(max_length=100)
    email = fields.CharField(max_length=100)
    
    class Meta:
        table = "users"

# Использование
async def get_user(user_id: int):
    user = await User.get(id=user_id)
    return user

# Tortoise преимущества:
# - Async/await
# - Простой синтаксис
# - FastAPI интеграция

Django ORM — встроенный ORM для Django

# Идеально для:
# - Django приложений
# - Встроенная в фреймворк
# - Migrations система
# - Связь с админ панелью

from django.db import models

class User(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(unique=True)
    created_at = models.DateTimeField(auto_now_add=True)

# Использование
users = User.objects.filter(email__endswith="@example.com")
user = User.objects.get(id=1)
user.name = "John"
user.save()

4. Реальная таблица выбора

┌─────────────────────┬────────────────┬──────────────┬──────────────┐
│ Требование          │ Лучший выбор   │ Альтернатива │ Избегать     │
├─────────────────────┼────────────────┼──────────────┼──────────────┤
│ REST API            │ FastAPI        │ Flask        │ Django       │
│ Full-stack app      │ Django         │ FastAPI      │ Sanic        │
│ Микросервис         │ FastAPI        │ Flask        │ Django       │
│ GraphQL             │ Strawberry     │ Graphene     │ Flask        │
│ Real-time (WebSock) │ Starlette      │ Sanic        │ Django       │
│ Streaming data      │ Sanic          │ Starlette    │ Flask        │
│ High performance    │ Starlette      │ Sanic        │ Django       │
│ Complex ORM         │ SQLAlchemy     │ Django ORM   │ Tortoise     │
│ Async ORM           │ Tortoise       │ SQLAlchemy   │ Django ORM   │
│ Admin panel needed  │ Django         │ Flask-Admin  │ FastAPI      │
│ Rapid development   │ Django         │ FastAPI      │ Sanic        │
│ Data science app    │ FastAPI        │ Streamlit    │ Django       │
│ CLI tool            │ Click/Typer    │ Argparse     │ Flask        │
│ Background jobs     │ Celery         │ APScheduler  │ Threading    │
└─────────────────────┴────────────────┴──────────────┴──────────────┘

5. Сравнение популярных фреймворков

# FASTAPI vs Django

# FastAPI: Современный, быстрый, асинхронный
Преимущества:
✓ Async/await
✓ OpenAPI документация автоматически
✓ Высокая производительность (асинхронный)
✓ Type hints и валидация из коробки
✓ Модульная архитектура
✗ Нет встроённого admin
✗ Нет встроённой аутентификации
✗ Нет встроённого ORM

# Django: Батарейки включены, all-in-one
Преимущества:
✓ All-in-one solution
✓ Встроенный admin
✓ Встроенная аутентификация и permissions
✓ ORM встроена
✓ Forms, Templates
✗ Сложнее для простых APIs
✗ По умолчанию синхронный
✗ Overkill для микросервисов

# Flask: Лёгкий, гибкий, минимальный
Преимущества:
✓ Простота
✓ Максимальная гибкость
✓ Лёгкий вес
✓ Хороший для микросервисов
✗ Нужно выбирать и интегрировать компоненты
✗ Меньше встроенных возможностей
✗ По умолчанию синхронный

6. Выбор по метрикам производительности

# Benchmark (requests/sec, выше — лучше)
#
# Starlette:        ~100,000 req/s
# Sanic:            ~90,000 req/s
# FastAPI:          ~80,000 req/s (с async handlers)
# Flask:            ~30,000 req/s
# Django:           ~10,000 req/s
#
# Внимание: Это микрабенчмарки! Real-world зависит от логики

import asyncio
import aiohttp
from time import time

async def benchmark_framework(framework_url: str, requests: int = 1000):
    async with aiohttp.ClientSession() as session:
        start = time()
        tasks = []
        for _ in range(requests):
            task = session.get(framework_url)
            tasks.append(task)
        
        responses = await asyncio.gather(*tasks)
        elapsed = time() - start
        
        rps = requests / elapsed
        print(f"Framework: {rps:.0f} req/s")
        return rps

# Запуск
async def main():
    await benchmark_framework("http://localhost:8000/users/1")

asyncio.run(main())

7. Практический выбор для реальных проектов

# СЦЕНАРИЙ 1: Стартап нужен MVP быстро
# → Django (все есть из коробки) или FastAPI (быстрее)

# СЦЕНАРИЙ 2: Корпоративное приложение
# → Django (много features, stable, хорошая поддержка)

# СЦЕНАРИЙ 3: Микросервисная архитектура
# → FastAPI (асинхронный, лёгкий, fast)

# СЦЕНАРИЙ 4: Real-time приложение (WebSockets)
# → Starlette или Sanic (асинхронный, WebSockets)

# СЦЕНАРИЙ 5: Data Science / ML API
# → FastAPI + Pydantic (просто сконвертить модель в endpoint)

# СЦЕНАРИЙ 6: Максимальная производительность
# → Starlette или Sanic + асинхронный код

# СЦЕНАРИЙ 7: Запрос с минимальной кривой обучения
# → Flask (простой синтаксис) или Django (документация)

# СЦЕНАРИЙ 8: Внутреннее приложение компании
# → Django (админ панель экономит время)

Итоговые рекомендации

Выбирай FastAPI если:

• Разрабатываешь REST API
• Нужна асинхронность
• Важна производительность
• Хочешь современный Python (async/await, type hints)

Выбирай Django если:

• Нужна полноценная web-application
• Нужны админ панель и встроенная аутентификация
• Доступна опытная команда
• Скорость разработки > скорость выполнения

Выбирай Flask если:

• Нужна максимальная гибкость
• Проект небольшой
• Хочешь минимум dependencies
• Разрабатываешь микросервис

Выбирай Starlette/Sanic если:

• Нужна максимальная производительность
• Нужны WebSockets
• Нужна полная асинхронность

Ключевое правило: Не существует идеального фреймворка — есть правильный выбор под твою задачу.