antonino, Autor em Área de Trampo

List e Dict Comprehensions: Elegância e Performance em Python

22/05/202623/04/2026 Por antonino

Comprehensions são uma sintaxe concisa para criar coleções. Elas existem para listas, dicionários e conjuntos. Primeiramente, elas substituem loops tradicionais com append. O resultado é um código mais limpo e legível. Além disso, comprehensions são geralmente mais rápidas. Isso acontece porque são otimizadas em C nativo. Por exemplo, [x*2 for x in range(10)] dobra números. Sem comprehension, você precisaria de três linhas. Portanto, o ganho de produtividade é significativo. Essa característica foi inspirada em Haskell e outras linguagens. Assim, Python ganhou uma ferramenta expressiva e poderosa.

Sintaxe e características das comprehensions

A sintaxe básica de list comprehension é:

$[\text{expressão} \text{ for } \text{item} \text{ in } \text{iterável} \text{ if } \text{condição}]$

Isso significa: para cada item, aplique a expressão. O if é opcional e filtra os elementos. Uma dict comprehension é similar, mas com chave e valor:

$\{\text{chave: valor} \text{ for } \text{item} \text{ in } \text{iterável}\}$

Primeiramente, evite aninhar muitas comprehensions. Duas ou três já prejudicam a legibilidade do código. Além disso, mantenha a condição if simples. Isso foi projetado para clareza, não para complexidade. Portanto, use comprehensions para transformações diretas.

Outra característica importante é a memória eficiente. Para listas muito grandes, use generator expressions. Elas usam parênteses em vez de colchetes. Por exemplo, (x*2 for x in range(10**6)). Isso não aloca a lista inteira na memória. Consequentemente, seu programa usa menos RAM. Essa dica é valiosa para processamento de grandes volumes.

Quando utilizar comprehensions no seu código

Use comprehensions para mapeamentos e filtros simples. Transformar uma lista aplicando uma função é ideal. Filtrar elementos baseado em uma condição também funciona bem. Por exemplo, pares de uma lista: [x for x in lista if x%2==0]. Outro bom uso é criar dicionários a partir de listas. Também são ótimas para inverter pares chave-valor. Por outro lado, evite comprehensions com efeitos colaterais. Imprimir ou salvar arquivos dentro delas confunde. Primeiramente, mantenha a expressão pura (sem side effects). Se o loop precisa de múltiplas linhas, use for tradicional. Além disso, não use para estruturas de dados aninhadas complexas. Isso foi percebido como anti-padrão pela comunidade. Portanto, valorize a legibilidade acima da concisão.

Outro bom uso é em testes de transformações de dados. Você pode rapidamente visualizar resultados no terminal. Cientistas de dados usam bastante essas construções. Use também para inicializar dicionários com valores padrão. Por exemplo, {nome:0 for nome in lista_nomes}. Isso cria um contador ou acumulador rapidamente. Portanto, dominar comprehensions é essencial em Python.

Exemplo prático: transformando listas e dicionários

O código abaixo mostra diversos usos de comprehensions. Começamos com listas e evoluímos para dicionários. Adicionamos condições para filtrar dados específicos. Também demonstramos aninhamento (com moderação). Por fim, comparamos performance com loops tradicionais. Observe como o tempo de execução é melhor. Isso ocorre principalmente para grandes volumes. Vamos ao código comentado para explorar cada caso.

import time

# ============================================
# EXEMPLO 1: LIST COMPREHENSION BÁSICA
# ============================================
print("=== List Comprehension ===")

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Loop tradicional
quadrados_loop = []
for n in numeros:
    quadrados_loop.append(n ** 2)
print(f"Loop: {quadrados_loop}")

# List comprehension (muito mais limpo)
quadrados_comp = [n ** 2 for n in numeros]
print(f"Comprehension: {quadrados_comp}")

# Com filtro: apenas pares
pares_quadrados = [n ** 2 for n in numeros if n % 2 == 0]
print(f"Pares ao quadrado: {pares_quadrados}")

