Fundamentos de Django
¿Qué es Django?
¿Cómo instalar Django?
Entendiendo la arquitectura de Django
Qué es el patrón MVT (Model, View y Template)
La M en el Patrón: Modelo
Introducción a Modelos y Bases de Datos
Manejo Avanzado de Modelos y Bases de Datos
Gestión de Modelos y Bases de Datos en Django con SQLite
Inserción de Datos con Django
Actualización y Eliminación de Datos en Django
Relaciones y Asociaciones entre Modelos
Creación y Gestión de Relaciones entre Modelos en Django
Relaciones Muchos a Muchos (N:N) en Django
Relaciones Uno a Uno (1:1) en Django
Queries y Filtros en Django: Optimización y Estrategias Avanzadas
Configuración de URLs y Vistas Avanzadas
Gestión de URLs en Django: Configuración, Rutas y Mejores Prácticas
Vistas Basadas en Clases en Django
La T en el Patrón: Plantillas o Templates
Personalización de Interfaz con Plantillas en Django
Desarrollo de Aplicaciones en Django
Configuración del Proyectos en Django
Creación del Modelo para la Aplicación 'Products' en Django
Cómo Crear Migraciones de Datos en Django
Creación de la Aplicación 'Products' con Formularios en Django
Integracion de TailwindCSS en Django
Django Admin
Manejo de Sesiones en Django
Manejo de Órdenes en CoffeShop
Manejo de Pedidos en CoffeShop
Mixings en vistas basadas en clases
Agregar productos a la orden
Django Rest Framework
Django REST Framework
Despliegue de aplicaciones Django
Configurar PostgreSQL en AWS con Django
Variables de entorno en Django
¿Cómo usar Unit Testing en Django?
Debugging en Django
Desplegar aplicaciones de Django en AWS
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Gestión de URLs en Django: Configuración, Rutas y Mejores Prácticas
13/32Recursos
Configurar las URLs en Django es esencial para organizar tu proyecto y facilitar la navegación.
¿Cómo crear un archivo de URLs en Django?
Primero, debes crear un archivo urls.py en cada aplicación que desarrolles. Por ejemplo, si tienes una aplicación llamada MyFirstApp, debes crear un archivo urls.py dentro de esta aplicación.
- Crear el archivo: En la aplicación
MyFirstApp, crea un archivo llamadourls.py. - Copiar y pegar configuración básica: Puedes copiar la configuración básica de otro archivo de URLs y modificarla según sea necesario.
- Eliminar enlaces e importaciones innecesarias: Mantén solo lo necesario para tu aplicación.
from django.urls import path
from . import views
urlpatterns = [
path('listado/', views.myView, name='listado'),
]
¿Cómo incluir URLs de una aplicación en el proyecto?
Para incluir las URLs de una aplicación en el proyecto principal, sigue estos pasos:
- Modificar el archivo de URLs del proyecto: Agrega un nuevo
pathque incluya las URLs de tu aplicación.
from django.urls import include, path
urlpatterns = [
path('carros/', include('myFirstApp.urls')),
]
- Importar el include: Asegúrate de importar
includedesdedjango.urls.
¿Cómo configurar un servidor de desarrollo?
Para probar los cambios, ejecuta el servidor de desarrollo:
python manage.py runserver
Esto iniciará el servidor y podrás ver los cambios en tiempo real.
¿Cómo crear URLs dinámicas?
Para crear URLs que acepten parámetros dinámicos, sigue estos pasos:
- Definir una URL dinámica: Utiliza los caracteres
<y>para especificar el tipo de dato y el nombre del parámetro.
urlpatterns = [
path('detalle/<int:id>/', views.detalle, name='detalle'),
]
- Modificar la vista para aceptar parámetros: Asegúrate de que tu vista acepte los parámetros correspondientes.
def detalle(request, id):
return HttpResponse(f"El ID es {id}")
¿Cómo manejar diferentes tipos de datos en URLs?
Django permite convertir diferentes tipos de datos en las URLs, como enteros y cadenas de texto:
- Enteros: Utiliza
<int:nombre>para enteros. - Cadenas de texto: Utiliza
<str:nombre>para cadenas de texto.
urlpatterns = [
path('marca/<str:brand>/', views.marca, name='marca'),
]
¿Cómo probar URLs dinámicas en el navegador?
- Probar con enteros: Accede a una URL que requiera un entero, como
detalle/1/. - Probar con cadenas de texto: Accede a una URL que requiera una cadena de texto, como
marca/mazda/.
Aportes 12
Preguntas 1
Ordenar por:
Reto resuelto:
```js
from django.http import HttpResponse
from django.urls import path
from .models import Author, Profile
def my_view(request, *args, **kwargs):
print(args)
print(kwargs)
return HttpResponse("")
def author_view(request, *args, **kwargs):
print(args)
print(kwargs)
author = Author.objects.get(id=kwargs['id'])
profile = Profile.objects.get(author_id=kwargs['id'])
return HttpResponse(f"Author: {author.name} - Website: {profile.website} - Biografia: {profile.biography} ")
urlpatterns = [
path('listado/', my_view),
path('detalle/<int:id>', my_view),
path('marcas/<str:brand>', my_view),
path('autor/<int:id>', author_view),
]
```
Me sale un warning que las urls deben empezar sin la barra, así path("/listado", my\_view) debe ser cambiado a path("listado", my\_view). Sigue funcionando igual, pero desaparece el warning
en mi punto de vista, vi que varios crean su url concatenando su ID, siento que no es nada seguro porque se podria hacer muchas cosas con ese id que tiene en la url, lo conveniente es manejarlo oculto mas no mostrar por ID, es mi punto de vista ya que hay otros metodos de como hacerlo
tengo un problema
Vista: from django.contrib import adminfrom django.urls import path, includefrom django.http import HttpResponsefrom django.urls import pathfrom my\_first\_app.views import my\_view, my\_view2\\<html lang="en">\<head> \<meta charset="UTF-8"> \<meta name="viewport" content="width=device-width, initial-scale=1.0"> \<title>Lista de Autos\</title>\</head>\<body> \
\</body>\</html>
urlpatterns = \[ path("listado/", my\_view, name="car\_list"), path("detalle/\<int:id>", my\_view), path("marcas/\<str:brand>", my\_view), path("autor/\<str:author\_name>", my\_view2, name="author\_biography"),]
urlpatterns = \[ path('admin/', admin.site.urls), path("carros/", include("my\_first\_app.urls")), path("biografia/",include("my\_first\_app.urls"))]
```js
from django.shortcuts import render
from my_first_app.models import Car, Profile
# Create your views here.
def my_view(request):
car_list = Car.objects.all()
context = {
"car_list": car_list
}
return render(request, "my_first_app/car_list.html", context)
def my_view2(request,author_name):
author_biography = Profile.objects.filter(author__name=author_name)
context = {
"author_biography": author_biography
}
return render(request, "my_first_app/car_list.html", context)
```Urls:
```js
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path("carros/", include("my_first_app.urls")),
path("biografia/",include("my_first_app.urls"))
]
```Urls de my\_first\_app:
```js
from django.http import HttpResponse
from django.urls import path
from my_first_app.views import my_view, my_view2
urlpatterns = [
path("listado/", my_view, name="car_list"),
path("detalle/<int:id>", my_view),
path("marcas/<str:brand>", my_view),
path("autor/<str:author_name>", my_view2, name="author_biography"),
]
```template:
```js
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Lista de Autos</title>
</head>
<body>
</body>
</html>
```
Perfil del Autor {{ profile.author.name }}\
\ {% for author in author\_biography %} \ \ \ \ \ {% endfor %} \| {{ author.author }}\ | {{ author.website }}\ | {{ author.biography }}\ |
Perfil del Autor {{ profile.author.name }}
{% for author in author_biography %} {% endfor %}| {{ author.author }} | {{ author.website }} | {{ author.biography }} |
Reto:
**views.py** en **my\_first\_app:**
dentro de templates/my\_first\_app/ cree el archivo author\_profile.html
Luego dentro de my\_first\_app modifique el archivo urls.py de la siguiente manera:
Luego de eso modifique el archivo urls.py dentro de my\_\_first\_project:
Al modificar el urls del proyeto en la linea 22 quitando carros, al ejecutar el código las rutas quedan:
Finalmente para ver el el perfil del autor:
Algo mas de las URLs en Django en los primeros pasos con Django documentation:
<https://docs.djangoproject.com/en/5.0/intro/tutorial01/#path-argument-route>
Comparto mi solución para mostrar la información del perfil de un Autor:
**views.py (my\_first\_app):**
**urls.py (my\_first\_app):**
**author\_profile.html (my\_first\_app/views):**
Me parece que esta clase de URL fue muy resumida y muy rápida. Hubiese sido mejor que empiece con la creación de la URL de la homepage creándola desde my_first_project y luego si con la explicación de include urls en las app.
urls.py
```python
from django.http import HttpResponsefrom django.urls import path
from my\_first\_app.views import author\_profile\_show
def my\_view(request, \*args, \*\*kwargs): print(args) print(kwargs) return HttpResponse("")
urlpatterns = \[ path("listado/", my\_view), path("detalle/\<int:id>", my\_view), path("marcas/\<str:brand>", my\_view), path("author\_profile/\<int:id>", author\_profile\_show),
```
**view.py**
```python
from django.shortcuts import renderfrom my\_first\_app.models import Car, Profile
\# Create your views here.def my\_view(request): car\_list = Car.objects.all() context = { "car\_list":car\_list } return render(request, "my\_first\_app/car\_list.html", context)
def author\_profile\_show(request, id): profile = Profile.objects.get(author\_id = id) context = { "profile":profile } return render(request, "my\_first\_app/author\_profile.html", context)
```
**author\_profile.py**
```html
\\<html lang="en">\<head> \<meta charset="UTF-8"> \<meta name="viewport" content="width=device-width, initial-scale=1.0"> \<title>Document\</title>\</head>\<body> \<head>AUTHOR PROFILE\</head> \<main> \<article> \<header> \
{{ profile.author.name}}\
\Fecha de nacimiento: \<time>{{ profile.author.birth\_date }}\</time>\
\</header> \<footer> \{{ profile.biography }} \
\ {{ profile.website }} \ \</footer> \</article> \</main>\</body>\</html> ```
1. url app
2. url proyecto 
3. vista autor 
4. html 
5. resultado
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?