Curso Django

Django es un framework web de alto nivel escrito en Python que permite el desarrollo rápido y limpio de aplicaciones web robustas. Creado en 2003 y liberado públicamente en 2005, Django sigue el principio "Don't Repeat Yourself" (DRY) y la filosofía de "Convention over Configuration", lo que significa que proporciona configuraciones sensatas por defecto mientras permite la personalización cuando es necesaria. El itinerario de este curso se mantiene alineado con la rama estable del framework y cada lección incorpora un diagrama visual pensado para formación presencial, documentación interna y LMS corporativos.

Filosofía

Django se construye sobre varios principios fundamentales que lo distinguen de otros frameworks web. El framework adopta el patrón arquitectónico Model-View-Template (MVT), una variación del tradicional Model-View-Controller que separa claramente la lógica de negocio, la presentación y el control de flujo de la aplicación.

La filosofía "batteries included" de Django significa que viene equipado con una amplia gama de funcionalidades integradas: un ORM (Object-Relational Mapping) sofisticado, un sistema de autenticación robusto, un panel de administración automático, herramientas de seguridad integradas, y un sistema de plantillas flexible. Esta aproximación permite a los desarrolladores concentrarse en la lógica específica de su aplicación en lugar de reimplementar funcionalidades comunes.

Arquitectura MVT

El patrón MVT de Django organiza el código en tres componentes principales que trabajan de manera coordinada. Los modelos definen la estructura de datos y encapsulan la lógica de negocio, actuando como la interfaz entre la aplicación y la base de datos. Las vistas procesan las peticiones HTTP, ejecutan la lógica necesaria y devuelven respuestas apropiadas. Las plantillas se encargan de la presentación, definiendo cómo se estructura y presenta la información al usuario final.

Esta separación de responsabilidades facilita el mantenimiento del código, permite el trabajo en equipo eficiente y hace que las aplicaciones sean más escalables y testeables. Cada componente puede desarrollarse y modificarse independientemente, lo que resulta especialmente valioso en proyectos grandes y complejos.

Django ORM

El ORM de Django constituye una de sus características más distintivas, proporcionando una abstracción de alto nivel sobre las operaciones de base de datos. Este sistema permite definir modelos de datos como clases Python, donde cada clase representa una tabla de base de datos y cada atributo corresponde a un campo.

from django.db import models

class Autor(models.Model):
    nombre = models.CharField(max_length=100)
    email = models.EmailField()
    fecha_nacimiento = models.DateField()

    def __str__(self):
        return self.nombre

class Libro(models.Model):
    titulo = models.CharField(max_length=200)
    autor = models.ForeignKey(Autor, on_delete=models.CASCADE)
    fecha_publicacion = models.DateField()
    isbn = models.CharField(max_length=13, unique=True)

El ORM traduce automáticamente las operaciones Python en consultas SQL optimizadas, soportando múltiples motores de base de datos como PostgreSQL, MySQL, SQLite y Oracle. Las migraciones gestionan automáticamente los cambios en el esquema de la base de datos, permitiendo evolucionar la estructura de datos de manera controlada y versionada.

Las relaciones entre modelos se definen de manera intuitiva mediante campos especiales como ForeignKey, ManyToManyField y OneToOneField, que Django traduce automáticamente en las restricciones y joins apropiados a nivel de base de datos. Las consultas avanzadas se realizan mediante la QuerySet API, que permite encadenar filtros, anotaciones y agregaciones de forma expresiva y eficiente.

Vistas y enrutamiento

Django ofrece un sistema de enrutamiento URL limpio y flexible basado en la función path() y el módulo re_path() para patrones más complejos. Las URLs se organizan en módulos mediante include(), lo que permite estructurar grandes aplicaciones de forma modular.

El framework proporciona dos aproximaciones principales para manejar las peticiones HTTP: vistas basadas en funciones y vistas basadas en clases. Las vistas basadas en funciones proporcionan un control directo y explícito sobre el procesamiento de peticiones, siendo ideales para lógica simple y específica.

