Shell de Django, ORM y QuerySets

En resumen

El Shell de Django es una herramienta esencial durante la etapa de desarrollo y depuración de tus proyectos. Permite acceder directamente al ORM y a los QuerySets para realizar consultas y trabajar con la base de datos.

¿Qué es Django Shell?¶

El shell de Django es una interfaz de línea de comandos interactiva que combina el intérprete de Python con las funcionalidades de Django. Al iniciarlo, carga automáticamente la configuración del proyecto, permitiendo trabajar directamente con sus aplicaciones y modelos.

Una de sus principales ventajas es el acceso al ORM (Object-Relational Mapper) de Django, que permite consultar, crear, modificar y eliminar datos de la base de datos utilizando Python, sin necesidad de escribir directamente consultas SQL.

Django utiliza Python como intérprete interactivo por defecto. Sin embargo, también puedes utilizar IPython o bpython como alternativas, siempre que estén instalados en el entorno virtual del proyecto.

Para acceder al shell de Django, solo necesitas ejecutar el comando shell en un proyecto de Django. Para ello, es necesario tener un proyecto configurado y en funcionamiento. Si quieres comenzar a configurar un proyecto desde cero, sigue las instrucciones.

Instrucciones: nuevo proyecto¶

A continuación, selecciona tu plataforma y sigue los pasos indicados para configurar un nuevo proyecto con Django.

Si ya tienes un proyecto

Las siguientes instrucciones están pensadas para configurar un proyecto Django desde cero. Si ya tienes un proyecto Django creado y configurado, no despliegues esta sección y continúa con el siguiente paso del post.

Ver Instrucciones

Windows Linux macOS

1. Abrir el símbolo de sistema

Presiona Win+R para abrir la ventana Ejecutar. Escribe cmd y presiona Enter para abrir el Símbolo del sistema (CMD).

Abrir CMD — Abrir el símbolo del sistema (CMD)

2. Ir a la ubicación deseada

Una vez que tengas el CMD abierto, usa el comando cd para navegar a la carpeta donde deseas crear tu proyecto. Por ejemplo, si deseas ir a la carpeta Documentos:

cd %UserProfile%\Documents #(1)!

Ingresa a la carpeta Documentos del usuario actual.

3. Crear la carpeta del proyecto y acceder a ella

Ejecuta el siguiente comando reemplazando mi-proyecto por el nombre deseado:

mkdir //PROJECT// #(1)!
cd //PROJECT// #(2)!

Crea la carpeta del proyecto
Ingresa a la carpeta creada anteriormente

4. Crear el entorno virtual

Ejecuta el siguiente comando para crear un entorno virtual en la carpeta del proyecto:

python -m venv .venv #(1)!

Crea un entorno virtual de Python llamado .venv.

5. Activar el entorno virtual

Ejecuta el siguiente comando para activar el entorno virtual:

.\.venv\Scripts\activate

Una vez activado, deberías ver (.venv) al comienzo de la línea de comandos.

(.venv) C:\Users\mcherrera\nuevo-proyecto

Ahora tenemos un entorno limpio y listo para trabajar.

6. Instalar Django en el entorno virtual

Una vez que el entorno virtual está activado, instala Django con el siguiente comando:

(.venv) pip install django

7. Generar un nuevo

Con la herramienta django-admin y el comando startproject se puede generar automáticamente la estructura inicial de un nuevo proyecto Django.

(.venv) django-admin startproject _site .

Utilizamos un punto . al final del comando para generar el proyecto en el directorio actual, evitando que Django cree una carpeta adicional con el nombre del proyecto.

8. Archivos del proyecto

Una vez generado, tendrás disponible el archivo manage.py en el proyecto:

Archivos del proyecto

 mi-proyecto
├──  _site
│   ├──  __init__.py #(1)!
│   ├──  asgi.py #(2)!
│   ├──  settings.py #(3)!
│   ├──  urls.py #(4)!
│   └──  wsgi.py #(5)!
├──  .venv #(6)!
└──  manage.py #(7)!

Inicializa el paquete Python del proyecto Django.
Configura el punto de entrada ASGI para servidores asíncronos.
Contiene la configuración principal del proyecto Django.
Define las rutas y URLs del proyecto.
Configura el punto de entrada WSGI para servidores web tradicionales.
Contiene el entorno virtual de Python del proyecto.
Permite administrar el proyecto mediante comandos de Django.

