Django: Ventajas, Inconvenientes y Buenas Prácticas

Introducción a Django

Django es un framework web de alto nivel para Python que fomenta el desarrollo rápido y el diseño limpio. Sigue el principio "baterías incluidas", proporcionando muchas herramientas y funcionalidades listas para usar.

Ventajas de Django

• Baterías incluidas: Admin panel, ORM, autenticación, y mucho más incluido.
• Seguridad: Protección CSRF, XSS, SQL injection, y otras vulnerabilidades por defecto.
• Escalabilidad: Usado por Instagram, Spotify, y otras aplicaciones de gran escala.
• Comunidad activa: Gran ecosistema de paquetes y documentación extensa.
• ORM potente: Sistema de base de datos abstracto y migraciones automáticas.
• Admin automático: Panel de administración generado automáticamente.

Inconvenientes de Django

• Curva de aprendizaje: Más complejo que frameworks más simples como Flask.
• Menos flexibilidad: Estructura más rígida, menos libertad en la organización.
• Overhead: Puede ser excesivo para proyectos muy pequeños o APIs simples.
• Monolítico: Todo está acoplado, aunque puedes desactivar lo que no uses.

Cómo empezar con Django

Paso 1: Instalación

# Crear entorno virtual
python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate

# Instalar Django
pip install django

# Verificar instalación
django-admin --version

Paso 2: Crear un proyecto

# Crear proyecto
django-admin startproject mi_proyecto

# Estructura creada
mi_proyecto/
├── manage.py
├── mi_proyecto/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py

Paso 3: Crear una aplicación

# Desde el directorio del proyecto
python manage.py startapp mi_app

# Estructura de la app
mi_app/
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── views.py
├── tests.py
└── migrations/

Paso 4: Configuración inicial

En settings.py:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'mi_app',  # Tu aplicación
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mi_base_datos',
        'USER': 'usuario',
        'PASSWORD': 'contraseña',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

# Configuración de seguridad
SECRET_KEY = os.environ.get('SECRET_KEY')
DEBUG = os.environ.get('DEBUG', 'False') == 'True'
ALLOWED_HOSTS = ['tu-dominio.com', 'www.tu-dominio.com']

Paso 5: Crear modelos

# mi_app/models.py
from django.db import models
from django.utils import timezone

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey('auth.User', on_delete=models.CASCADE)
    created_at = models.DateTimeField(default=timezone.now)
    published = models.BooleanField(default=False)

    class Meta:
        ordering = ['-created_at']

    def __str__(self):
        return self.title

Paso 6: Migraciones

# Crear migraciones
python manage.py makemigrations

# Aplicar migraciones
python manage.py migrate

# Crear superusuario
python manage.py createsuperuser

Buenas prácticas en Django

1. Estructura del proyecto

proyecto/
├── manage.py
├── proyecto/
│   ├── settings/
│   │   ├── __init__.py
│   │   ├── base.py
│   │   ├── development.py
│   │   └── production.py
│   ├── urls.py
│   └── wsgi.py
├── apps/
│   ├── mi_app/
│   └── otra_app/
├── static/
├── media/
└── templates/

2. Separar settings por entorno

# settings/base.py
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent.parent

# settings/development.py
from .base import *
DEBUG = True
ALLOWED_HOSTS = ['localhost', '127.0.0.1']

# settings/production.py
from .base import *
DEBUG = False
ALLOWED_HOSTS = ['tu-dominio.com']
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True

3. Usar Class-Based Views

from django.views.generic import ListView, DetailView, CreateView
from django.contrib.auth.mixins import LoginRequiredMixin

class PostListView(ListView):
    model = Post
    template_name = 'posts/list.html'
    context_object_name = 'posts'
    paginate_by = 10

class PostDetailView(DetailView):
    model = Post
    template_name = 'posts/detail.html'

class PostCreateView(LoginRequiredMixin, CreateView):
    model = Post
    fields = ['title', 'content']
    template_name = 'posts/create.html'
    
    def form_valid(self, form):
        form.instance.author = self.request.user
        return super().form_valid(form)

4. Optimización de consultas

# Mal: N+1 queries
posts = Post.objects.all()
for post in posts:
    print(post.author.username)  # Query por cada post

# Bien: Usar select_related o prefetch_related
posts = Post.objects.select_related('author').all()
for post in posts:
    print(post.author.username)  # Sin queries adicionales

5. Seguridad

• Nunca hardcodees SECRET_KEY: Usa variables de entorno.
• DEBUG=False en producción: Nunca dejes DEBUG activado.
• Usa HTTPS: Configura SSL/TLS en producción.
• Valida datos: Usa forms y serializers para validar entrada.
• Protección CSRF: Django lo incluye, pero asegúrate de usarlo.

6. Testing

# mi_app/tests.py
from django.test import TestCase, Client
from django.contrib.auth import get_user_model
from .models import Post

User = get_user_model()

class PostModelTest(TestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpass123'
        )

    def test_post_creation(self):
        post = Post.objects.create(
            title='Test Post',
            content='Test content',
            author=self.user
        )
        self.assertEqual(str(post), 'Test Post')
        self.assertTrue(post.created_at)

class PostViewTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            username='testuser',
            password='testpass123'
        )

    def test_post_list_view(self):
        response = self.client.get('/posts/')
        self.assertEqual(response.status_code, 200)

Comparación: Django vs Flask

Conclusión

Django es una excelente opción para proyectos que requieren funcionalidades completas desde el inicio. Su filosofía "baterías incluidas" acelera el desarrollo y su enfoque en seguridad lo hace ideal para aplicaciones empresariales. Si necesitas más control y flexibilidad, Flask puede ser mejor opción, pero para la mayoría de aplicaciones web modernas, Django ofrece una base sólida y productiva.