Какие знаешь фреймворки для Backend?

Backend фреймворки для Python

Python имеет богатый экосистем фреймворков для создания веб-приложений и API. Выбор зависит от сложности проекта и требований.

1. FastAPI — современный фреймворк для API

Лучший выбор в 2025 для новых проектов:

from fastapi import FastAPI, Depends
from pydantic import BaseModel
from typing import Optional

app = FastAPI()

class User(BaseModel):
    id: int
    name: str
    email: Optional[str] = None

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

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    return {"id": user_id}

# Запуск: uvicorn main:app --reload

Преимущества:

• Автоматическая валидация Pydantic
• OpenAPI/Swagger документация из кода
• Асинхронность (async/await) по умолчанию
• Очень быстро (производительность близка к Node.js)
• Легко писать типы (типизация из коробки)
• Dependency Injection встроен

Недостатки:

• Молодой фреймворк (но уже очень стабилен)
• Меньше готовых решений, чем в Django
• Требует дополнительных библиотек для БД ORM

2. Django — зрелый, полнофункциональный фреймворк

Лучший для полнофункциональных приложений:

# models.py
from django.db import models

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

# views.py
from django.shortcuts import render
from django.views import View
from rest_framework import viewsets
from rest_framework.decorators import api_view

@api_view(['GET', 'POST'])
def user_list(request):
    if request.method == 'POST':
        serializer = UserSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
    else:
        users = User.objects.all()
        serializer = UserSerializer(users, many=True)
        return Response(serializer.data)

# urls.py
from django.urls import path

urlpatterns = [
    path('api/users', user_list),
]

Преимущества:

• Полноценный фреймворк (templates, admin, ORM, auth)
• Огромное сообщество
• Django REST Framework для API
• Администраторская панель из коробки
• Зрелость (production-ready)
• Встроенная аутентификация и авторизация

Недостатки:

• Синхронный (async добавили недавно)
• Изучение кривой выше
• Может быть оverkill для простого API
• Медленнее FastAPI

3. Flask — микрофреймворк

Для простых приложений и когда нужна максимальная гибкость:

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

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://...'
db = SQLAlchemy(app)
CORS(app)

@app.route('/users', methods=['GET'])
def get_users():
    users = User.query.all()
    return jsonify([{'id': u.id, 'name': u.name} for u in users])

@app.route('/users', methods=['POST'])
def create_user():
    data = request.json
    user = User(name=data['name'], email=data['email'])
    db.session.add(user)
    db.session.commit()
    return jsonify({'id': user.id}), 201

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

Преимущества:

• Минимален и гибкий
• Легче учиться
• Большое сообщество и расширения
• Хорош для простых задач

Недостатки:

• Нужно добавлять много расширений для полноценного приложения
• Валидация не встроена
• Медленнее FastAPI
• Синхронный

4. Falcon — высокопроизводительный микрофреймворк

Для очень быстрых API:

import falcon
import json

class UsersResource:
    def on_get(self, req, resp):
        users = [{"id": 1, "name": "Alice"}]
        resp.media = users
    
    def on_post(self, req, resp):
        data = json.loads(req.bounded_stream.read())
        resp.media = {"created": data['name']}

app = falcon.App()
app.add_route('/users', UsersResource())

# Запуск: gunicorn main:app

Преимущества:

• Очень быстро (в benchmarks быстрее FastAPI)
• Минимален
• Хорош для микросервисов

Недостатки:

• Меньше сообщества
• Меньше готовых решений

5. Starlette — асинхронный микрофреймворк

FastAPI построен на Starlette. Используй, если нужна более низкоуровневая работа:

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

async def homepage(request):
    return JSONResponse({'hello': 'world'})

async def user_detail(request):
    user_id = request.path_params['user_id']
    await asyncio.sleep(1)  # Асинхронная операция
    return JSONResponse({'id': user_id})

routes = [
    Route('/', homepage),
    Route('/users/{user_id}', user_detail),
]

app = Starlette(routes=routes)

Преимущества:

• Асинхронность
• Легче, чем FastAPI, но больше контроля
• Хорош как основа для кастомных фреймворков

6. Sanic — похож на Flask, но асинхронный

from sanic import Sanic, json

app = Sanic("MyApp")

@app.get("/")
async def index(request):
    return json({"hello": "world"})

@app.post("/users")
async def create_user(request):
    return json({"created": request.json['name']}, status=201)

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

Преимущества:

• Синтаксис близок к Flask
• Асинхронный

Недостатки:

• Меньше сообщества, чем FastAPI

7. Tornado — фреймворк для WebSockets и real-time

Когда нужны WebSockets, real-time updates:

import tornado.ioloop
import tornado.web
import asyncio

class WebSocketHandler(tornado.web.WebSocketHandler):
    def on_message(self, message):
        # Отправляй сообщение обратно всем connected клиентам
        self.write_message(f"echo: {message}")

app = tornado.web.Application([
    (r"/ws", WebSocketHandler),
])

if __name__ == "__main__":
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

8. Сравнительная таблица

9. Мой выбор для разных проектов

разные_проекты = {
    "Новый REST API": "FastAPI (best defaults)",
    "Полнофункциональное веб-приложение": "Django",
    "Простой скрипт с HTTP endpoint": "Flask",
    "Микросервис (нужна максимальная скорость)": "Falcon",
    "Real-time приложение (WebSockets, чат)": "Tornado или FastAPI",
    "GraphQL API": "FastAPI + Strawberry",
    "Админ-панель для CRUD операций": "Django + Django Admin",
    "Async фон-работник (celery задачи)": "FastAPI + Celery"
}

10. Современный стек 2025

модерн_стек = {
    "API": "FastAPI + Pydantic V2",
    "ORM": "SQLAlchemy 2.0",
    "БД": "PostgreSQL",
    "Валидация": "Pydantic validators",
    "Async": "asyncio + async sqlalchemy",
    "Тестирование": "pytest + pytest-asyncio",
    "Документация": "OpenAPI (встроен в FastAPI)",
    "Деплой": "Docker + Kubernetes или Vercel"
}

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