El archivo manage.py permite administrar y ejecutar distintas tareas del proyecto Django, como iniciar el servidor de desarrollo, ejecutar migraciones y crear aplicaciones.

1. Abrir la terminal

Presiona las teclas Ctrl+Alt+T o busca Terminal en tu lanzador de aplicaciones para abrir una nueva Terminal.

2. Navegar a la ubicación deseada

Una vez que tengas la terminal abierta, usa el comando cd para navegar a la carpeta donde deseas crear el proyecto Django. Por ejemplo, ir a Documentos:

Terminal

cd ~/Documents

3. Crear la carpeta del proyecto y acceder a ella

Ejecuta el siguiente comando reemplazando mi-proyecto por el nombre que deseas:

Terminal

mkdir //PROJECT// #(1)!
cd //PROJECT// #(2)!

Crea la carpeta del proyecto
Ingresa a la carpeta creada anteriormente

4. Crear el entorno virtual

Terminal

python3 -m venv .venv

5. Activar el entorno virtual

Terminal

source .venv/bin/activate

Una vez activado, deberías ver (.venv) al comienzo de la terminal.

6. Instalar Django en el entorno virtual

Una vez que el entorno virtual está activado, instala Django con el siguiente comando:

Terminal

(.venv) pip install django

7. Generar un nuevo

Con la herramienta django-admin y el comando startproject se puede generar automáticamente la estructura inicial de un nuevo proyecto Django.

Terminal

(.venv) django-admin startproject _site .

Utilizamos un punto . al final del comando para generar el proyecto en el directorio actual, evitando que Django cree una carpeta adicional con el nombre del proyecto.

8. Archivos del proyecto

Una vez generado, tendrás disponible el archivo manage.py en el proyecto:

Archivos del proyecto

 mi-proyecto
├──  _site
│   ├──  __init__.py #(1)!
│   ├──  asgi.py #(2)!
│   ├──  settings.py #(3)!
│   ├──  urls.py #(4)!
│   └──  wsgi.py #(5)!
├──  .venv #(6)!
└──  manage.py #(7)!

Inicializa el paquete Python del proyecto Django.
Configura el punto de entrada ASGI para servidores asíncronos.
Contiene la configuración principal del proyecto Django.
Define las rutas y URLs del proyecto.
Configura el punto de entrada WSGI para servidores web tradicionales.
Contiene el entorno virtual de Python del proyecto.
Permite administrar el proyecto mediante comandos de Django.

El archivo manage.py permite administrar y ejecutar distintas tareas del proyecto Django, como iniciar el servidor de desarrollo, ejecutar migraciones y crear aplicaciones.

1. Abrir la terminal de comandos

Presiona Cmd+Space para abrir Spotlight, luego escribe terminal y presiona Enter

Abrir Terminal en MacOS — Abrir Terminal en macOS

2. Navegar a la ubicación deseada

Una vez que tengas la terminal abierta, usa el comando cd para navegar a la carpeta donde deseas crear el proyecto Django. Por ejemplo, ir a Documentos:

Terminal

cd ~/Documents

3. Crear la carpeta del proyecto y acceder a ella

Ejecuta el siguiente comando reemplazando mi-proyecto por el nombre que deseas:

Terminal

mkdir //PROJECT// #(1)!
cd //PROJECT// #(2)!

Crea la carpeta del proyecto
Ingresa a la carpeta creada anteriormente

4. Crear el entorno virtual

Terminal

python3 -m venv .venv

5. Activar el entorno virtual

Terminal

source .venv/bin/activate

Una vez activado, deberías ver (.venv) al comienzo de la terminal.

6. Instalar Django en el entorno virtual

Una vez que el entorno virtual está activado, instala Django con el siguiente comando:

Terminal

(.venv) pip install django

7. Generar un nuevo

Con la herramienta django-admin y el comando startproject se puede generar automáticamente la estructura inicial de un nuevo proyecto Django.

Terminal

(.venv) django-admin startproject _site .

Utilizamos un punto . al final del comando para generar el proyecto en el directorio actual, evitando que Django cree una carpeta adicional con el nombre del proyecto.

8. Archivos del proyecto

Una vez generado, tendrás disponible el archivo manage.py en el proyecto:

Archivos del proyecto

 mi-proyecto
