Criando e Recuperando Objetos de Modelos - Django

O Django oferece métodos para criar e recuperar objetos de modelos diretamente do banco de dados. A seguir, são apresentados detalhes sobre esses métodos, usando como exemplo o modelo Person:

from django.db import models
 
class Person(models.Model):
    name = models.CharField(max_length=20)
    age = models.IntegerField()

Adicionando Objetos ao Banco de Dados

create()

O método create() cria e salva um novo objeto no banco de dados:

tom = Person.objects.create(name="Tom", age=23)
print(tom.id)

Após a criação, o ID do objeto pode ser acessado por meio do atributo id.

A versão assíncrona, chamada acreate(), permite adicionar objetos ao banco de dados de forma assíncrona:

from .models import Person
import asyncio

async def acreate_person():
    person = await Person.objects.acreate(name="Sam", age=26)
    print(person.name)

asyncio.run(acreate_person())

save()

Além disso, é possível criar e salvar objetos separadamente usando o método save():

tom = Person(name="Tom", age=23)
tom.save()
print(tom.id)

bulk_create()

Para criar múltiplos objetos de forma eficiente, o método bulk_create() permite passar uma lista de instâncias para serem adicionadas ao banco de dados:

from .models import Person

people = Person.objects.bulk_create([
    Person(name="Kate", age=24),
    Person(name="Ann", age=21),
])

for person in people:
    print(f"{person.id}. {person.name}")

Recuperando Objetos do Banco de Dados

get()

O método get() busca um único objeto que atende a um critério específico:

tom = Person.objects.get(name="Tom")
bob = Person.objects.get(age=23)

Esse método deve ser usado com cuidado, pois gera exceções caso nenhum objeto seja encontrado (DoesNotExist) ou se mais de um objeto atender ao critério (MultipleObjectsReturned). O tratamento de exceções pode ser usado para evitar erros:

from .models import Person
from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned

try:
    tom = Person.objects.get(name="Tom")
    alex = Person.objects.get(name="Alex")
except ObjectDoesNotExist:
    print("O objeto não existe.")
except MultipleObjectsReturned:
    print("Mais de um objeto encontrado.")

A versão assíncrona do get() é chamada aget() e é útil em contextos assíncronos:

from .models import Person
import asyncio

async def get_person():
    person = await Person.objects.aget(id=1)
    print(person.name)

asyncio.run(get_person())

get_or_create()

Além disso, existe o método get_or_create(), que busca um objeto com os critérios fornecidos e o cria caso não exista:

bob, created = Person.objects.get_or_create(name="Bob", age=24)
print(created)  # True se o objeto foi criado, False se já existia
print(bob.name, bob.age) # Bob 24

all()

Para recuperar todos os objetos de uma tabela, o método all() retorna um QuerySet completo:

people = Person.objects.all()

filter()

Filtros podem ser aplicados para recuperar objetos específicos:

people = Person.objects.filter(age=23)
people2 = Person.objects.filter(name="Tom", age=23)

exclude()

Já o método exclude() exclui objetos da consulta que atendem a um critério específico:

Os métodos filter() e exclude() podem ser combinados para consultas mais complexas:

people = Person.objects.filter(name="Tom").exclude(age=23)

in_bulk()

Para recuperar objetos com base em uma lista de IDs, o método in_bulk() é útil:

# Recupera todos os objetos
people1 = Person.objects.in_bulk()
    
# Recupera os objetos com IDs 1 e 3
people2 = Person.objects.in_bulk([1, 3])

Limitando a Quantidade de Objetos Recuperados

A sintaxe de slicing pode ser usada para limitar os resultados de um QuerySet. Para obter os primeiros 5 objetos:

people = Person.objects.all()[:5]

Para ignorar os primeiros 5 objetos e obter os próximos 5:

people = Person.objects.all()[5:10]

No nível SQL, isso é traduzido para LIMIT e OFFSET.