Какими еще фреймворками пользовался, кроме Django?

Опыт с Python фреймворками (помимо Django)

За 10+ лет использовал множество фреймворков для разных задач. Вот мой практический опыт.

1. FastAPI - современный выбор для API

Использую в проектах где критична скорость разработки и performance:

# FastAPI - очень быстрый и удобный фреймворк
from fastapi import FastAPI, HTTPException, Depends
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
from typing import Optional, List
import uvicorn

app = FastAPI(
    title="My API",
    version="1.0.0",
    description="High-performance API"
)

# Pydantic модели - автоматическая валидация
class User(BaseModel):
    id: int
    name: str = Field(..., min_length=3, max_length=50)
    email: str
    age: Optional[int] = None

    class Config:
        schema_extra = {
            "example": {
                "id": 1,
                "name": "John",
                "email": "john@example.com",
                "age": 30
            }
        }

# Автоматический OpenAPI (Swagger) - без доп. конфига!

@app.get("/")
async def read_root():
    return {"Hello": "World"}

@app.get("/users/{user_id}")
async def get_user(user_id: int) -> User:
    """Получить пользователя по ID"""
    if user_id not in users:
        raise HTTPException(status_code=404, detail="User not found")
    return users[user_id]

@app.post("/users/")
async def create_user(user: User) -> User:
    """Создать нового пользователя"""
    users[user.id] = user
    return user

# Dependency Injection
async def get_current_user(token: str) -> User:
    if not verify_token(token):
        raise HTTPException(status_code=401, detail="Invalid token")
    return get_user_by_token(token)

@app.get("/protected/")
async def protected_route(user: User = Depends(get_current_user)):
    return {"user": user}

# WebSocket поддержка
@app.websocket("/ws")
async def websocket_endpoint(websocket):
    await websocket.accept()
    try:
        while True:
            data = await websocket.receive_text()
            await websocket.send_text(f"Echo: {data}")
    finally:
        await websocket.close()

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Плюсы FastAPI:

• Асинхронность по умолчанию
• Автоматическая документация (Swagger, ReDoc)
• Очень быстрый (почти как Go)
• Отличная валидация через Pydantic
• Type hints встроены

Минусы:

• Меньше готовых решений чем Django
• Нет ORM в коробке
• Admin панель нужно писать самому

2. Flask - лёгкий и гибкий

Использовал в небольших проектах и микросервисах:

from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_restful import Api, Resource
from flask_cors import CORS

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
app.config['JSON_SORT_KEYS'] = False

db = SQLAlchemy(app)
api = Api(app)
CORS(app)  # Включаем CORS

