Tutorial paso a paso para crear un blog básico con Django y Python
¡Bienvenido a este tutorial Django para principiantes! Aquí aprenderás, paso a paso, cómo crear un blog básico utilizando Python y el framework Django, ideal para quienes están comenzando en el desarrollo web con Django y programación Python para principiantes.
¿Qué aprenderás en este tutorial?
- Configurar el entorno de desarrollo para Django
- Crear un proyecto Django desde cero
- Definir modelos para la base de datos
- Crear vistas que gestionen la lógica
- Construir plantillas HTML para la presentación
- Implementar funcionalidades para publicar, editar y eliminar entradas en el blog
¡Empecemos!
Configuración del entorno de desarrollo
Antes de escribir código, debemos preparar nuestro entorno.
1. Instalar Python
Asegúrate de tener instalado Python 3. En terminal o consola, verifica con:
|
1 2 3 4 |
python --version # o python3 --version |
Si no lo tienes, descárgalo desde python.org.
2. Crear un entorno virtual
Un entorno virtual mantiene nuestras librerías aisladas.
|
1 2 3 4 5 6 7 8 9 10 |
# Crear entorno virtual llamado 'env' python -m venv env # Activar entorno virtual # En Windows env\Scripts\activate # En macOS/Linux source env/bin/activate |
3. Instalar Django
Con el entorno virtual activo, instala Django:
|
1 2 |
pip install django |
Verifica la instalación:
|
1 2 |
django-admin --version |
Crear un proyecto Django
Ahora que tienes Django, crea el proyecto que contendrá tu blog.
|
1 2 3 |
django-admin startproject mi_blog cd mi_blog |
El comando crea una carpeta mi_blog con la estructura básica.
Ejecutar el servidor de desarrollo
Prueba que todo funciona:
|
1 2 |
python manage.py runserver |
Abre tu navegador y ve a http://127.0.0.1:8000/. Verás la página de bienvenida de Django.
Crear una aplicación para el blog
Django organiza funcionalidad en aplicaciones. Creamos una para gestionar el blog.
|
1 2 |
python manage.py startapp blog |
Añade la app a la configuración en mi_blog/settings.py, en la lista INSTALLED_APPS:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
INSTALLED_APPS = [ # apps por defecto 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', # nuestra app de blog 'blog', ] |
Definir los modelos de datos
El modelo define la estructura de nuestra base de datos. Para un blog básico, necesitamos un modelo Entrada con campos como título, contenido, fecha y autor.
Abre blog/models.py y escribe:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
from django.db import models from django.utils import timezone class Entrada(models.Model): titulo = models.CharField(max_length=200) # Campo para título contenido = models.TextField() # Texto principal del post fecha_creacion = models.DateTimeField(default=timezone.now) # Fecha y hora de creación fecha_publicacion = models.DateTimeField(blank=True, null=True) # Fecha de publicación def publicar(self): self.fecha_publicacion = timezone.now() self.save() def __str__(self): return self.titulo |
Explicación
CharField: para cadenas cortasTextField: para textos largosDateTimeField: para fechas y horasdef publicar: método para asignar fecha de publicación__str__: para mostrar el título en el admin o consola
Migrar modelos para crear tablas en la base de datos
Django utiliza migraciones para modificar la base de datos.
Ejecuta:
|
1 2 3 |
python manage.py makemigrations blog python manage.py migrate |
Esto crea las tablas de la base de datos para tu blog.
Crear vistas para manejar las solicitudes
Ahora, crearemos vistas para mostrar y gestionar las entradas.
Abre blog/views.py y añade:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
from django.shortcuts import render, get_object_or_404, redirect from django.utils import timezone from .models import Entrada from .forms import EntradaForm # Vista que lista todas las entradas publicadas def lista_entradas(request): entradas = Entrada.objects.filter(fecha_publicacion__lte=timezone.now()).order_by('-fecha_publicacion') return render(request, 'blog/lista_entradas.html', {'entradas': entradas}) # Vista de detalle de una entrada def detalle_entrada(request, pk): entrada = get_object_or_404(Entrada, pk=pk) return render(request, 'blog/detalle_entrada.html', {'entrada': entrada}) # Crear una nueva entrada def nueva_entrada(request): if request.method == 'POST': form = EntradaForm(request.POST) if form.is_valid(): entrada = form.save(commit=False) # Para publicación directa se puede activar la siguiente línea # entrada.publicar() entrada.save() return redirect('detalle_entrada', pk=entrada.pk) else: form = EntradaForm() return render(request, 'blog/editar_entrada.html', {'form': form}) # Editar una entrada existente def editar_entrada(request, pk): entrada = get_object_or_404(Entrada, pk=pk) if request.method == 'POST': form = EntradaForm(request.POST, instance=entrada) if form.is_valid(): entrada = form.save(commit=False) entrada.save() return redirect('detalle_entrada', pk=entrada.pk) else: form = EntradaForm(instance=entrada) return render(request, 'blog/editar_entrada.html', {'form': form}) # Eliminar una entrada def eliminar_entrada(request, pk): entrada = get_object_or_404(Entrada, pk=pk) if request.method == 'POST': entrada.delete() return redirect('lista_entradas') return render(request, 'blog/eliminar_entrada.html', {'entrada': entrada}) |
Explicación
render: para devolver páginas HTMLget_object_or_404: buscar objeto o error 404redirect: redireccionar a otras vistas- Vistas para listar, detalle, crear, editar y eliminar
Crear formularios para crear y editar entradas
Django utiliza formularios para manejar datos de entrada.
Crea blog/forms.py con el siguiente contenido:
|
1 2 3 4 5 6 7 8 |
from django import forms from .models import Entrada class EntradaForm(forms.ModelForm): class Meta: model = Entrada fields = ('titulo', 'contenido',) |
Este formulario usa el modelo Entrada e incluirá los campos título y contenido.
Crear las plantillas HTML
Crea una carpeta templates/blog dentro de la carpeta blog.
1. Lista de entradas (lista_entradas.html)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
<!-- templates/blog/lista_entradas.html --> <!DOCTYPE html> <html lang="es"> <head> <meta charset="UTF-8"> <title>Blog - Lista de entradas</title> </head> <body> <h1>Blog - Entradas publicadas</h1> <a href="{% url 'nueva_entrada' %}">Nueva entrada</a> <ul> {% for entrada in entradas %} <li> <a href="{% url 'detalle_entrada' entrada.pk %}">{{ entrada.titulo }}</a> - {{ entrada.fecha_publicacion|date:"d M Y H:i" }} </li> {% empty %} <li>No hay entradas publicadas.</li> {% endfor %} </ul> </body> </html> |
2. Detalle de entrada (detalle_entrada.html)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
<!-- templates/blog/detalle_entrada.html --> <!DOCTYPE html> <html lang="es"> <head> <meta charset="UTF-8"> <title>{{ entrada.titulo }}</title> </head> <body> <h1>{{ entrada.titulo }}</h1> <p><em>Publicado el {{ entrada.fecha_publicacion|date:"d M Y H:i" }}</em></p> <div> {{ entrada.contenido|linebreaksbr }} </div> <a href="{% url 'editar_entrada' entrada.pk %}">Editar</a> | <a href="{% url 'eliminar_entrada' entrada.pk %}">Eliminar</a> | <a href="{% url 'lista_entradas' %}">Volver a la lista</a> </body> </html> |
3. Formulario para crear/editar (editar_entrada.html)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
<!-- templates/blog/editar_entrada.html --> <!DOCTYPE html> <html lang="es"> <head> <meta charset="UTF-8"> <title>{% if form.instance.pk %}Editar{% else %}Nueva{% endif %} entrada</title> </head> <body> <h1>{% if form.instance.pk %}Editar{% else %}Nueva{% endif %} entrada</h1> <form method="post"> {% csrf_token %} {{ form.as_p }} <button type="submit">Guardar</button> </form> <a href="{% url 'lista_entradas' %}">Cancelar</a> </body> </html> |
4. Confirmación de eliminación (eliminar_entrada.html)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
<!-- templates/blog/eliminar_entrada.html --> <!DOCTYPE html> <html lang="es"> <head> <meta charset="UTF-8"> <title>Eliminar entrada</title> </head> <body> <h1>Eliminar: {{ entrada.titulo }}</h1> <p>¿Estás seguro de eliminar esta entrada?</p> <form method="post"> {% csrf_token %} <button type="submit">Confirmar eliminación</button> </form> <a href="{% url 'detalle_entrada' entrada.pk %}">Cancelar</a> </body> </html> |
Configurar URLs
Para conectar nuestras vistas, definiremos URLs.
1. Crear archivo blog/urls.py:
|
1 2 3 4 5 6 7 8 9 10 11 |
from django.urls import path from . import views urlpatterns = [ path('', views.lista_entradas, name='lista_entradas'), path('entrada/<int:pk>/', views.detalle_entrada, name='detalle_entrada'), path('entrada/nueva/', views.nueva_entrada, name='nueva_entrada'), path('entrada/<int:pk>/editar/', views.editar_entrada, name='editar_entrada'), path('entrada/<int:pk>/eliminar/', views.eliminar_entrada, name='eliminar_entrada'), ] |
2. Incluir URLs del blog en las URLs del proyecto mi_blog/urls.py:
|
1 2 3 4 5 6 7 8 |
from django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('', include('blog.urls')), ] |
Probar la aplicación
Ejecuta el servidor:
|
1 2 |
python manage.py runserver |
Entra a http://127.0.0.1:8000/ para ver la lista de entradas. Puedes crear, editar, ver y eliminar blogs.
Buenas prácticas y próximos pasos
- Seguridad: Implementa autenticación para que solo usuarios autorizados puedan publicar o editar.
- Estilo: Usa CSS para mejorar el diseño.
- Optimización: Añade paginación o búsqueda en las entradas.
- Despliegue: Prueba a subir tu blog a plataformas como Heroku o PythonAnywhere.
Conclusión
¡Felicidades! Has aprendido a crear un blog básico usando Django y Python.
Este tutorial Django te introdujo a:
- Configuración del entorno
- Creación de proyectos y apps
- Modelos, vistas y plantillas
- Funcionalidades CRUD para entradas
Sigue practicando para profundizar en el desarrollo web con Django y mejorar tus habilidades en programación Python para principiantes.
¿Quieres seguir avanzando? Considera explorar tutoriales sobre autenticación de usuarios, despliegue web y optimización SEO para Django.
¡Comienza tu aventura en el mundo del desarrollo web con Django hoy mismo!
