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
You don't have access to this class
Keep learning! Join and start boosting your career
If you already have an account,
Queries y Filtros en Django: Optimización y Estrategias Avanzadas
12/32Resources
Managers in Django are a powerful tool that allows us to perform various actions within the lists of objects in a model, such as counting, fetching the first or last element, creating new records and much more.
To count the authors that are created, we use the default manager called objects and the count method.
author_count = Author.objects.count() print(f"There are {author_count} authors.")How to get the first and last author created?
To get the first and last author, we can use the first and last methods of the manager objects.
first_author = Author.objects.first() print(f"The first author is: {first_author.name}.") last_author = Author.objects.last() print(f"The last author is: {last_author.name}.")How to create new authors with the manager?
We can create a new author directly in the database using the create method of the manager.
new_author = Author.objects.create(name="Luis Martinez", birthday="1980-01-01") print(f"New author created: {new_author.name}")How to get a list of authors?
To get a list of all authors, we use the manager's all method, which returns a queryset.
authors = Author.objects.all()for author in authors: print(author.name)How to filter authors?
We can filter authors using the filter method, which allows us to specify conditions based on the fields of the model.
authors_filtered = Author.objects.filter(name="Pydanny")for author in authors_filtered: print(f"Filtered author: {author.name}")How to delete a filtered author?
First, we filter the author we want to delete and then we apply the delete method.
Author.objects.filter(name="Luis Martínez").delete() print("Author deleted.")How to order authors?
We can sort the authors using the order_by method.
authors_ordered = Author.objects.order_by('name')for author in authors_ordered: print(author.name)Contributions 28
Questions 1
Sort by:
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)
```
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.
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()`
**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()`
Reto completado, solo había que modificar el archivo de views.py:
```python
from django.shortcuts import renderfrom 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
Pues esta fue mi solución, en sí, solo fue 2 líneas de código de lo que teníamos
la importación de Car y obtener todos los carros con `objects.all()`
`def my_view(request):`
` car_list = Car.objects.all()`
` return render(request, "my_first_app/car_list.html", context={"car_list": car_list})`
reto de la clase
```python
from django.shortcuts import render
from .models import Carro
# Create your views here.
def my_view(request):
car_list = Carro.objects.all()
return render(request, 'my_first_app/car_list.html', {'carros':car_list})
```
```python
views.py
from django.shortcuts import render
from my_first_app.models import Carro
# Create your views here.
def my_View(request):
car_list = Carro.objects.all()
context = {
"car_list": car_list
}
return render(request,"my_first_app/car_list.html",context)
#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>
</body>
</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> \
\</body>
\</html>
Lista de Carros
{% for car in car_list %} {% endfor %}| Carro | Color |
|---|---|
| {{ car.title }} | {{ car.Color }} |
Lista de Carros\
\ \ \ \ \ \ \ \ {% for car in car\_list %} \ \ \ \ {% endfor %} \ \| Carro\ | Color\ |
|---|---|
| {{ car.title }}\ | {{ car.Color }}\ |
```js
from django.shortcuts import render
from my_first_app.models import Car
# Create your views here.
def my_view(request):
cars = Car.objects.all()
context = {
'car_list': cars
}
return render(request, "my_first_app/car_list.html", context)
```*from* django.shortcuts *import* render*from* my\_first\_app.models *import* Car
*# Create your views here.*def my\_view(*request*): cars = Car.objects.all() context = { 'car\_list': cars } *return* render(*request*, "my\_first\_app/car\_list.html", context)
```python
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)
``````python
from django.db import models
# Create your models here.
class Car(models.Model):
title = models.TextField(max_length=250)
year = models.TextField(max_length=4, null=True)
color = models.TextField(max_length=250, null=True)
``````python
<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 %}
-
Brand: {{ car.title }}
Year: {{ car.year }}
Color: {{ car.color }}
{% endfor %}
```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 %}
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 %}` `
Want to see more contributions, questions and answers from the community?