Guía de Django Nivel Medio: ORM, Vistas, Plantillas y Admin por Santiago Soñora

“Hola, mundo” en Django

Un proyecto básico de Django que responde con 'Hola, mundo' en la URL raíz, mostrando la interacción entre urls y views.

📋 Copiar

# En mi_app/views.py
from django.http import HttpResponse

def hola_mundo(request):
    return HttpResponse("Hola, mundo")

# En mi_proyecto/urls.py
from django.urls import path
from mi_app import views

urlpatterns = [
    path('', views.hola_mundo, name='inicio'),
]

Resultado:

Output

Hola, mundo (mostrado en http://localhost:8000 en la ruta raíz)

Comandos básicos

Familiarizarse con estos comandos es esencial para interactuar eficientemente con Django:

Instalar Django
📋 Copiar
```
pip install Django
```
Instala el framework Django junto con sus dependencias principales usando pip. Se recomienda hacerlo en un entorno virtual.
Congelar dependencias en archivo
📋 Copiar
```
pip freeze > requirements.txt
```
Genera un archivo `requirements.txt` con todas las bibliotecas instaladas en el entorno virtual actual, con sus versiones exactas.
Crear un nuevo proyecto
📋 Copiar
```
django-admin startproject nombre_proyecto .
```
Genera la estructura inicial de un proyecto Django en el directorio actual.
Crear una nueva aplicación
📋 Copiar
```
python manage.py startapp nombre_app
```
Crea una nueva aplicación (`app`) dentro del proyecto Django con la estructura de directorios estándar (models, views, urls, admin, etc.).
Ejecutar el servidor de desarrollo
📋 Copiar
```
python manage.py runserver
```
Inicia el servidor web ligero de Django para probar la aplicación localmente. Por defecto en http://localhost:8000/.

Crear modelos

📋 Copiar

# En mi_app/models.py
from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    pub_date = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

Define un modelo `Post` que mapea a una tabla en la base de datos, con campos y sus tipos de datos.

Crear migraciones
📋 Copiar
```
python manage.py makemigrations
```
Genera los archivos de migración (`.py`) que describen los cambios necesarios en la base de datos para reflejar los modelos actuales.
Aplicar migraciones a la base de datos
📋 Copiar
```
python manage.py migrate
```
Ejecuta las migraciones pendientes para aplicar los cambios al esquema de la base de datos. Incluye las migraciones iniciales de Django (auth, admin, etc.).
Crear superusuario (Admin)
📋 Copiar
```
python manage.py createsuperuser
```
Crea una cuenta de usuario con permisos de administrador para acceder al panel de administración de Django.
Usar el Shell Interactivo con ORM
📋 Copiar
```
python manage.py shell
# Dentro del shell:
from mi_app.models import Post
Post.objects.create(title='Mi Primer Post', content='Hola Mundo')
print(Post.objects.all())
```
Inicia un shell interactivo de Python con el entorno de Django cargado, permitiendo interactuar con los modelos y el ORM directamente.

Crear una Vista Basada en Clase (CBV)

📋 Copiar

# En mi_app/views.py
from django.views.generic import ListView
from .models import Post

class PostListView(ListView):
    model = Post
    template_name = 'mi_app/post_list.html' # Especifica la plantilla
    context_object_name = 'posts' # Nombre de la variable en la plantilla

Define una vista utilizando una Clase Basada en Vista genérica (`ListView`) para mostrar una lista de objetos de un modelo.

Mapear URL a CBV

📋 Copiar

# En mi_app/urls.py
from django.urls import path
from .views import PostListView

urlpatterns = [
    path('posts/', PostListView.as_view(), name='lista-posts'),
]

Asocia una URL específica ('/posts/') a una Vista Basada en Clase, usando el método `.as_view()`.

Crear un Formulario basado en un Modelo (ModelForm)
📋 Copiar
```
# En mi_app/forms.py
from django import forms
from .models import Post

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ['title', 'content'] # Campos a incluir
```
Define una clase Formulario (`PostForm`) que se genera automáticamente a partir del modelo `Post`, facilitando la creación de formularios para editar o crear objetos del modelo.
Configurar URL para archivos estáticos
📋 Copiar
```
# En settings.py
STATIC_URL = '/static/'

# En template.html
{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">
```
Define la URL base para servir archivos estáticos (CSS, JS, imágenes del diseño) y cómo referenciarlos en las plantillas usando el tag `static`.
Configurar URL y directorio para archivos de medios
📋 Copiar
```
# En settings.py
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'
```
Define la URL base para acceder a archivos subidos por los usuarios (`MEDIA_URL`) y el directorio físico donde se guardarán en el servidor (`MEDIA_ROOT`).

Incluir URLs de una aplicación

📋 Copiar

# En urls.py principal (mi_proyecto/urls.py)
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('mi_app.urls')), # Incluye URLs de mi_app
]

