Django Models são a espinha dorsal de aplicações Django.
Eles definem como os dados são estruturados no banco.
Cada model vira uma tabela no banco de dados.
Primeiramente, você escreve classes Python comuns.
Cada atributo de classe vira uma coluna da tabela.
Isso é chamado de ORM (Mapeamento Objeto-Relacional).
Por exemplo, um model Produto vira tabela “produto”.
Os campos incluem CharField, IntegerField, entre outros.
Além disso, relacionamentos são muito intuitivos.
Use ForeignKey para ligações entre tabelas.
Portanto, você manipula objetos, não SQL.
Assim, o desenvolvimento fica mais rápido e seguro.
Características fundamentais dos Django Models
Uma característica central é a geração automática de schemas.
O Django cria tabelas e índices sem intervenção manual.
Outro ponto forte é a validação integrada dos campos.
Cada tipo de campo já valida os dados recebidos.
Por exemplo, EmailField verifica formato de e-mail.
Isso foi pensado para segurança e conveniência.
Além disso, os models têm uma API de consulta poderosa.
Você faz filtros com filter() e exclude().
Encadeie métodos para consultas complexas facilmente.
Uma fórmula que representa isso é:
Outra característica importante é o sistema de migrações.
O Django rastreia mudanças nos seus models.
Comandos como makemigrations geram scripts sob demanda.
Depois, migrate aplica essas mudanças no banco.
Isso foi inspirado em práticas de engenharia reversa.
Consequentemente, você versiona sua estrutura de dados.
Assim, equipes inteiras evoluem o banco sincronizadamente.
Quando utilizar Django Models
Use Django Models em qualquer aplicação web Django. Elas são obrigatórias no framework para persistência. Projetos de blog, e-commerce e redes sociais usam. Outro caso comum é em sistemas administrativos internos. Por outro lado, evite models para análises pesadas. Nesse cenário, pandas ou Spark são mais eficientes. Primeiramente, avalie se os dados são relacionais. Se sim, Django Models são uma excelente escolha. Se você precisa de flexibilidade de schemas, considere NoSQL. O Django não é ideal para bancos não-relacionais. Além disso, para scripts únicos de carga de dados, Use SQL direto, mais rápido e sem overhead. Portanto, Django Models brilham em aplicações transacionais.
Outro bom uso é em projetos de longo prazo. A manutenção é facilitada pela abstração do ORM. Novos desenvolvedores entendem rapidamente os models. Isso foi observado em empresas com equipes grandes. Use também para protótipos que podem crescer. O Django escala muito bem com otimizações pontuais. Portanto, é uma escolha profissional e segura.
Exemplo prático: blog com usuários e posts
O código abaixo simula um app Django completo.
Definimos dois models: Autor e Artigo.
Um autor pode ter vários artigos (relação 1:N).
Primeiramente, cada model herda de models.Model.
Depois, adicionamos campos com tipos específicos.
Incluímos também métodos personalizados nos models.
Por exemplo, __str__ controla a exibição no admin.
Outro método, publicar, altera o estado do artigo.
Observe como a lógica fica dentro do próprio model.
Isso é chamado de “model rico” (fat model).
Vamos ao código comentado para entendimento completo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 |
# Este código simula o arquivo models.py de um app Django # Para usar em um projeto real, execute dentro de um ambiente Django from django.db import models from django.utils import timezone from django.contrib.auth.models import User from django.urls import reverse # ============================================ # EXEMPLO 1: MODEL SIMPLES # ============================================ class Autor(models.Model): """Model para autores de artigos.""" # Campos básicos nome = models.CharField(max_length=100, verbose_name="Nome completo") email = models.EmailField(unique=True, verbose_name="E-mail") biografia = models.TextField(blank=True, verbose_name="Biografia") data_nascimento = models.DateField(null=True, blank=True) # Campos automáticos data_criacao = models.DateTimeField(auto_now_add=True) data_atualizacao = models.DateTimeField(auto_now=True) ativo = models.BooleanField(default=True) class Meta: ordering = ['nome'] verbose_name = 'Autor' verbose_name_plural = 'Autores' def __str__(self): return self.nome def get_absolute_url(self): """Retorna URL para detalhe do autor.""" return reverse('autor_detail', args=[self.id]) @property def total_artigos(self): """Propriedade calculada: conta artigos publicados.""" return self.artigos.filter(publicado=True).count() # ============================================ # EXEMPLO 2: MODEL COM RELACIONAMENTO # ============================================ class Artigo(models.Model): """Model para artigos do blog.""" # Opções para o campo status class Status(models.TextChoices): RASCUNHO = 'R', 'Rascunho' PUBLICADO = 'P', 'Publicado' ARQUIVADO = 'A', 'Arquivado' # Campos básicos titulo = models.CharField(max_length=200, unique=True) slug = models.SlugField(max_length=200, unique=True) conteudo = models.TextField() resumo = models.TextField(max_length=500, blank=True) # Relacionamento (ForeignKey) autor = models.ForeignKey( Autor, on_delete=models.CASCADE, related_name='artigos', verbose_name='Autor' ) # Datas data_criacao = models.DateTimeField(auto_now_add=True) data_publicacao = models.DateTimeField(null=True, blank=True) data_atualizacao = models.DateTimeField(auto_now=True) # Status status = models.CharField( max_length=1, choices=Status.choices, default=Status.RASCUNHO ) # Campos para SEO meta_descricao = models.CharField(max_length=160, blank=True) palavras_chave = models.CharField(max_length=200, blank=True, help_text="Separe por vírgulas") class Meta: ordering = ['-data_publicacao', '-data_criacao'] indexes = [ models.Index(fields=['slug']), models.Index(fields=['status', 'data_publicacao']), ] verbose_name = 'Artigo' verbose_name_plural = 'Artigos' def __str__(self): return self.titulo def get_absolute_url(self): """URL amigável para o artigo.""" return reverse('artigo_detail', args=[self.slug]) def publicar(self): """Método para publicar o artigo.""" if self.status == self.Status.RASCUNHO: self.status = self.Status.PUBLICADO self.data_publicacao = timezone.now() self.save() return True return False def arquivar(self): """Método para arquivar o artigo.""" if self.status == self.Status.PUBLICADO: self.status = self.Status.ARQUIVADO self.save() return True return False @property def esta_publicado(self): return self.status == self.Status.PUBLICADO @property def palavras_chave_lista(self): """Retorna lista de palavras-chave.""" return [p.strip() for p in self.palavras_chave.split(',') if p.strip()] # ============================================ # EXEMPLO 3: MODEL COM RELAÇÃO MANY-TO-MANY # ============================================ class Tag(models.Model): """Tags para categorizar artigos.""" nome = models.CharField(max_length=50, unique=True) slug = models.SlugField(max_length=50, unique=True) artigos = models.ManyToManyField(Artigo, related_name='tags', blank=True) data_criacao = models.DateTimeField(auto_now_add=True) class Meta: ordering = ['nome'] def __str__(self): return self.nome def get_absolute_url(self): return reverse('tag_detail', args=[self.slug]) @property def total_artigos(self): return self.artigos.count() # ============================================ # EXEMPLO 4: MODEL COM GERENCIADOR PERSONALIZADO # ============================================ class ArtigoManager(models.Manager): """Manager personalizado para consultas comuns.""" def publicados(self): """Retorna apenas artigos publicados.""" return self.filter(status=Artigo.Status.PUBLICADO) def recentes(self, limite=5): """Retorna os artigos mais recentes.""" return self.publicados().order_by('-data_publicacao')[:limite] def por_autor(self, autor_id): """Retorna artigos de um autor específico.""" return self.publicados().filter(autor_id=autor_id) # Para usar o manager personalizado, adicione ao model Artigo: # objects = ArtigoManager() # ============================================ # EXEMPLO DE USO (NO SHELL DO DJANGO) # ============================================ """ # Criar um autor autor1 = Autor.objects.create( nome="Ana Oliveira", email="ana@exemplo.com", biografia="Escritora e desenvolvedora Python" ) # Criar um artigo artigo = Artigo( titulo="Introdução ao Django", slug="introducao-django", conteudo="Django é um framework web poderoso...", resumo="Aprenda os fundamentos do Django", autor=autor1, status=Artigo.Status.RASCUNHO ) artigo.save() # Publicar o artigo artigo.publicar() # Consultar artigos publicados de um autor artigos_autor = Artigo.objects.filter(autor=autor1, status='P') print(f"Artigos publicados: {artigos_autor.count()}") # Usar o manager personalizado (se implementado) # artigos_recentes = Artigo.objects.recentes(3) # Buscar por palavra-chave artigos_python = Artigo.objects.filter(conteudo__icontains="Python") """ |
No exemplo, cada model é uma classe Python comum.
Os campos são definidos com tipos específicos do Django.
Os relacionamentos usam ForeignKey ou ManyToManyField.
Métodos como publicar() encapsulam regras de negócio.
Propriedades como total_artigos calculam valores dinamicamente.
Isso mantém as views e templates mais limpos.
Além disso, o Django cria automaticamente o banco.
Não é necessário escrever nenhuma linha de SQL.
Primeiramente, execute python manage.py makemigrations.
Depois, python manage.py migrate para aplicar.
Assim, você tem um banco funcional em segundos.
Portanto, a produtividade é imensamente superior.
Outro ponto importante é o painel administrativo.
Registre seus models no admin.py com uma linha.
Você ganha uma interface CRUD completa automaticamente.
Isso foi pensado para acelerar o desenvolvimento de backoffice.
Por exemplo, admin.site.register(Autor) é suficiente.
O Django gera formulários, listagens e buscas.
Isso é incrível para protótipos e MVPs.
Além disso, você pode personalizar tudo facilmente.
Portanto, Django Models são uma escolha poderosa.
Use-os com confiança em seus próximos projetos.
Finalmente, lembre-se de documentar seus models.
Use help_text nos campos para explicações.
Isso ajuda outros desenvolvedores no futuro.
Além disso, mantenha as migrações versionadas no Git.
Nunca edite migrações manualmente a menos que necessário.
Nunca exclua uma migração já aplicada em produção.
Isso pode corromper o estado do banco de dados.
Primeiramente, planeje bem a estrutura dos dados.
Depois, evolua os models com migrações novas.
Assim, você evita dores de cabeça no futuro.
Portanto, Django Models são robustos e confiáveis.
Aprenda-os bem e você construirá sistemas incríveis.