# Модель
class Product(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    price = db.Column(db.Float, nullable=False)

# Простой маршрут
@app.route("/")
def hello():
    return jsonify({"message": "Hello World"})

@app.route("/products", methods=["GET", "POST"])
def products():
    if request.method == "POST":
        data = request.get_json()
        product = Product(name=data["name"], price=data["price"])
        db.session.add(product)
        db.session.commit()
        return jsonify({"id": product.id}), 201
    else:
        products = Product.query.all()
        return jsonify([
            {"id": p.id, "name": p.name, "price": p.price}
            for p in products
        ])

# REST API с flask-restful
class ProductResource(Resource):
    def get(self, product_id):
        product = Product.query.get(product_id)
        if not product:
            return {"error": "Not found"}, 404
        return {
            "id": product.id,
            "name": product.name,
            "price": product.price
        }
    
    def delete(self, product_id):
        product = Product.query.get(product_id)
        if product:
            db.session.delete(product)
            db.session.commit()
        return {"success": True}

api.add_resource(ProductResource, "/api/products/<int:product_id>")

if __name__ == "__main__":
    with app.app_context():
        db.create_all()
    app.run(debug=True)

Плюсы Flask:

• Очень простой и лёгкий
• Гибкий - можно использовать любые библиотеки
• Хорошо для микросервисов
• Нежёсткая структура

Минусы:

• Много boilerplate для полного приложения
• Нет admin панели
• Сложнее с большими проектами

3. Aiohttp - асинхронный веб-фреймворк

Использовал для высоконагруженных приложений:

from aiohttp import web
import asyncio

async def handle_request(request):
    name = request.match_info.get('name', "anonymous")
    text = f"Hello, {name}"
    return web.Response(text=text)

async def handle_json(request):
    data = await request.json()
    return web.json_response({"received": data})

async def websocket_handler(request):
    ws = web.WebSocketResponse()
    await ws.prepare(request)
    
    async for msg in ws:
        if msg.type == web.WSMsgType.text:
            await ws.send_str(f"Echo: {msg.data}")
        elif msg.type == web.WSMsgType.error:
            break
    
    return ws

# Middleware
@web.middleware
async def log_middleware(request, handler):
    print(f"{request.method} {request.path}")
    response = await handler(request)
    return response

app = web.Application(middlewares=[log_middleware])
app.router.add_get('/', handle_request)
app.router.add_get('/hello/{name}', handle_request)
app.router.add_post('/api/data', handle_json)
app.router.add_get('/ws', websocket_handler)

if __name__ == '__main__':
    web.run_app(app, port=8080)

Плюсы:

• Асинхронный с самого начала
• Поддержка WebSockets
• Хорошая для микросервисов

Минусы:

• Менее популярен
• Нет готовых решений

4. Pyramid - средний размер

Использовал в проектах среднего размера:

from pyramid.config import Configurator
from pyramid.request import Request
from pyramid.response import Response
from pyramid.view import view_config

# Декораторы для маршрутов
@view_config(route_name='home', renderer='json')
def home(request: Request):
    return {'message': 'Hello World'}

@view_config(route_name='user', renderer='json')
def get_user(request: Request):
    user_id = request.matchdict['id']
    return {'id': user_id, 'name': 'John'}

if __name__ == '__main__':
    with Configurator() as config:
        config.add_route('home', '/')
        config.add_route('user', '/users/{id}')
        config.scan()
        
        app = config.make_wsgi_app()
        
        from waitress import serve
        serve(app, host='0.0.0.0', port=6543)

5. Tornado - высоконагруженные приложения

Использовал для real-time приложений:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    async def get(self):
        await self.write({"message": "Hello World"})

class WebSocketHandler(tornado.web.WebSocketHandler):
    def open(self):
        print("WebSocket opened")
    
    def on_message(self, message):
        self.write_message(f"Echo: {message}")
    
    def on_close(self):
        print("WebSocket closed")

if __name__ == "__main__":
    app = tornado.web.Application([
        (r"/", MainHandler),
        (r"/ws", WebSocketHandler),
    ])
    app.listen(8080)
    tornado.ioloop.IOLoop.current().start()

Плюсы:

• Очень быстрый
• Встроенная поддержка WebSocket
• Асинхронный

Минусы:

• Кривая обучения
• Нишевое применение

6. Сравнение фреймворков

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

class FrameworkChoice:
    """
    Мой выбор в зависимости от требований
    """
    
    choices = {
        'REST API с высокой нагрузкой': 'FastAPI',
        'Полноценное веб-приложение': 'Django',
        'Прототип или MVP': 'Flask',
        'Микросервис': 'FastAPI or Flask',
        'Real-time приложение (чаты, уведомления)': 'Tornado',
        'Асинхронные операции': 'FastAPI + Celery',
        'CMS или админ-панель': 'Django',
        'GraphQL API': 'FastAPI + Strawberry',
        'Очень простой скрипт': 'Flask',
        'High-load система': 'Tornado или aiohttp'
    }
    
    def current_preference(self):
        return {
            'primary': 'FastAPI для всего нового',
            'reason': [
                'Асинхронность по умолчанию',
                'Отличная документация (OpenAPI)',
                'Супер быстро',
                'Type hints поддержка',
                'Pydantic валидация'
            ],
            'fallback': 'Django для больших приложений',
            'secondary': 'Flask для быстрых прототипов'
        }

8. Экосистема и инструменты

# ORM для non-Django фреймворков
# SQLAlchemy - лучшая ORM в Python
from sqlalchemy import create_engine, Column, Integer, String
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)

# ORM для async (SQLAlchemy 2.0+)
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine

# Validation
# Pydantic для FastAPI
from pydantic import BaseModel, Field, validator

# Task queue
# Celery/RQ для любого фреймворка

# Authentication
# python-jose для JWT
from jose import JWTError, jwt
from passlib.context import CryptContext

Для нового проекта я почти всегда выбираю FastAPI, потому что это оптимальный баланс между простотой, производительностью и функциональностью.