# Com transformação dupla
texto = ["python", "é", "divertido"]
maisculo_comp = [palavra.upper() for palavra in texto]
print(f"Caixa alta: {maisculo_comp}")


# ============================================
# EXEMPLO 2: DICT COMPREHENSION
# ============================================
print("\n=== Dict Comprehension ===")

# Criando dicionário a partir de listas
frutas = ["maçã", "banana", "laranja", "uva"]
precos = [2.50, 1.80, 3.00, 5.50]

# Loop tradicional
tabela_loop = {}
for i in range(len(frutas)):
    tabela_loop[frutas[i]] = precos[i]
print(f"Loop: {tabela_loop}")

# Dict comprehension (mais elegante)
tabela_comp = {fruta: preco for fruta, preco in zip(frutas, precos)}
print(f"Comprehension: {tabela_comp}")

# Filtrando produtos caros (acima de R$ 3)
caros = {fruta: preco for fruta, preco in tabela_comp.items() if preco > 3}
print(f"Produtos caros: {caros}")

# Invertendo chave-valor
invertido = {preco: fruta for fruta, preco in tabela_comp.items()}
print(f"Dicionário invertido: {invertido}")

# Criando dicionário com operação
quadrados_dict = {n: n**2 for n in range(1, 6)}
print(f"Quadrados em dict: {quadrados_dict}")


# ============================================
# EXEMPLO 3: SET COMPREHENSION
# ============================================
print("\n=== Set Comprehension ===")

numeros_repetidos = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unicos_quadrados = {n**2 for n in numeros_repetidos}
print(f"Únicos elevados ao quadrado: {unicos_quadrados}")

# Vogais em uma string
frase = "Python é uma linguagem poderosa"
vogais = {letra for letra in frase.lower() if letra in 'aeiouáéíóú'}
print(f"Vogais encontradas: {vogais}")


# ============================================
# EXEMPLO 4: COMPREHENSIONS ANINHADAS (COM CUIDADO)
# ============================================
print("\n=== Comprehensions Aninhadas ===")

matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Achatar matriz (lista de listas para uma lista)
achatada = [num for linha in matriz for num in linha]
print(f"Matriz achatada: {achatada}")

# Matriz transposta
transposta = [[linha[i] for linha in matriz] for i in range(3)]
print(f"Matriz transposta: {transposta}")


# ============================================
# EXEMPLO 5: COMPARAÇÃO DE PERFORMANCE
# ============================================
print("\n=== Performance: Loop vs Comprehension ===")

# Criando uma lista grande
tamanho = 10_000_000

# Loop tradicional
inicio = time.time()
quadrados_loop = []
for i in range(tamanho):
    quadrados_loop.append(i ** 2)
fim = time.time()
print(f"Loop tradicional: {fim - inicio:.4f} segundos")

# Comprehension
inicio = time.time()
quadrados_comp = [i ** 2 for i in range(tamanho)]
fim = time.time()
print(f"List comprehension: {fim - inicio:.4f} segundos")

# Generator (economia de memória)
inicio = time.time()
quadrados_gen = (i ** 2 for i in range(tamanho))
# O generator ainda não foi executado (lazy)
fim = time.time()
print(f"Generator (criação): {fim - inicio:.6f} segundos")
print(f"Primeiro valor do generator: {next(quadrados_gen)}")


# ============================================
# EXEMPLO 6: USO EM PROBLEMAS REAIS
# ============================================
print("\n=== Problemas Reais com Comprehension ===")

# Dados de exemplo: vendas por vendedor
vendas = [
    ("Ana", 1500),
    ("Carlos", 2300),
    ("Ana", 800),
    ("Beatriz", 3100),
    ("Carlos", 1200),
    ("Ana", 500),
]

# Total de vendas por vendedor
total_por_vendedor = {}
for vendedor, valor in vendas:
    total_por_vendedor[vendedor] = total_por_vendedor.get(vendedor, 0) + valor
print(f"Total de vendas: {total_por_vendedor}")

# Filtrar vendedores que bateram meta (acima de 2000)
meta = 2000
acima_meta = {vendedor: total for vendedor, total in total_por_vendedor.items() if total > meta}
print(f"Acima da meta (R$: {meta}): {acima_meta}")

