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,
Queries y Filtros en Django: Optimización y Estrategias Avanzadas
12/32Recursos
Los managers en Django son una herramienta poderosa que permite realizar diversas acciones dentro de las listas de objetos de un modelo, como contar, traer el primero o el último elemento, crear nuevos registros y mucho más.
Para contar los autores que están creados, utilizamos el manager por defecto llamado objects y el método count.
author_count = Author.objects.count()
print(f"Hay {author_count} autores.")
¿Cómo traer el primer y último autor creado?
Para obtener el primer y último autor, podemos usar los métodos first y last del manager objects.
primer_autor = Author.objects.first()
print(f"El primer autor es: {primer_autor.name}")
ultimo_autor = Author.objects.last()
print(f"El último autor es: {ultimo_autor.name}")
¿Cómo crear nuevos autores con el manager?
Podemos crear un nuevo autor directamente en la base de datos utilizando el método create del manager.
nuevo_autor = Author.objects.create(name="Luis Martínez", birthday="1980-01-01")
print(f"Nuevo autor creado: {nuevo_autor.name}")
¿Cómo traer una lista de autores?
Para obtener una lista de todos los autores, utilizamos el método all del manager, que nos devuelve un queryset.
autores = Author.objects.all()
for autor in autores:
print(autor.name)
¿Cómo filtrar autores?
Podemos filtrar autores utilizando el método filter, que permite especificar condiciones basadas en los campos del modelo.
autores_filtrados = Author.objects.filter(name="Pydanny")
for autor in autores_filtrados:
print(f"Autor filtrado: {autor.name}")
¿Cómo borrar un autor filtrado?
Primero, filtramos el autor que queremos borrar y luego aplicamos el método delete.
Author.objects.filter(name="Luis Martínez").delete()
print("Autor borrado.")
¿Cómo ordenar autores?
Podemos ordenar los autores utilizando el método order_by.
autores_ordenados = Author.objects.order_by('name')
for autor in autores_ordenados:
print(autor.name)
Aportes 20
Preguntas 0
Ordenar por:
Los managers son una parte fundamental del sistema de consultas.
1. Definición: Un manager es la interfaz a través de la cual Django proporciona operaciones de consulta a la base de datos para un modelo.
2. Función principal: Actúa como un intermediario entre el modelo y la base de datos, proporcionando métodos para realizar consultas.
3. Manager por defecto: Cada modelo de Django tiene al menos un manager, llamado `objects` por defecto.
`todos_los_libros = Book.objects.all() libros_filtrados = Book.objects.filter(autor="Tolkien")`
Métodos comunes:
* `all()`: Recupera todos los objetos.
* `filter()`: Filtra objetos según criterios.
* `get()`: Obtiene un objeto único.
* `create()`: Crea un nuevo objeto.
* `update()`: Actualiza objetos.
1. Managers personalizados: Puedes crear managers personalizados para añadir métodos específicos o modificar el comportamiento de las consultas.
2. Chaining: Los métodos de los managers se pueden encadenar para construir consultas complejas.
3. Lazy evaluation: Las consultas no se ejecutan hasta que realmente se necesitan los resultados, lo que permite una construcción eficiente de consultas complejas.
```js
from django.shortcuts import render
from my_first_app.models import Car
# 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)
<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>
```\\<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>
Lista de Autos
{% for car in car_list %} {% endfor %}| Marca | Año | Color |
|---|---|---|
| {{ car.title }} | {{ car.year }} | {{ car.color }} |
Lista de Autos\
\ \ \ \ \ \ {% for car in car\_list %} \ \ \ \ \ {% endfor %} \| Marca\ | Año\ | Color\ |
|---|---|---|
| {{ car.title }}\ | {{ car.year }}\ | {{ car.color }}\ |
Reto resuelto:
```js
from django.shortcuts import render
from .models import Car
# 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)
```
**view.py**
```python
from django.shortcuts import render
from my_first_app.models import Car
# 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)
```TEMPLATES car\_list.py
```html
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Car list</title>
</head>
<body>
Lista de carros
-
{% for car in car_list%}
{% endfor %}
</body>
</html>
```
| TITLE | MODEL | YEAR | COLOR |
|---|---|---|---|
| {{car.title}} | {{car.model}} | {{car.year}} | {{car.color}} |
una recomendacion para el ux ui, debe tener en cuenta que la barrita donde se adelanta o se retrasa 15 minutos, la misma de play, no permite mostrar lo que esta copiando, entonces es bueno que le haga clear a la terminal, o , ponga pequeña la ventana de la terminal.
Comando concadenado para eliminar registros
en la base de datos, DespuEs de ser filtrados por una campo especifico del modelo.
`Author.objects.filter(name="Audry").delete()`
Veo que no lo mencionan pero cuando estamos trabajanco con objetos no es necesario enviar las variables que contiene, ejemplo "name" o "birth\_date", evidentemente es una buena práctica y evita errores humanos, pero cuando trabajamos con tan pocos datos podemos simplemente obviarlo, eso sí, debemos utilizarlo en el mismo orden, esto es lo importante, mientras que enviandole el atributo no necesariamente tiene que ser en el mismo orden.
EjemploAuthor.objects.create(name="Daniel", birth\_date="1990-12-05")
```js
Author.objects.create(name="Daniel", birth_date="1990-12")
``````js
Author.objects.create("Daniel","1990-12-05")
```Nota: No lo hagan, solo es bueno que lo sepan.
```python
from django.db import models
# Create your models here.
class Car(models.Model):
brand = models.CharField(max_length=10)
model_car = models.CharField(max_length=15)
year = models.DateField()
def __str__(self) :
return self.brand
class Dealrshep(models.Model):
name = models.CharField(max_length=50)
address = models.CharField(max_length=100)
def __str__(self):
return self.name
```
Result of challenge:
```js
from django.shortcuts import render
from .models import Car
# 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)
``````js
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
The car is {{ car.title }} - with year {{ car.year }} - and color {{ car.color }}
{% endfor %}
</body>
</html>
```
Car List
{% for car in car_list %}
En views.py hay que agregar:
`from my_first_app.models import Car`
y en la función my\_view:
`car_list = Car.objects.all()`
El método `order_by` del manager de Django permite usar múltiples parámetros para el ordenamiento. Puedes pasar varios campos separados por comas y Django los ordenará en el orden que especifiques. Por ejemplo, `objects.order_by('campo1', 'campo2')`. Esto te permite hacer un ordenamiento más complejo. ¡Sigue aprendiendo y experimentando con Django!
El reto que dejo el profe:
```python
from django.shortcuts import render
from my_first_app.models import Car
def my_view(request):
car_list = Car.objects.all()
return render(request, 'my_first_app/car_list.html', {"car_list": car_list})
EL HTML:
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Car List</title>
</head>
<body>
Car List
-
{% for car in car_list %}
-
{{ car.title }}
{{ car.year }}
{% endfor %}
**Database Managers (Manejadores de bases de datos)**:
Un "manager" es un objeto que gestiona consultas a bases de datos. En Django, por ejemplo, los *model managers* son responsables de interactuar con la base de datos y proporcionar métodos para consultar registros. Ejemplo:
Buen dia campeon.
```js
from .models import Vehicle
def my_view(request):
motorcycle_list = [
{'title': 'BMW R 18 Transcontinental Touring'},
{'title': 'Ducati Scrambler Urban Mot Super motard'},
{'title': 'Honda CB300R Neo Sports Cafe Naked bike'},
{'title': 'Harley-Davidson Electra Glide Standard Touring'},
{'title': 'Kawasaki Ninja 1000SX Tourer Sport'},
{'title': 'Suzuki Boulevard C50SE Touring'},
]
# car_list = list_car_dicts
car_list = Vehicle.objects.all()
motor_list = motorcycle_list
context = {
'car_list': car_list,
'motor_list': motor_list
}
return render(request, "my_app/index.html", context)
```
```python
from django.shortcuts import render, HttpResponse
from .models import Car # uso .models para importar el modelo Car
# Traer todos los autos de la base de datos
def my_view(request):
car_list = Car.objects.all()
context = {"car_list": car_list}
return render(
request, "car_view.html", context
) # Creo un archivo html en la carpeta templates/pages, y paso la lista de autos en formato
```from django.shortcuts import render, HttpResponsefrom .models import Car # uso .models para importar el modelo Car
\# Create your views here.def home\_page\_view(request) -> HttpResponse: return HttpResponse("Hello World")
\# Traer todos los autos de la base de datos
def my\_view(request): car\_list = Car.objects.all() context = {"car\_list": car\_list} return render( request, "car\_view.html", context ) # Creo un archivo html en la carpeta templates/pages, y paso la lista de autos en formato
**Reto:**
en **my\_first\_app** ir al archivo de **views.py** y actualizar car\_list para obtener la información desde el model Car.objects.all() y con esto cargar la información de la BD.
**Resultado del código:**
```python
from django.shortcuts import render
from my_first_app.models import Car
# 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)
```
Reto resuelto:
```js
from django.shortcuts import render
from .models import Car
# 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)
```from django.shortcuts import renderfrom .models import Car
\# 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)
Reto resuelto:
`from django.shortcuts import renderfrom .models import Car`
`# 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)`
No, el método `order_by` del manager de Django puede recibir múltiples parámetros. Puedes pasar varios campos separados por comas para ordenar por varios criterios. Por ejemplo, `objects.order_by('campo1', 'campo2')` ordenará primero por `campo1` y luego por `campo2`. ¡Sigue aprendiendo!
En views.py
`from django.shortcuts import render`
`from mvt.models import Car`
`def my_view(request):`
` car_list = [{"title": "BMW"}, {"title": "MAZDA"}]`
` car_list_db = Car.objects.all()`
` context = {`
` "car_list": car_list,`
` "car_list_db": car_list_db,`
` } `
` return render(`
` request, "mvt/car_list.html", context`
` ) `
En car\_list.html
``
`<html lang="en">`
` <head>`
` <meta charset="UTF-8" />`
` <meta name="viewport" content="width=device-width, initial-scale=1.0" />`
` <title>Car List</title>`
` </head>`
` <body>`
`
Lista de Carros Quemada
` `- `
` {% for car in car_list %}`
`
- {{ car.title }} ` ` {% endfor %}` `
Lista de Carros BD
` `- `
`
- Title, Year ` ` {% for car_db in car_list_db %}` `
- {{ car_db.title }}, {{ car_db.year}} ` ` {% endfor %}` `
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?