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.

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 testeable. 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.

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.

Vistas

Django ofrece 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 que encapsulan patrones frecuentes como listados, detalles, creación y actualización de objetos.

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. Este sistema multicapa garantiza la integridad de los datos antes de su persistencia en la base de datos.

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.

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 autenticación y autorización granular. El sistema de middleware permite añadir capas adicionales de seguridad de manera modular y reutilizable.