Introducción a las vistas de Django
Las vistas son fundamentales en el patrón de arquitectura de Django, y comprender bien cómo trabajar con ellas es esencial para cualquier desarrollador que trabaje con este marco de trabajo. Si es nuevo en el desarrollo de aplicaciones web con Django o simplemente necesita un repaso de las vistas, siga leyendo.
Comprender mejor las vistas le ayudará a progresar más rápidamente en su proyecto Django. Tanto si trabaja en el backend de una API como en los flujos de una interfaz de usuario web, saber utilizar las vistas es crucial.
Siga leyendo para descubrir qué son las vistas de Django, sus diferentes tipos, las mejores prácticas para trabajar con ellas y ejemplos de usos.
¿Qué son las vistas de Django?
Las vistas son un componente esencial del patrón de arquitectura MTV (modelo-plantilla-vista) de Django. Esencialmente actúan como intermediarias entre modelos y plantillas, procesando las solicitudes de los usuarios y devolviendo las respuestas.
Es posible que se haya encontrado con vistas en el patrón MVC (modelo-vista-controlador). Sin embargo, estas son ligeramente diferentes de las vistas en Django y no se corresponden exactamente. Las vistas de Django son esencialmente controladores en MVC, mientras que las plantillas de Django se alinean aproximadamente con las vistas en MVC. Por ello es vital comprender los matices de las vistas de Django, incluso si está familiarizado con las vistas en el contexto de MVC.
Las vistas forman parte de la interfaz de usuario en Django, y manejan la lógica y el procesamiento de datos para las solicitudes web realizadas a sus aplicaciones y sitios basados en Django. Convierten sus plantillas en lo que el usuario ve cuando consulta su página web. Cada vista basada en funciones o clases toma la solicitud de un usuario, obtiene los datos de sus modelos, aplica la lógica empresarial o el procesamiento de datos y, a continuación, prepara y devuelve una respuesta HTTP a una plantilla.
Esta respuesta puede ser cualquier cosa que pueda mostrar un navegador web y suele ser una página web HTML. Sin embargo, las vistas de Django también pueden presentar imágenes, documentos XML, redirecciones, páginas de error y mucho más.
Renderizado y paso de datos a plantillas
Django cuenta con el acceso directo render() para simplificar la renderización de plantillas desde dentro de las vistas. El uso de render() ayuda a evitar el código repetitivo para cargar la plantilla y crear la respuesta manualmente.
PyCharm ofrece una finalización de código inteligente que sugiere automáticamente la función render() de django.shortcuts cuando comienza a escribirla en sus vistas. También reconoce los nombres de las plantillas y proporciona finalización automática para las rutas de las plantillas, lo que le ayuda a evitar erratas y errores.
El usuario proporciona la solicitud, el nombre de la plantilla y un diccionario de contexto, que ofrece datos para la plantilla. Una vez obtenidos los datos necesarios, la vista los pasa a la plantilla, donde se pueden renderizar y presentar al usuario.
from django.shortcuts import render
def my_view(request):
# Some business logic to obtain data
data_to_pass = {'variable1': 'value1', 'variable2': 'value2'}
# Pass the data to the template
return render(request, 'my_template.html', context=data_to_pass)
En este ejemplo, data_to_pass es un diccionario que contiene los datos que desea enviar a la plantilla. A continuación, se utiliza la función render para renderizar la plantilla (my_template.html) con los datos de contexto proporcionados.
Ahora, en su plantilla (my_template.html), puede acceder a los datos y mostrarlos.
{{ variable1 }}
{{ variable2 }}
En la plantilla se utilizan llaves dobles ({{ }}) para indicar las variables, que se sustituirán por los valores de los datos contextuales pasados por la vista.
PyCharm ofrece completado y resaltado de sintaxis para etiquetas de plantilla, variables y bucles de Django. También proporciona un análisis lint en el editor para los errores más comunes. Esto le permite centrarse en la creación de vistas y el manejo de la lógica, en lugar de perder tiempo rellenando manualmente los elementos de la plantilla o depurando errores comunes.
Vistas basadas en funciones
Django presenta dos tipos de vistas: vistas basadas en funciones y vistas basadas en clases.
Las vistas basadas en funciones se crean utilizando funciones sencillas de Python y suelen dividirse en cuatro categorías básicas: crear, leer, actualizar y eliminar (create, read, update, and delete, CRUD). Esta es la base de cualquier marco de trabajo en desarrollo. Reciben una solicitud HTTP y devuelven una respuesta HTTP.
from django.http import HttpResponse
def my_view(request):
# View logic goes here
context = {"message": "Hello world"}
return HttpResponse(render(request, "mytemplate.html", context))
Este fragmento maneja la lógica de la vista, prepara un diccionario de contexto para pasar datos a una plantilla que se renderiza y devuelve el HTML final de la plantilla en un objeto de respuesta.
Las vistas basadas en funciones son sencillas y directas. La lógica está contenida en una única función de Python en lugar de repartirse entre los métodos de una clase, lo que las hace más adecuadas para usos con un procesamiento mínimo.
PyCharm le permite generar automáticamente la estructura def my_view(request) utilizando plantillas activas. Las plantillas activas son fragmentos de código predefinidos que pueden ampliarse a código repetitivo. Esta función le ahorra tiempo y garantiza una estructura coherente para sus definiciones de vistas.
Puede invocar plantillas activas simplemente pulsando ⌘J, escribiendo Listview y pulsando la tecla Tab.
Además, PyCharm incluye una ventana de herramientas Django Structure, donde verá una lista de todas las vistas de su proyecto Django, organizadas por aplicación. Esto le permite localizar rápidamente las vistas, navegar entre ellas e identificar a qué archivo pertenece cada vista.
Vistas basadas en clases
Django introdujo las vistas basadas en clases para que los usuarios no tuvieran que escribir el mismo código repetidamente. No sustituyen a las vistas basadas en funciones, sino que tienen ciertas aplicaciones y ventajas, especialmente en los casos en los que se requiere una lógica compleja.
Las vistas basadas en clases en Django proporcionan clases principales reutilizables que implementan varios patrones y funcionalidades que se suelen necesitar para las vistas de aplicaciones web. Puede tomar sus vistas de estas clases principales para reducir el código repetitivo.
Las vistas basadas en clases ofrecen clases principales genéricas como:
ListViewDetailViewCreateView- Y muchas más.
A continuación se muestran dos fragmentos de código similares que muestran una BookListView sencilla. El primero muestra una implementación básica utilizando las convenciones basadas en clases predeterminadas, mientras que el segundo ilustra cómo puede personalizar la vista especificando parámetros adicionales.
Implementación básica:
from django.views.generic import ListView
from .models import Book
class BookListView(ListView):
model = Book
# The template_name is omitted because Django defaults to 'book_list.html'
# based on the convention of _list.html for ListView.
Cuando BookListView se renderiza, consulta automáticamente los registros Book y los pasa bajo la variable books al renderizar book_list.html. Esto significa que puede crear una vista para enumerar objetos rápidamente sin necesidad de reescribir la lógica subyacente.
Implementación personalizada:
from django.views.generic import ListView
from .models import Book
class BookListView(ListView):
model = Book
# You can customize the view further by adding additional attributes or methods
def get_queryset(self):
# Example of customizing the queryset to filter books
return Book.objects.filter(is_available=True)
En el segundo fragmento, hemos introducido un método personalizado get_queryset(), que nos permite filtrar con mayor precisión los registros mostrados en la vista. Esto muestra cómo las vistas basadas en clases pueden ampliarse más allá de su funcionalidad predeterminada para satisfacer las necesidades de su aplicación.
Las vistas basadas en clases también definen métodos que se vinculan a partes clave del ciclo de vida de la solicitud y la respuesta, como:
get()– lógica para solicitudesGET.post()– lógica para solicitudesPOST.dispatch()– determina a qué método llamarget()opost().
Estos tipos de vistas proporcionan estructura a la vez que ofrecen personalización cuando es necesario, lo que las hace muy adecuadas para usos elaborados.
PyCharm ofrece plantillas activas para vistas basadas en clases como ListView, DetailView y TemplateView, para que pueda generar clases de vistas enteras en segundos, completas con métodos repetitivos y docstrings.
Creación de vistas personalizadas basadas en clases
También puede crear sus propias clases de vistas subclasificando las genéricas de Django y personalizándolas según sus necesidades.
Estos son algunos usos en los que quizá desee crear sus propias clases:
- Añadir lógica empresarial, como cálculos complicados.
- Mezclar varias clases principales genéricas para combinar funcionalidad.
- Gestionar las sesiones o el estado a través de varias solicitudes.
- Optimizar el acceso a la base de datos con consultas personalizadas.
- Reutilizar la lógica de renderizado común en diferentes áreas.
Una vista personalizada basada en clases podría tener este aspecto:
from django.views.generic import View
from django.shortcuts import render
from . import models
class ProductSalesView(View):
def get(self, request):
# Custom data processing
sales = get_sales_data()
return render(request, "sales.html", {"sales": sales})
def post(self, request):
# Custom form handling
form = SalesSearchForm(request.POST)
if form.is_valid():
results = models.Sale.objects.filter(date__gte=form.cleaned_data['start_date'])
context = {"results": results}
return render(request, "search_results.html", context)
# Invalid form handling
errors = form.errors
return render(request, "sales.html", {"errors": errors})
Aquí, los gestores personalizados get y post le permiten ampliar los existentes entre las solicitudes.
Cuándo utilizar cada tipo de vista
Tanto las vistas basadas en funciones como las basadas en clases pueden ser útiles en función de la complejidad y las necesidades de la lógica de la vista.
Las principales diferencias son que los puntos de vista basados en la clase:
- Promueven la reutilización mediante las subclases y la herencia del comportamiento de las clases principales.
- Son ideales para la gestión del estado entre solicitudes.
- Proporcionan más estructura y aplican la disciplina.
Se pueden utilizar trabajando con:
- Páginas de paneles con lógica de renderización compleja.
- Páginas de cara al público que muestran datos dinámicos.
- Portales de administración para la gestión de contenidos.
- Enumeran o detallan páginas que incluyen modelos de bases de datos.
Por otro lado, las vistas basadas en funciones:
- Son más sencillas y se necesita menos código para crearlas.
- Pueden ser más fáciles de entender para los desarrolladores de Python.
- Son muy flexibles y tienen menos limitaciones.
Entre sus usos se incluyen:
- Prototipos de ideas.
- CRUD simple o vistas de base de datos.
- Páginas de destino o de marketing.
- Puntos de conexión de la API para servir solicitudes web.
En resumen, las vistas basadas en funciones son flexibles, sencillas y más fáciles de razonar. Sin embargo, para casos más complejos, tendrá que crear más código que no podrá reutilizar.
Las vistas basadas en clases en Django refuerzan la estructura y son reutilizables, pero pueden ser más difíciles de entender e implementar, así como más difíciles de depurar.
Vistas y URL
Como hemos indicado, en Django, las vistas son las funciones o clases que determinan cómo se renderiza una plantilla. Cada vista enlaza con un patrón de URL específico, guiando las solicitudes entrantes al lugar correcto.
Comprender la relación entre las vistas y las URL es importante para gestionar eficazmente el flujo de su aplicación.
Cada vista se corresponde con un patrón URL definido en el archivo urls.py de su aplicación Django. Esta asignación de URL asegura que cuando un usuario navega a una dirección específica en su aplicación, Django sabe exactamente qué vista invocar.
Echemos un vistazo a la configuración de una URL sencilla:
from django.urls import path
from .views import BookListView
urlpatterns = [
path('books/', BookListView.as_view(), name='book-list'),
]
En esta configuración, cuando un usuario visita /books/, BookListView se pone en marcha para renderizar la lista de libros. Al asignar claramente las URL a las vistas, su base de código será más fácil de leer y estará más organizada.
Simplifique la gestión de URL con PyCharm
La gestión y visualización de puntos de conexión en Django puede convertirse en un reto a medida que su aplicación crece. PyCharm aborda esta cuestión con su ventana de herramientas Endpoints , que proporciona una vista centralizada de todos los patrones URL, vistas vinculadas y métodos HTTP de su aplicación. Esta funcionalidad le permite ver una lista de todos los puntos de conexión de su proyecto, lo que facilita el seguimiento de las vistas vinculadas a URL específicas.
En lugar de buscar en varios archivos urls.py, puede localizar al instante las vistas correspondientes y navegar hasta ellas con un solo clic. Esto es especialmente útil para proyectos Django más grandes donde las configuraciones URL abarcan varios archivos o cuando se trabaja en equipo, donde establecer el contexto rápidamente es crucial.
Además, la ventana de herramientas Endpoints le permite visualizar todos los puntos de conexión en una interfaz similar a una tabla. Cada fila muestra la ruta URL, el método HTTP (GET, POST, etc.) y la función o clase de vista asociada de un punto de conexión determinado.
Esta funcionalidad no solo aumenta la productividad, sino que también mejora la navegación por el código, lo que le permite detectar con facilidad patrones de URL omitidos o duplicados. Este nivel de visibilidad es inestimable para depurar problemas de enrutamiento o para incorporar nuevos desarrolladores a un proyecto.
Consulte este vídeo para obtener más información sobre la ventana de herramientas Endpoints y cómo sacarle partido.
Mejores prácticas para utilizar las vistas de Django
He aquí algunas pautas que pueden ayudarle a crear vistas bien estructuradas y mantenibles.
Mantenga las vistas centradas
Las vistas deben concentrarse en gestionar las solicitudes, obtener datos, pasar datos a las plantillas y controlar el flujo y las redirecciones. La lógica empresarial complicada y un procesamiento complejo deben producirse en otro lugar, como en los métodos del modelo o en clases de servicio dedicadas.
Sin embargo, debe tener cuidado de no sobrecargar sus modelos con demasiada lógica, ya que esto puede conducir al antipatrón «fat model» en Django. La documentación de Django sobre las vistas proporciona más información sobre cómo estructurarlas adecuadamente.
Mantenga las vistas y las plantillas sin sobrecargas
Lo mejor es que tanto las vistas como las plantillas sean ligeras. Las vistas deben encargarse del procesamiento de solicitudes y la recuperación de datos, mientras que las plantillas deben centrarse en la presentación con una lógica mínima.
El procesamiento complejo debe realizarse en Python fuera de las plantillas para mejorar la mantenibilidad y las pruebas. Para obtener más información, consulte la documentación sobre plantillas de Django.
Desacoplar las consultas de la base de datos
Extraer las consultas de la base de datos a gestores de modelos o repositorios independientes en lugar de colocarlas directamente en las vistas puede ayudar a reducir la duplicación. Consulte la documentación sobre modelos de Django para obtener información sobre la gestión eficaz de las interacciones con la base de datos.
Utilice vistas genéricas basadas en clases cuando sea posible
Las vistas genéricas basadas en clases de Django, como DetailView y ListView, se pueden reutilizar sin necesidad de escribir mucho código. Opte por utilizarlas en lugar de reinventar la rueda para aprovechar mejor su tiempo. La documentación sobre vistas genéricas es un recurso excelente para comprender estas funcionalidades.
Las vistas basadas en funciones están bien para casos sencillos
Para vistas básicas como servir API, una función puede ser más eficaz que una clase. Reserve vistas complejas basadas en clases para flujos de interfaz de usuario complicados. La página de redacción de documentación sobre las vistas ofrece ejemplos útiles.
Estructure rutas y URL de forma limpia
Organice las rutas y los gestores de vistas agrupándolos en aplicaciones por funcionalidad. Esto facilita la búsqueda y la navegación por la fuente. Consulte la documentación del distribuidor de URL de Django para conocer las mejores prácticas para estructurar sus configuraciones de URL.
Próximos pasos
Ahora que comprende en esencia las vistas en Django, querrá profundizar en el marco de trabajo y en otros pasos siguientes.
- Ponga al día sus conocimientos sobre Django con nuestro artículo del blog Cómo aprender Django, ideal para principiantes o para quienes deseen actualizar sus conocimientos.
- Descubra cómo crear y ejecutar su primer proyecto Django en PyCharm, con nuestro tutorial sobre la elaboración de una aplicación básica de tareas pendientes, o explore nuestra lista completa de ideas de proyectos Django para obtener más inspiración.
- Explore el estado de Django para ver las últimas tendencias en el desarrollo de Django e inspirarse un poco más.
- Si aún está decidiendo qué marco de trabajo de Python utilizar, nuestras guías comparativas Django vs. Flask y Django vs. FastAPI pueden ayudarle.
Compatibilidad con Django en PyCharm
PyCharm Professional es el mejor IDE de su clase para el desarrollo en Django. Le permite codificar más rápido con asistencia a la codificación específica para Django, navegación y refactorización en todo el proyecto y compatibilidad total con plantillas Django. Puede conectarse a su base de datos en un solo clic y trabajar en TypeScript, JavaScript y marcos de trabajo frontend. PyCharm también es compatible con Flask y FastAPI sin necesidad de configuraciones adicionales.
Cree mejores aplicaciones y agilice su código. Comience ahora con PyCharm para desarrollar en Django sin esfuerzo.
Artículo original en inglés de:
Subscribe to PyCharm Blog updates