from django.shortcuts import render, get_object_or_404
from django.http import JsonResponse

def detalle_libro(request, libro_id):
    libro = get_object_or_404(Libro, id=libro_id)
    return render(request, 'libros/detalle.html', {'libro': libro})

def buscar_libros(request):
    termino = request.GET.get('q', '')
    libros = Libro.objects.filter(titulo__icontains=termino)
    return render(request, 'libros/resultados.html', {'libros': libros})

Las vistas basadas en clases ofrecen una aproximación más estructurada y reutilizable, especialmente útil para operaciones CRUD comunes. Django proporciona vistas genéricas como ListView, DetailView, CreateView, UpdateView y DeleteView que encapsulan patrones frecuentes con configuración mínima.

Plantillas

El Django Template Language (DTL) proporciona un sistema de plantillas seguro y expresivo que separa claramente la lógica de presentación del código Python. Las plantillas utilizan una sintaxis simple pero potente que permite la inserción de datos dinámicos, estructuras de control y filtros de formateo.

<!-- libro_detalle.html -->
<div class="libro-detalle">
    <h1>{{ libro.titulo }}</h1>
    <p><strong>Autor:</strong> {{ libro.autor.nombre }}</p>
    <p><strong>Publicado:</strong> {{ libro.fecha_publicacion|date:"d/m/Y" }}</p>

    {% if libro.disponible %}
        <span class="disponible">Disponible</span>
    {% else %}
        <span class="no-disponible">No disponible</span>
    {% endif %}
</div>

El sistema de herencia de plantillas permite crear jerarquías de plantillas reutilizables, donde las plantillas base definen la estructura común y las plantillas derivadas especializan secciones específicas. Esta aproximación promueve la consistencia visual y facilita el mantenimiento de interfaces complejas.

Formularios

El sistema de formularios de Django proporciona una manera robusta de manejar la entrada de datos del usuario, incluyendo validación automática, generación de HTML y protección contra ataques comunes. Los formularios pueden definirse manualmente o generarse automáticamente a partir de modelos existentes.

from django import forms
from .models import Libro

class LibroForm(forms.ModelForm):
    class Meta:
        model = Libro
        fields = ['titulo', 'autor', 'fecha_publicacion', 'isbn']
        widgets = {
            'fecha_publicacion': forms.DateInput(attrs={'type': 'date'}),
            'titulo': forms.TextInput(attrs={'class': 'form-control'})
        }

    def clean_isbn(self):
        isbn = self.cleaned_data['isbn']
        if len(isbn) != 13:
            raise forms.ValidationError("El ISBN debe tener 13 dígitos")
        return isbn

La validación de formularios opera en múltiples niveles: validación de campo individual, validación cruzada entre campos y validación a nivel de modelo. Los formsets permiten gestionar múltiples instancias de un mismo formulario, ideal para editar colecciones de objetos relacionados.

Autenticación y autorización

Django incluye un sistema de autenticación completo que gestiona cuentas de usuario, grupos, permisos y sesiones. El modelo User incorporado puede extenderse mediante AbstractUser o AbstractBaseUser para adaptarse a las necesidades de cada proyecto. El sistema de permisos permite definir accesos granulares a nivel de modelo y objeto, mientras que los grupos facilitan la asignación colectiva de permisos.

Panel de administración

El admin de Django genera automáticamente una interfaz web de administración a partir de los modelos definidos. Esta interfaz es altamente personalizable mediante la clase ModelAdmin, que permite configurar la visualización de listados, filtros de búsqueda, formularios de edición, acciones en lote e inlines para modelos relacionados.

Django REST Framework

Django REST Framework (DRF) extiende Django para la creación de APIs REST robustas y escalables. Este framework adicional proporciona herramientas especializadas para la serialización de datos, autenticación de APIs, control de permisos y documentación automática.

from rest_framework import serializers, viewsets
from rest_framework.decorators import action
from rest_framework.response import Response

class LibroSerializer(serializers.ModelSerializer):
    autor_nombre = serializers.CharField(source='autor.nombre', read_only=True)

    class Meta:
        model = Libro
        fields = ['id', 'titulo', 'autor', 'autor_nombre', 'fecha_publicacion', 'isbn']

class LibroViewSet(viewsets.ModelViewSet):
    queryset = Libro.objects.all()
    serializer_class = LibroSerializer

    @action(detail=False, methods=['get'])
    def recientes(self, request):
        libros_recientes = Libro.objects.filter(
            fecha_publicacion__gte=timezone.now() - timedelta(days=30)
        )
        serializer = self.get_serializer(libros_recientes, many=True)
        return Response(serializer.data)

Los serializadores convierten automáticamente entre objetos Python complejos y formatos de datos como JSON, mientras que los ViewSets proporcionan un conjunto completo de operaciones CRUD con configuración mínima. El sistema de permisos y autenticación de DRF permite implementar esquemas de seguridad sofisticados, incluyendo autenticación por tokens, OAuth y JWT.

Middleware y señales

El sistema de middleware de Django permite procesar peticiones y respuestas de forma global, añadiendo funcionalidades transversales como seguridad, sesiones, autenticación y caché. Los middleware se ejecutan en un orden definido y pueden interceptar tanto las peticiones entrantes como las respuestas salientes.

Las señales proporcionan un mecanismo de comunicación desacoplado entre componentes de la aplicación. Señales como pre_save, post_save, pre_delete y post_delete permiten ejecutar lógica automáticamente cuando se producen determinados eventos en los modelos, sin necesidad de modificar el código original.

Seguridad integrada

Django incorpora protecciones de seguridad por defecto contra las vulnerabilidades web más comunes. La protección CSRF (Cross-Site Request Forgery) se activa automáticamente en formularios, mientras que el sistema de plantillas escapa automáticamente las variables para prevenir ataques XSS (Cross-Site Scripting).

El framework incluye protecciones contra inyección SQL mediante el uso de consultas parametrizadas en el ORM, y proporciona herramientas para implementar cabeceras de seguridad como HSTS, X-Content-Type-Options y X-Frame-Options a través de su middleware de seguridad. La rama estable actual también permite definir Content Security Policy (CSP) con SECURE_CSP, ContentSecurityPolicyMiddleware y nonces en plantillas, algo especialmente útil en auditorías y despliegues corporativos.

Testing

Django incluye un framework de testing integrado basado en unittest de Python, ampliado con herramientas específicas para aplicaciones web. La clase TestCase proporciona una base de datos de prueba aislada, un cliente HTTP simulado y assertions especializados para verificar respuestas HTTP, redirecciones, plantillas utilizadas y contenido renderizado.

Despliegue y operación

Django soporta despliegue WSGI (por ejemplo Gunicorn) y ASGI para cargas concurrentes o integración con el ecosistema asíncrono. El marco de tareas en segundo plano estandariza cómo encolar trabajo fuera de la petición HTTP, mientras que los workers siguen siendo parte de tu plataforma (Kubernetes, colas, procesos dedicados). La gestión de archivos estáticos en producción usa collectstatic con Nginx, CDN o WhiteNoise. Docker y docker-compose siguen siendo el estándar de facto para entornos reproducibles en equipos y empresas.

Capacidades recientes relevantes para empresas

La rama estable actual incorpora, entre otras cosas, Content Security Policy integrada (SECURE_CSP, ContentSecurityPolicyMiddleware), partials en el lenguaje de plantillas ({% partialdef %}, {% partial %}) y un framework de tareas (django.tasks) para separar el encolado de la ejecución. El curso las cubre en el módulo final dedicado como parte del stack moderno de proyectos Django.