├──  _site
│   ├──  __init__.py #(1)!
│   ├──  asgi.py #(2)!
│   ├──  settings.py #(3)!
│   ├──  urls.py #(4)!
│   └──  wsgi.py #(5)!
├──  .venv #(6)!
└──  manage.py #(7)!

Inicializa el paquete Python del proyecto Django.
Configura el punto de entrada ASGI para servidores asíncronos.
Contiene la configuración principal del proyecto Django.
Define las rutas y URLs del proyecto.
Configura el punto de entrada WSGI para servidores web tradicionales.
Contiene el entorno virtual de Python del proyecto.
Permite administrar el proyecto mediante comandos de Django.

El archivo manage.py permite administrar y ejecutar distintas tareas del proyecto Django, como iniciar el servidor de desarrollo, ejecutar migraciones y crear aplicaciones.

Ahora, podemos ejecutar el siguiente comando para ingresar al shell de Django.

Terminal

python manage.py shell

Podemos observar como entra en modo interactivo, invitandonos a escribir nuevas instrucciones.

Info

Para salir del modo interactivo, debes escribir exit() o con la combinación de teclas Ctrl+D

¿Qué es un ORM?¶

Un ORM (Object-Relational Mapping) es una técnica que permite interactuar con bases de datos relacionales mediante objetos y código del lenguaje de programación, evitando escribir SQL directamente. Django ORM implementa este enfoque en Python, permitiendo crear, consultar, actualizar y eliminar registros mediante modelos y métodos.

Sus componentes principales son:

Modelos: Clases de Python que representan las tablas de la base de datos. Sus atributos representan las columnas y heredan de models.Model.
Managers: Interfaces que permiten acceder a los modelos y construir consultas sobre sus datos. El manager predeterminado es objects.
QuerySets: Representan consultas sobre los datos de un modelo y permiten filtrar, ordenar y manipular registros. Son perezosos: métodos como filter() construyen la consulta sin ejecutarla inmediatamente. Esta se ejecuta cuando el QuerySet es evaluado, por ejemplo, al iterarlo o convertirlo en una lista.

Funcionamiento del ORM de Django

graph TD
    A[Aplicación Django] -->|Interacción| B[Modelos]

    subgraph ORM["ORM de Django"]
        B --> C[Managers]
        C --> D[QuerySets]

        D -->|Construye consulta| E[Consulta SQL]

        D --> F{¿Evaluado?}
        F -->|No| D
        F -->|Sí| E
    end

    E -->|Ejecuta| G@{ shape: cyl, label: "Base de Datos" }
    G -->|Resultados| D
    D -->|Objetos Python| A

Crear una aplicación¶

Antes de profundizar en el Shell de Django y los QuerySets del ORM, debemos crear una aplicación que nos permita definir modelos y realizar operaciones sobre la base de datos.

Asumiendo que ya tienes el proyecto generado siguiendo las instrucciones, podemos crear la aplicación products utilizando el archivo manage.py:

Terminal

python manage.py startapp products

Esto creará la estructura inicial de la aplicación, donde posteriormente definiremos nuestro modelo y comenzar a trabajar con él desde el Shell de Django.

Crear un modelo¶

Ahora podemos definir un modelo abriendo el archivo products/models.py y definir el siguiente modelo:

products/models.py
from django.db import models


class Product(models.Model):

    name = models.CharField(max_length=50)
    category = models.CharField(max_length=30)
    price = models.IntegerField()
    stock = models.IntegerField(default=0)

    def __str__(self):
        return self.name

Abrir el Modelo

 ...
├──  _site
└──  products/
    ├──  migrations/
    ├──  __init__.py
    ├──  admin.py
    ├──  apps.py
    ├──  models.py
    ├──  tests.py
    └──  views.py

Registrar la aplicación¶

Luego debemos abrir el archivo _mysite/settings.py y registrar la app generada:

_site/settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'products'
]

Abrir el archivo settings

 ...
└──  _site
    ├──  __init__.py
    ├──  asgi.py
    ├──  settings.py
    ├──  urls.py
    └──  wsgi.py

Con esto, Django reconocerá products como una aplicación perteneciente al proyecto.

Aplicar las migraciones¶

Luego generamos una nueva migración con el comando makemigrations y corremos las migraciones pendientes con el comando migrate:

Con esto, Django crea en SQLite la tabla correspondiente al modelo Product, dejándola lista para trabajar.

Operaciones ORM en el shell¶

Ahora podemos comenzar a realizar operaciones con el modelo Product desde el Shell de Django:

ComandoOutput

python manage.py shell

Insertar¶

En Django, una clase definida como modelo que hereda de models.Model representa una tabla de la base de datos una vez que se han aplicado las migraciones, mientras que una instancia de esa clase representa un registro particular dentro de ella. Al crear y guardar una instancia, estamos realizando una operación equivalente a una sentencia INSERT en SQL.

El ORM de Django proporciona dos métodos principales para insertar registros de forma individual. Uno permite crear y guardar el registro mediante una instancia del modelo, mientras que el otro utiliza el manager objects para crearlo directamente.

Método `save()`¶

Podemos crear un registro instanciando la clase del modelo y proporcionando los valores mediante argumentos de palabras clave. Luego, debemos llamar al método save() para guardar la instancia y confirmar el nuevo registro en la base de datos.

En el siguiente ejemplo, veremos cómo agregar un nuevo registro al modelo Product:

Ejemplo: inserción exitosa con save()

Código Python Shell Django

from products.models import Product #(1)!

producto = Product(name="Notebook", category="Electrónica", price=899990, stock=10) #(2)!
producto.save() #(3)!

Importamos la clase del modelo Product
Instanciamos la clase y la almacenamos en una variable
Invocamos al método save() para insertar el producto en la base de datos

>>> from products.models import Product
>>>
>>> producto = Product(name="Notebook", category="Electrónica", price=899990, stock=10)
>>> producto.save()
>>> exit()

Resultado

Si al ejecutar save() no se muestra ningún error en la Shell de Django, significa que el registro se guardó correctamente en la base de datos.

Consejo

El método save() es útil cuando necesitamos trabajar con la instancia antes de guardarla, por ejemplo, para realizar validaciones o modificar sus valores.

Método `create()`¶

Otra forma de insertar un registro en el modelo Product es mediante el método create() de su manager objects. Este método crea y guarda directamente el registro en la base de datos, por lo que no es necesario llamar a save() por separado.

El siguiente ejemplo muestra su uso:

Ejemplo: inserción exitosa con create()

Código Python Shell Django

from products.models import Product

Product.objects.create(name="Teclado", category="Periféricos", price=34990, stock=15)

>>> from products.models import Product
>>>
>>> Product.objects.create(name="Teclado", category="Periféricos", price=34990, stock=15)
<Product: Teclado>
>>> exit()

Resultado

Si observamos el resultado en la Shell, create() retorna la instancia de Product que acabamos de insertar. En este caso, <Product: Teclado> corresponde al objeto creado.

Consejo

El método create() es útil cuando queremos crear y guardar un registro directamente, sin necesidad de instanciar el modelo y llamar a save() por separado.

Insertar múltiples registros¶

Ahora veremos cómo insertar varios registros relacionados con Product. Para ello, crearemos un nuevo modelo Supplier que nos permitirá representar los proveedores de los productos.

Creamos la clase Supplier dentro de models.py en la aplicación:

products/models.py
class Supplier(models.Model):

    name = models.CharField(max_length=50)
    email = models.EmailField()
    product = models.ForeignKey(Product, on_delete=models.CASCADE)

    def __str__(self):
        return self.name

Abrir el Modelo

 ...
├──  _site
└──  products/
    ├──  migrations/
    ├──  __init__.py
    ├──  admin.py
    ├──  apps.py
    ├──  models.py
    ├──  tests.py
    └──  views.py

En la nueva clase Supplier, hemos definido los campos necesarios para representar a un proveedor y la hemos relacionado con el modelo Product mediante una llave foránea. De esta forma, cada proveedor queda asociado a un producto determinado. Además, definimos el método __str__() para representar el proveedor mediante su nombre.

Generamos una nueva migración y la aplicamos a la base de datos con el comando migrate:

Método `bulk_create()`¶

Ahora podemos volver a la Shell de Django e insertar múltiples registros en el modelo Supplier utilizando el método bulk_create(). Como el campo product es obligatorio, primero obtenemos el producto al que estarán asociados los proveedores y luego creamos todos los registros en una sola operación.

Ejemplo: insertar múltiples Supplier con bulk_create()

Código Python Shell Django

from products.models import Product, Supplier  # (1)!

product = Product.objects.get(name="Teclado")  # (2)!
Supplier.objects.bulk_create(  # (3)!
    [
        Supplier(
            name="TechStore",
            email="contacto@techstore.cl",
            product=product
        ),
        Supplier(
            name="ElectroMarket",
            email="ventas@electromarket.cl",
            product=product
        ),
        Supplier(
            name="Digital World",
            email="contacto@digitalworld.cl",
            product=product
        )
    ]
)

Importamos los modelos Product y Supplier que utilizaremos para realizar la inserción.
Obtenemos el producto Teclado que utilizaremos para asociarlo a los proveedores.
Utilizamos bulk_create() para insertar múltiples proveedores en una sola operación.

>>> from products.models import Product, Supplier
>>>
>>> product = Product.objects.get(name="Teclado")
>>> Supplier.objects.bulk_create(
...     [
...         Supplier(
...             name="TechStore",
...             email="contacto@techstore.cl",
...             product=product
...         ),
...         Supplier(
...             name="ElectroMarket",
...             email="ventas@electromarket.cl",
...             product=product
...         ),
...         Supplier(
...             name="Digital World",
...             email="contacto@digitalworld.cl",
...             product=product
...         )
...     ]
... )
[<Supplier: TechStore>, <Supplier: ElectroMarket>, <Supplier: Digital World>]
>>>

También podemos utilizar bulk_create() directamente con el modelo Product para insertar varios productos en una sola operación. En este caso, no necesitamos obtener previamente ningún objeto relacionado, ya que los campos definidos en Product son suficientes para crear cada registro.

Ejemplo: inserción múltiples Product con bulk_create()

Código Python Shell Django

from products.models import Product

Product.objects.bulk_create(
    [
        Product(
            name="Monitor",
            category="Periféricos",
            price=159990,
            stock=8
        ),
        Product(
            name="Webcam",
            category="Periféricos",
            price=45990,
            stock=12
        ),
        Product(
            name="Audífonos",
            category="Audio",
            price=29990,
            stock=20
        )
    ]
)