Incluye todos los patrones de URL definidos en el archivo `urls.py` de la aplicación `mi_app` bajo la ruta base '/blog/'.

Conceptos Clave

Comprender estos conceptos fundamentales te ayudará a dominar Django de forma más organizada y eficiente:

Arquitectura MVT (Model-View-Template):

Entender cómo Django estructura las aplicaciones y el flujo de una petición: el Model (ORM) interactúa con la base de datos; la View (la lógica de negocio) procesa la petición y prepara datos; y la Template (Jinja2 por defecto, DTL) renderiza la respuesta HTML al usuario. Aunque se le llama MVT, a menudo se mapea al patrón MVC.
Django ORM (Object-Relational Mapper):

El sistema de Django para interactuar con la base de datos relacional utilizando objetos Python en lugar de escribir SQL. Define modelos (`models.Model`) que representan tablas y utiliza QuerySets (`.objects.all()`, `.filter()`, `.get()`, `.create()`, `.update()`, `.delete()`) para realizar operaciones de base de datos.
URL Routing (URLs):

Definir los patrones de URL que la aplicación reconocerá y asociarlos a las vistas (handlers) que deben procesar esas peticiones. Uso de la función `path()`, expresiones regulares (`re_path`), rutas dinámicas con tipos de convertidores (int, slug, uuid, path), nombres de URL (`name=`) para referenciarlas fácilmente y la función `include()` para modularizar rutas por aplicación.
Vistas (Function-Based Views vs Class-Based Views):

La lógica principal que recibe una petición HTTP y retorna una respuesta (típicamente renderizando una plantilla). Entender la diferencia entre vistas basadas en funciones (simples y directas) y las potentes Vistas Basadas en Clases (CBVs) genéricas que abstraen tareas comunes (mostrar listas, detalles, crear, actualizar, eliminar objetos) con menos código repetitivo.
Django Template Language (DTL):

El motor de plantillas predeterminado de Django (aunque se puede usar Jinja2). Aprender su sintaxis simple para mostrar variables (`{{ variable }}`), utilizar tags para lógica de control (bucles `{% for %}`, condicionales `{% if %}`, herencia de plantillas `{% extends %}`, `{% block %}`) y filtros para transformar datos (`{{ variable|filter_name }}`).
Sistema de Formularios:

El robusto sistema de Django para crear, procesar y validar formularios HTML. Define la estructura de los campos y sus reglas de validación en clases `forms.Form` o, más comúnmente para interactuar con la base de datos, `forms.ModelForm`.
Sistema de Autenticación Integrado:

Django viene con un sistema completo para manejar el registro de usuarios, login, logout, gestión de sesiones y permisos. Incluye modelos de usuario (`User`), vistas y URL's predefinidas que se pueden integrar o personalizar.
Django Admin Site:

Un panel de administración autogenerado que permite a los usuarios con permisos (ej: superusuario) gestionar los datos de los modelos a través de una interfaz web amigable. Es altamente personalizable y una herramienta poderosa para la gestión de contenido.
Archivos Estáticos y Archivos de Medios:

Comprender la diferencia: los archivos estáticos (CSS, JavaScript, imágenes del diseño del sitio) son parte de la aplicación y se gestionan con `STATIC_URL`/`STATIC_ROOT`. Los archivos de medios son archivos subidos por los usuarios (imágenes de perfil, documentos) y se gestionan con `MEDIA_URL`/`MEDIA_ROOT`. La configuración para servirlos en desarrollo vs. producción es diferente.
QuerySets:

Los QuerySets son objetos que representan una colección de objetos recuperados de la base de datos (o que serán recuperados). Son 'perezosos' (lazy): la consulta a la base de datos no se ejecuta hasta que se evalúa el QuerySet (ej: al iterar sobre él, al convertirlo a lista, al acceder a un elemento). Aprender a encadenar métodos de QuerySet (`.filter()`, `.order_by()`, `.annotate()`, etc.) es clave para usar el ORM eficazmente.
Signals (Concepto):

El framework de Signals permite que remitentes (sender) notifiquen a un conjunto de receptores (receiver) cuando ocurre cierta acción. Es útil para desacoplar código, ejecutando lógica adicional en respuesta a eventos (ej: después de que un objeto se guarda, antes de que se elimina).

Casos de uso

Algunos ejemplos de aplicaciones prácticas donde se utiliza Django:

Construcción de un blog o sitio de noticias completo con gestión de contenido y usuarios:

Implementar modelos para posts, comentarios, categorías; vistas para listar, mostrar detalles y permitir comentarios; URLs amigables; usar DTL para el frontend; y aprovechar el admin para gestionar publicaciones y usuarios.
Desarrollo de una aplicación de comercio electrónico simple con catálogo y carrito:

Modelar productos, categorías, pedidos, ítems del carrito; usar el ORM para consultas de productos y gestión de pedidos; vistas para el catálogo, detalle de producto y carrito; formularios para checkout y manejo de direcciones.
Implementación completa de un sistema de registro, login, logout y gestión de perfiles de usuario:

Utilizar el sistema de autenticación integrado de Django, crear formularios de registro y login, proteger vistas con decoradores (`@login_required`) o mixins de CBVs, y desarrollar vistas para mostrar y editar perfiles de usuario.
Creación de un panel de administración personalizado para gestionar diferentes tipos de datos:

Registrar modelos en el admin, personalizar la visualización de listas (`list_display`), añadir filtros (`list_filter`), campos de búsqueda (`search_fields`), y acciones personalizadas (`actions`) para facilitar la gestión de datos por parte de los administradores.
Desarrollo de APIs RESTful robustas con Django REST Framework (DRF):

Aunque es una biblioteca externa, DRF es el estándar para crear APIs con Django. Permite crear serializadores para representar datos de modelos, vistas basadas en clases para endpoints API y manejar autenticación/permisos específicos para APIs.
Gestión y servicio de archivos subidos por los usuarios (imágenes, documentos):

Configurar `MEDIA_URL` y `MEDIA_ROOT`, añadir campos de archivo o imagen a los modelos, y configurar URLs y vistas para permitir a los usuarios subir archivos y servirlos correctamente.
Integración con servicios de terceros (ej: envío de correos electrónicos, APIs externas):

Utilizar las funciones de Django para el envío de correo (`django.core.mail`) o bibliotecas de Python (`requests`) para interactuar con APIs externas dentro de tus vistas o tareas de backend.

Consejos para Principiantes

Aquí tienes algunas recomendaciones para facilitar tus inicios en Django:

Entiende el Flujo MVT:

Visualiza cómo una petición viaja a través de las URL's hacia una Vista, interactúa con los Modelos (ORM) si es necesario, y usa las Plantillas (DTL) para generar la respuesta. Este flujo es fundamental para trabajar con Django.
Domina el ORM y los QuerySets:

Invierte tiempo en aprender a usar el ORM para realizar todas las operaciones de base de datos (CRUD, consultas complejas con `.filter()`, `.exclude()`, `.annotate()`, `.aggregate()`). Evita el SQL crudo siempre que sea posible.
Usa Vistas Basadas en Clases (CBVs) para tareas comunes:

Una vez que entiendas el flujo básico, adopta las CBVs genéricas (`ListView`, `DetailView`, `CreateView`, `UpdateView`, `DeleteView`). Te ahorrarán mucho código repetitivo para las funcionalidades básicas CRUD.
Familiarízate con el Lenguaje de Plantillas de Django (DTL):

Aprende a usar variables, tags (`{% %}`) y filtros (`{{ | }}`). La herencia de plantillas (`{% extends %}`, `{% block %}`) es esencial para crear un diseño web consistente y reutilizable.
Aprovecha al máximo el Django Admin Site:

El panel de administración es una herramienta súper potente para gestionar tus datos rápidamente. Aprende a registrar tus modelos (`admin.site.register()`) y a personalizar cómo se muestran y editan (`ModelAdmin`).
Gestiona Correctamente Archivos Estáticos y de Medios:

Configura `STATIC_URL`, `STATIC_ROOT`, `MEDIA_URL` y `MEDIA_ROOT`. Entiende cómo se recolectan (`collectstatic`) y se sirven en desarrollo vs. producción. Es una fuente común de problemas para principiantes.
Escribe Tests Automatizados (Modelos, Vistas, Formularios):

Django facilita la escritura de pruebas. Acostúmbrate a escribir tests para tus modelos, vistas y formularios. Te ahorrará tiempo a largo plazo y garantizará la fiabilidad de tu código.
Lee la Documentación Oficial de Django:

La documentación es excelente, completa y bien organizada. Es tu recurso principal para aprender sobre todas las características de Django y resolver dudas.
Utiliza Entornos Virtuales (¡Fundamental!):

Siempre trabaja en un entorno virtual para aislar las dependencias de tu proyecto Django y evitar conflictos.
Empieza con el Tutorial Oficial de Django:

Si recién estás empezando, sigue el tutorial oficial paso a paso. Te guiará a través de los conceptos básicos de MVT, ORM, URLs y Vistas.

Herramientas relacionadas

Si te interesa Django, también podrías explorar estas herramientas:

Recursos útiles

Amplía tus conocimientos con estos enlaces y materiales: