Resumo : neste tutorial, você aprenderá sobre modelos Django e como criar modelos para sua aplicação Django.
Este tutorial começa onde o tutorial de criação de templates do Django parou.
Introdução aos modelos Django
No Django, um modelo é uma subclasse da django.db.models.Model
classe. Um modelo contém um ou mais campos e métodos que manipulam os campos.
Essencialmente, um modelo Django é mapeado para uma única tabela no banco de dados na qual cada campo do modelo representa uma coluna na tabela.
Um aplicativo pode ter zero ou mais modelos armazenados no models.py
módulo. Por exemplo, o seguinte define um Post
modelo para o blog
aplicativo:
from django.db import models
from django.utils import timezone
class Post(models.Model):
title = models.CharField(max_length=120)
content = models.TextField()
published_at = models.DateTimeField(default=timezone.now)
Linguagem de código: Python ( python )
O Post
modelo possui os campos title
, content
e published_at
. Baseado no Post
modelo, o Django criará uma tabela no banco de dados com o seguinte código SQL:
CREATE TABLE "blog_post" (
"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
"title" varchar(120) NOT NULL,
"content" text NOT NULL,
"published_at" datetime NOT NULL,
);
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Observe que o SQL gerado acima é para SQLite . Se você usar um banco de dados diferente, verá que o código SQL é um pouco diferente.
O nome da tabela blog_post
é derivado automaticamente dos nomes do aplicativo e do modelo:
application.model
Linguagem de código: Python ( python )
Neste exemplo, o Django criará uma tabela blog_post
para o Post
modelo.
Para especificar um nome de tabela em vez de usar o nome padrão gerado pelo Django, você pode usar o db_table
atributo da Meta
classe assim:
from django.db import models
from django.utils import timezone
class Post(models.Model):
title = models.CharField(max_length=120)
content = models.TextField()
published_at = models.DateTimeField(default=timezone.now)
class Meta:
db_table = 'posts'
Linguagem de código: Python ( python )
Nesse caso, o Post
modelo será mapeado para a posts
tabela em vez da blog_post
tabela gerada. Neste tutorial, ficaremos com o nome da tabela gerada padrão blog_post
.
Ao criar uma tabela, o Django adiciona automaticamente o id
campo como chave primária da tabela. O id
campo é um campo de incremento automático com o tipo especificado no settings.py
arquivo do projeto:
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
Linguagem de código: Python ( python )
Se quiser especificar seu próprio campo de chave primária, você precisará defini-lo explicitamente no modelo como este:
post_id = models.BigAutoField(primary_key=True)
Linguagem de código: Python ( python )
Neste exemplo, the primary_key=True
indica que the post_id
é uma chave primária . Quando o Django vê um campo no modelo com primary_key=True
, ele não adiciona a id
coluna automática.
O Django exige que cada modelo tenha exatamente um campo com a extensão primary_key=True
.
Usando modelos
Depois de definir os modelos, você precisa informar ao Django que irá utilizá-los registrando o nome da aplicação na INSTALLED_APPS
lista settings.py
do projeto:
INSTALLED_APPS = [
# ...
'blog.apps.BlogConfig',
]
Linguagem de código: Python ( python )
Modelos integrados
Django vem com alguns modelos integrados, como User
from django.contrib.auth.models
module. Para usar o User
modelo, você precisa importá-lo para o models.py
arquivo:
from django.contrib.auth.models import User
Linguagem de código: Python ( python )
Chaves estrangeiras
Cada postagem no blog
aplicativo é criada por um usuário e um usuário pode criar zero ou mais postagens. Isso é chamado de relacionamento um-para-muitos .
Para modelar o relacionamento um-para-muitos, você usa o ForeignKey
campo:
from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User
class Post(models.Model):
title = models.CharField(max_length=120)
content = models.TextField()
published_at = models.DateTimeField(default=timezone.now)
author = models.ForeignKey(User, on_delete=models.CASCADE)
Linguagem de código: Python ( python )
Baseado neste modelo, o Django criará a blog_post
tabela com a seguinte estrutura:
CREATE TABLE "blog_post" (
"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
"title" varchar(120) NOT NULL,
"content" text NOT NULL,
"published_at" datetime NOT NULL,
"author_id" integer NOT NULL
REFERENCES "auth_user" ("id")
DEFERRABLE INITIALLY DEFERRED
);
Linguagem de código: SQL (linguagem de consulta estruturada) ( sql )
Neste exemplo, auth_id
é uma chave estrangeira que cria um relacionamento entre blog_post
tabela e auth_user
tabela. Observe que a auth_user
tabela é a tabela fornecida pelo Django.
O método __str__()
Para definir a representação de string de um modelo, você pode substituir o __str__()
método. Por exemplo:
from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User
class Post(models.Model):
title = models.CharField(max_length=120)
content = models.TextField()
published_at = models.DateTimeField(default=timezone.now)
author = models.ForeignKey(User, on_delete=models.CASCADE)
def __str__(self):
return self.title
Linguagem de código: Python ( python )
Quando você usa a instância do modelo Post como uma string, o Django chama o __str__()
método e exibe seu resultado.
Adicionando Metaclasse à classe Model
A Meta
classe permite que você configure o modelo. Por exemplo, o seguinte define a Meta
classe dentro da Post
classe modelo que classifica as postagens em published_at
ordem decrescente ( -published_at
), ou seja, as postagens mais recentes primeiro e as postagens mais antigas depois.
from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User
class Post(models.Model):
title = models.CharField(max_length=120)
content = models.TextField()
published_at = models.DateTimeField(default=timezone.now)
author = models.ForeignKey(User, on_delete=models.CASCADE)
def __str__(self):
return self.title
class Meta:
ordering = ['-published_at']
Linguagem de código: Python ( python )
Após definir os modelos, você pode criar e aplicar migrações para criar tabelas no banco de dados, que abordaremos no próximo tutorial.
Baixe o código fonte do Projeto Django
Resumo
- Defina todos os modelos no
models.py
arquivo da aplicação Django. - Defina uma classe que herda de
django.db.models.Model
para criar um modelo. - Um modelo é mapeado para uma tabela no banco de dados, na qual cada campo é mapeado para uma coluna na tabela do banco de dados.
- Substitua
__str__()
o método para retornar uma representação de string de um modelo. - Use a
Meta
classe para configurar o modelo.