# Extrair nomes em maiúsculo (usando list comp)
nomes_maiusculo = [nome.upper() for nome in total_por_vendedor.keys()]
print(f"Nomes em maiúsculo: {nomes_maiusculo}")

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

import time

# ============================================

# EXEMPLO 1: LIST COMPREHENSION BÁSICA

# ============================================

print("=== List Comprehension ===")

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Loop tradicional

quadrados_loop = []

for n in numeros:

quadrados_loop.append(n ** 2)

print(f"Loop: {quadrados_loop}")

# List comprehension (muito mais limpo)

quadrados_comp = [n ** 2 for n in numeros]

print(f"Comprehension: {quadrados_comp}")

# Com filtro: apenas pares

pares_quadrados = [n ** 2 for n in numeros if n % 2 == 0]

print(f"Pares ao quadrado: {pares_quadrados}")

# Com transformação dupla

texto = ["python", "é", "divertido"]

maisculo_comp = [palavra.upper() for palavra in texto]

print(f"Caixa alta: {maisculo_comp}")

# ============================================

# EXEMPLO 2: DICT COMPREHENSION

# ============================================

print("\n=== Dict Comprehension ===")

# Criando dicionário a partir de listas

frutas = ["maçã", "banana", "laranja", "uva"]

precos = [2.50, 1.80, 3.00, 5.50]

# Loop tradicional

tabela_loop = {}

for i in range(len(frutas)):

tabela_loop[frutas[i]] = precos[i]

print(f"Loop: {tabela_loop}")

# Dict comprehension (mais elegante)

tabela_comp = {fruta: preco for fruta, preco in zip(frutas, precos)}

print(f"Comprehension: {tabela_comp}")

# Filtrando produtos caros (acima de R$ 3)

caros = {fruta: preco for fruta, preco in tabela_comp.items() if preco > 3}

print(f"Produtos caros: {caros}")

# Invertendo chave-valor

invertido = {preco: fruta for fruta, preco in tabela_comp.items()}

print(f"Dicionário invertido: {invertido}")

# Criando dicionário com operação

quadrados_dict = {n: n**2 for n in range(1, 6)}

print(f"Quadrados em dict: {quadrados_dict}")

# ============================================

# EXEMPLO 3: SET COMPREHENSION

# ============================================

print("\n=== Set Comprehension ===")

numeros_repetidos = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

unicos_quadrados = {n**2 for n in numeros_repetidos}

print(f"Únicos elevados ao quadrado: {unicos_quadrados}")

# Vogais em uma string

frase = "Python é uma linguagem poderosa"

vogais = {letra for letra in frase.lower() if letra in 'aeiouáéíóú'}

print(f"Vogais encontradas: {vogais}")

# ============================================

# EXEMPLO 4: COMPREHENSIONS ANINHADAS (COM CUIDADO)

# ============================================

print("\n=== Comprehensions Aninhadas ===")

matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Achatar matriz (lista de listas para uma lista)

achatada = [num for linha in matriz for num in linha]

print(f"Matriz achatada: {achatada}")

# Matriz transposta

transposta = [[linha[i] for linha in matriz] for i in range(3)]

print(f"Matriz transposta: {transposta}")

# ============================================

# EXEMPLO 5: COMPARAÇÃO DE PERFORMANCE

# ============================================

print("\n=== Performance: Loop vs Comprehension ===")

# Criando uma lista grande

tamanho = 10_000_000

# Loop tradicional

inicio = time.time()

quadrados_loop = []

for i in range(tamanho):

quadrados_loop.append(i ** 2)

fim = time.time()

print(f"Loop tradicional: {fim - inicio:.4f} segundos")

# Comprehension

inicio = time.time()

quadrados_comp = [i ** 2 for i in range(tamanho)]

fim = time.time()

print(f"List comprehension: {fim - inicio:.4f} segundos")

# Generator (economia de memória)

inicio = time.time()

quadrados_gen = (i ** 2 for i in range(tamanho))

# O generator ainda não foi executado (lazy)

fim = time.time()