(.venv) ➜  python manage.py shell
Python 3.12.3 (main, Jun 19 2026, 12:46:00) [GCC 13.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from products.models import Product
>>> 
>>> Product.objects.bulk_create(
...     [
...         Product(
...             name="Monitor",
...             category="Periféricos",
...             price=159990,
...             stock=8
...         ),
...         Product(
...             name="Webcam",
...             category="Periféricos",
...             price=45990,
...             stock=12
...         ),
...         Product(
...             name="Audífonos",
...             category="Audio",
...             price=29990,
...             stock=20
...         )
...     ]
... )
[<Product: Monitor>, <Product: Webcam>, <Product: Audífonos>]
>>>

Ahora que ya hemos guardado objetos en la base de datos, vamos a continuar con la operación de obtener esos registros.

Listar¶

Para consultar registros en el ORM de Django utilizamos el manager objects del modelo. Sus métodos de consulta retornan un QuerySet, que representa una colección de objetos obtenidos desde la base de datos. A continuación, veremos los principales métodos para listar registros.

Método `all()`¶

El método all() nos permite obtener todos los objetos del modelo Supplier y retorna un QuerySet que contiene los registros almacenados en la base de datos:

Ejemplo: consulta con all()

Código Python Shell Django

from products.models import Supplier, Product

Supplier.objects.all()
Product.objects.all()

>>> from products.models import Supplier, Product
>>>
>>> Supplier.objects.all()
<QuerySet [<Supplier: TechStore>, <Supplier: ElectroMarket>, <Supplier: Digital World>]>
>>> Product.objects.all()
<QuerySet [<Product: Notebook>, <Product: Teclado>, <Product: Monitor>, <Product: Webcam>, <Product: Audífonos>]>
>>> exit()

Resultado

Si observamos el resultado en la Shell, all() retorna un QuerySet con los objetos de Product y Supplier almacenados en la base de datos. Cada objeto se muestra mediante su nombre, definido en el método __str__() de ambos modelos.

Consejo

El método all() es útil cuando necesitamos obtener todos los registros de un modelo sin aplicar filtros. El QuerySet obtenido puede utilizarse posteriormente para recorrer, inspeccionar o realizar otras operaciones sobre los objetos recuperados.

Obtener datos como diccionario¶

Como observamos en el resultado de all(), obtenemos un QuerySet con las instancias de los modelos. Para visualizar directamente los campos y valores de los registros contenidos en este QuerySet, podemos utilizar el método values(), que retorna los datos en forma de diccionarios.

Método `values()`¶

El método values() permite obtener los registros como diccionarios con los valores de sus campos.

Ejemplo: obtener los valores con values()

Código Python Shell Django

from products.models import Supplier, Product

Supplier.objects.all().values()
Product.objects.all().values()

>>> from products.models import Supplier, Product
>>>
>>> Supplier.objects.all().values()
<QuerySet [
    {'id': 1, 'name': 'TechStore', 'email': 'contacto@techstore.cl', 'product_id': 2},
    {'id': 2, 'name': 'ElectroMarket', 'email': 'ventas@electromarket.cl', 'product_id': 2},
    {'id': 3, 'name': 'Digital World', 'email': 'contacto@digitalworld.cl', 'product_id': 2}
]>
>>>
>>> Product.objects.all().values()
<QuerySet [
    {'id': 1, 'name': 'Notebook', 'category': 'Electrónica', 'price': 899990, 'stock': 10},
    {'id': 2, 'name': 'Teclado', 'category': 'Periféricos', 'price': 34990, 'stock': 15},
    {'id': 3, 'name': 'Monitor', 'category': 'Periféricos', 'price': 159990, 'stock': 8},
    {'id': 4, 'name': 'Webcam', 'category': 'Periféricos', 'price': 45990, 'stock': 12},
    {'id': 5, 'name': 'Audífonos', 'category': 'Audio', 'price': 29990, 'stock': 20}
]>
>>> exit()

Resultado

Si observamos el resultado en la Shell, values() retorna un QuerySet cuyos elementos son diccionarios con los valores de los campos de cada registro. Por lo tanto, all() permite trabajar directamente con los objetos del modelo, mientras que values() permite acceder a sus datos mediante las claves de los diccionarios.

Consejo

Utiliza el método values() cuando necesites obtener los datos de los registros como diccionarios, sin trabajar directamente con instancias del modelo. Puedes indicar los campos que deseas incluir en el resultado y combinar values() con métodos como all(), filter() y exclude() para determinar qué registros y qué información recuperar.

Método `get()`¶

Si queremos recuperar un solo registro, podemos utilizar el método get(). Sin embargo, si la consulta coincide con más de un registro, se producirá un error MultipleObjectsReturned.

Ejemplo: error MultipleObjectsReturned

Código Python Shell Django

from products.models import Supplier

Supplier.objects.get(product_id=2) #(1)!

La consulta coincide con 3 proveedores asociados al producto con id=2, por lo que get() genera la excepción MultipleObjectsReturned.

>>> from products.models import Supplier
>>>
>>> Supplier.objects.get(product_id=2)
Traceback (most recent call last):
File "<input>", line 1, in <module>
    Supplier.objects.get(product_id=2)
File "/home/mcherrera/.venv/lib/python3.12/site-packages/django/db/models/manager.py", line 87, in manager_method
    return getattr(self.get_queryset(), name)(*args, **kwargs)
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/mcherrera/.venv/lib/python3.12/site-packages/django/db/models/query.py", line 686, in get
    raise self.model.MultipleObjectsReturned(
products.models.Supplier.MultipleObjectsReturned: get() returned more than one Supplier -- it returned 3!
>>> exit()

El método get() es más apropiado cuando buscamos utilizando campos con valores únicos, como la llave primaria. En el siguiente ejemplo, utilizaremos el campo id para obtener un único objeto del modelo Product:

Ejemplo: consulta exitosa con get()

Código Python Shell Django

from products.models import Product

Product.objects.get(id=2)

>>> from products.models import Product
>>>
>>> Product.objects.get(id=2)
<Product: Teclado>
>>> exit()

Búsquedas¶

En el ORM de Django podemos filtrar los registros de un QuerySet utilizando búsquedas sobre los campos del modelo. Para especificar el tipo de búsqueda, utilizamos dos guiones bajos (__) entre el nombre del campo y el operador.

Por ejemplo, name__contains indica que queremos buscar en el campo name utilizando el operador contains.

Estas búsquedas permiten especificar condiciones que, internamente, son equivalentes a operadores utilizados en la cláusula WHERE de SQL.

Algunas de las búsquedas más utilizadas son:

ORM — contains

SQL — LIKE

Busca registros cuyo campo contenga un determinado texto.
ORM — range

SQL — BETWEEN

Busca registros cuyo valor se encuentre dentro de un intervalo.
ORM — gte

SQL — >=

Busca registros cuyo valor sea mayor o igual al valor indicado.
ORM — lte

SQL — <=

Busca registros cuyo valor sea menor o igual al valor indicado.

Los siguientes ejemplos muestran cómo utilizar estas búsquedas para filtrar registros de los modelos Product y Supplier desde la Shell de Django.

Operador - `contains`¶

Podemos buscar productos cuyo nombre contenga una determinada palabra o parte del texto utilizando el operador contains. Por ejemplo, busquemos los productos cuyo nombre incluya la palabra "Tecl":

Ejemplo: búsqueda exitosa con contains

Código Python Shell Django

from products.models import Product

Product.objects.filter(name__contains="Tecl")

>>> from products.models import Product
>>>
>>> Product.objects.filter(name__contains="Tecl")
<QuerySet [<Product: Teclado>]>
>>> exit()

Operadores `gte` y `lte`¶

Podemos utilizar gte y lte para filtrar registros según el valor de un campo numérico. gte permite obtener valores mayores o iguales, mientras que lte permite obtener valores menores o iguales.

Por ejemplo, podemos buscar productos cuyo precio sea mayor o igual a 100000 y productos cuyo stock sea menor o igual a 10:

Ejemplo: búsqueda con gte y lte

Python Shell Django

from products.models import Product

Product.objects.filter(price__gte=100000)
Product.objects.filter(stock__lte=10)

>>> from products.models import Product
>>>
>>> Product.objects.filter(price__gte=100000)
<QuerySet [<Product: Notebook>, <Product: Monitor>]>
>>> Product.objects.filter(stock__lte=10)
<QuerySet [<Product: Notebook>, <Product: Monitor>]>
>>> exit()

Operador `range`¶

El operador range permite filtrar registros cuyo valor se encuentre dentro de un intervalo determinado. Por ejemplo, podemos utilizarlo para buscar productos cuyo precio esté entre 30000 y 100000, o entre 30000 y 200000:

Ejemplo: búsqueda con range

Código Python Shell Django

from products.models import Product

Product.objects.filter(price__range=(30000, 100000))
Product.objects.filter(price__range=(30000, 200000))

>>> from products.models import Product
>>>
>>> Product.objects.filter(price__range=(30000, 100000))
<QuerySet [<Product: Teclado>, <Product: Webcam>]>
>>> Product.objects.filter(price__range=(30000, 200000))
<QuerySet [<Product: Teclado>, <Product: Monitor>, <Product: Webcam>]>
>>> exit()

Actualizar¶

En el ORM de Django podemos actualizar los registros de un modelo de distintas formas, dependiendo de si necesitamos modificar directamente los datos en la base de datos o trabajar primero con una instancia del modelo.

Las dos formas principales son:

update(): permite actualizar directamente uno o varios registros a partir de un QuerySet.
save(): permite modificar una instancia del modelo y luego guardar los cambios en la base de datos.

A continuación, veremos cada una de estas formas utilizando los modelos Product y Supplier.

Método `update()`¶

El método update() permite modificar directamente los campos de los registros que coincidan con una consulta realizada mediante filter().

En el siguiente ejemplo, actualizaremos el precio del producto con id=2, correspondiente a Teclado:

Ejemplo: actualización de un Product

Código Python Shell Django

from products.models import Product

Product.objects.get(id=2).price #(1)!
Product.objects.filter(id=2).update(price=39990) #(2)!
Product.objects.get(id=2).price #(3)!

Consultamos el precio actual del producto.
Actualizamos el precio del producto a 39990.
Consultamos nuevamente el precio para comprobar la actualización.

>>> from products.models import Product
>>>
>>> Product.objects.get(id=2).price
34990
>>> Product.objects.filter(id=2).update(price=39990)
1
>>> Product.objects.get(id=2).price
39990
>>> exit()

Método `save()` para actualizar¶

El método save() permite modificar una instancia del modelo y guardar los cambios realizados en la base de datos.

Ejemplo: actualización de un Supplier

Código Python Shell Django

from products.models import Supplier

supplier = Supplier.objects.get(id=1) #(1)!
supplier.email #(2)!
supplier.email = "soporte@techstore.cl" #(3)!
supplier.save() #(4)!
supplier.email #(5)!

Obtenemos el proveedor con id=1 para trabajar con su instancia.
Consultamos el correo actual.
Modificamos el correo electrónico del proveedor.
Guardamos los cambios en la base de datos mediante save().
Consultamos el correo actualizado para comprobar el cambio.

>>> from products.models import Supplier
>>>
>>> supplier = Supplier.objects.get(id=1)
>>> supplier.email
'contacto@techstore.cl'
>>> supplier.email = "soporte@techstore.cl"
>>> supplier.save()
>>> supplier.email
'soporte@techstore.cl'
>>> exit()

Eliminar¶

El ORM de Django proporciona el método delete() para eliminar registros de la base de datos. Al igual que las operaciones anteriores, podemos utilizarlo sobre una instancia específica o sobre un QuerySet, dependiendo de si queremos eliminar uno o varios registros.

Método `delete()` (eliminar un registro)¶

Para eliminar un registro específico, podemos obtener primero la instancia mediante get() y luego utilizar delete(). En el siguiente ejemplo, eliminaremos el Supplier con id=3:

Ejemplo: eliminación de un Supplier

Código Python Shell Django

from products.models import Supplier

Supplier.objects.all() #(1)!
Supplier.objects.get(id=3).delete() #(2)!
Supplier.objects.all() #(3)!

Consultamos los Supplier almacenados actualmente.
Obtenemos y eliminamos el Supplier con id=3.
Consultamos nuevamente los registros para comprobar la eliminación.

>>> from products.models import Supplier
>>>
>>> Supplier.objects.all()
<QuerySet [<Supplier: TechStore>, <Supplier: ElectroMarket>, <Supplier: Digital World>]>
>>> Supplier.objects.get(id=3).delete()
(1, {'products.Supplier': 1})
>>> Supplier.objects.all()
<QuerySet [<Supplier: TechStore>, <Supplier: ElectroMarket>]>
>>> exit()

Método `delete()` (eliminar múltiples registros)¶

El método delete() también puede utilizarse sobre un QuerySet para eliminar varios registros a la vez. Al utilizarlo junto con all(), se eliminan todos los registros del modelo. En este caso, eliminaremos los Supplier que aún permanecen en la base de datos:

Ejemplo: eliminar múltiples Supplier

Código Python Shell Django

from products.models import Supplier

Supplier.objects.all() #(1)!
Supplier.objects.all().delete() #(2)!
Supplier.objects.all() #(3)!

Consultamos los Supplier almacenados actualmente.
Eliminamos todos los Supplier mediante delete().
Consultamos nuevamente los registros para comprobar la eliminación.

>>> from products.models import Supplier
>>>
>>> Supplier.objects.all()
<QuerySet [<Supplier: TechStore>, <Supplier: ElectroMarket>]>
>>> Supplier.objects.all().delete()
(2, {'products.Supplier': 2})
>>> Supplier.objects.all()
<QuerySet []>
>>> exit()

Shell de Django, ORM y QuerySets

¿Qué es Django Shell?¶

Instrucciones: nuevo proyecto¶

¿Qué es un ORM?¶

Crear una aplicación¶

Crear un modelo¶

Registrar la aplicación¶

Aplicar las migraciones¶

Operaciones ORM en el shell¶

Insertar¶

Método save()¶

Método create()¶

Insertar múltiples registros¶

Método bulk_create()¶

Listar¶

Método all()¶

Obtener datos como diccionario¶

Método values()¶

Método get()¶

Búsquedas¶

Operador - contains¶

Operadores gte y lte¶

Operador range¶

Actualizar¶

Método update()¶

Método save() para actualizar¶

Eliminar¶

Método delete() (eliminar un registro)¶

Método delete() (eliminar múltiples registros)¶

Método `save()`¶

Método `create()`¶

Método `bulk_create()`¶

Método `all()`¶

Método `values()`¶

Método `get()`¶

Operador - `contains`¶

Operadores `gte` y `lte`¶

Operador `range`¶

Método `update()`¶

Método `save()` para actualizar¶

Método `delete()` (eliminar un registro)¶

Método `delete()` (eliminar múltiples registros)¶