print(f"Generator (criação): {fim - inicio:.6f} segundos")

print(f"Primeiro valor do generator: {next(quadrados_gen)}")

# ============================================

# EXEMPLO 6: USO EM PROBLEMAS REAIS

# ============================================

print("\n=== Problemas Reais com Comprehension ===")

# Dados de exemplo: vendas por vendedor

vendas = [

("Ana", 1500),

("Carlos", 2300),

("Ana", 800),

("Beatriz", 3100),

("Carlos", 1200),

("Ana", 500),

]

# Total de vendas por vendedor

total_por_vendedor = {}

for vendedor, valor in vendas:

total_por_vendedor[vendedor] = total_por_vendedor.get(vendedor, 0) + valor

print(f"Total de vendas: {total_por_vendedor}")

# Filtrar vendedores que bateram meta (acima de 2000)

meta = 2000

acima_meta = {vendedor: total for vendedor, total in total_por_vendedor.items() if total > meta}

print(f"Acima da meta (R$: {meta}): {acima_meta}")

# Extrair nomes em maiúsculo (usando list comp)

nomes_maiusculo = [nome.upper() for nome in total_por_vendedor.keys()]

print(f"Nomes em maiúsculo: {nomes_maiusculo}")

Nos exemplos, a diferença de sintaxe é clara. A versão com comprehension reduz drasticamente o código. Isso acontece sem perder legibilidade ou performance. Primeiramente, note a ausência de append() manual. Isso elimina um tipo comum de erro humano. Além disso, a intenção do código fica evidente. Qualquer programador Python entende rapidamente. Por exemplo, [x**2 for x in lista] é autoexplicativo. Já o loop equivalente exige leitura linha por linha. Portanto, comprehensions melhoram a comunicação do código. Use-as sempre que a transformação for clara e direta. Isso é considerado pythonico pela comunidade.

Outro ponto importante é a performance superior. No teste com 10 milhões de elementos, a diferença aparece. Comprehensions rodam em código C otimizado nativamente. Loops tradicionais têm overhead de interpretação por iteração. Isso foi medido e comprovado em diversos benchmarks. No entanto, a diferença só importa para grandes volumes. Para listas pequenas, a legibilidade é o fator principal. Primeiramente, escreva código claro e correto. Depois, se necessário, otimize onde houver gargalos. Portanto, não transforme todo loop em comprehension cegamente. Avalie o contexto e a complexidade da operação. Assim, você equilibra elegância e manutenibilidade.

✅ Quando usar
Mapeamento 1:1 (ex: quadrados)
Filtros simples (ex: pares)
Transformações de strings
Criação de dicionários
Conjuntos únicos
Inversão de pares

❌ Quando evitar
Side effects (print, salvar)
Lógica com muitas linhas
Aninhamento profundo
Tratamento de exceções
Recursão ou iteração complexa
Performance muito crítica

Finalmente, lembre-se das comprehensions para conjuntos. Use set quando a ordem não importar. Para dicionários, as chaves devem ser únicas. Repetições são resolvidas pela última ocorrência. Além disso, você pode usar condicionais múltiplas. Por exemplo, [x for x in lista if cond1 and cond2]. Isso é perfeitamente aceitável e legível. Evite, porém, if-else no final da expressão. Nesse caso, use expressao if cond else outra. Isso foi projetado para substituir operadores ternários. Portanto, explore todas as variantes disponíveis. A prática leva à maestria nesse recurso versátil.

Django Models: Definindo Estruturas de Dados com Classe

22/05/202623/04/2026 Por antonino

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 é:

$\text{QuerySet} = \text{Model.objects.filter(condição)}$

Isso retorna um conjunto iterável de objetos. Primeiramente, entenda que os QuerySets são lazy. Eles só executam quando você realmente precisa dos dados. Portanto, a performance é otimizada automaticamente.

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.

# 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")
"""

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="[email protected]",

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.

📌 Resumo dos tipos de campos mais comuns:

CharField TextField IntegerField FloatField BooleanField DateField DateTimeField EmailField URLField ForeignKey ManyToManyField OneToOneField

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.