Arquivo de Web - Área de Trampo

– Python
– Declarativa
1 – SQLAlchemy (ORM)
2 – Django Models
3 – List/dict comprehensions
4 – Regex (expressões regulares)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

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="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.

📌 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.

– Python
– Web
1 – Backend (servidor)
2 – Frontend (transpilado)
3 – APIs
4 –  Templates (Jinja2, Django Templates)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Templates são arquivos que misturam HTML com lógica simples. Eles geram páginas dinâmicas sem repetir código manualmente. Primeiramente, um template recebe dados do backend e os exibe. Por exemplo, {{ nome }} mostra o nome do usuário. Além disso, templates suportam loops e condicionais básicos. Assim, você consegue criar páginas ricas sem esforço repetitivo. Portanto, os dados se conectam ao HTML de forma direta. Quando utilizar templates? Em aplicações web com renderização no servidor. Também em e-mails HTML, relatórios ou documentos gerados dinamicamente. Python oferece dois sistemas principais: Jinja2 e Django Templates. Ambos são maduros, seguros e extensíveis. Então, vamos explorar suas características, diferenças e usos ideais. Três subtítulos guiarão sua jornada pelo mundo dos templates. Ao final, você saberá qual escolher para cada projeto.

Jinja2: flexível e multiplataforma

Jinja2 é o template engine mais popular fora do Django. Ele é usado pelo Flask, FastAPI, e muitas outras ferramentas. Quando usar Jinja2? Em projetos Flask ou em qualquer aplicação Python. Também é excelente para gerar código, e-mails ou arquivos de configuração. Primeiro, instale com pip install jinja2. Depois, crie templates com extensão .html ou .j2. A sintaxe é limpa e poderosa. Por exemplo, herança de templates funciona através de blocos nomeados. Além disso, você pode adicionar filtros personalizados facilmente. Exemplo completo de uso do Jinja2:

# Arquivo: template_exemplo.j2
<!DOCTYPE html>
<html>
<head>
    <title>{{ titulo }}</title>
</head>
<body>
    <h1>Olá, {{ usuario.nome }}!</h1>
    
    <ul>
    {% for item in lista %}
        <li>{{ loop.index }} - {{ item }}</li>
    {% endfor %}
    </ul>
    
    {% if usuario.logado %}
        <p>Você está logado desde {{ usuario.login_em.strftime('%d/%m/%Y') }}</p>
    {% else %}
        <a href="/login">Faça login</a>
    {% endif %}
    
    {{ texto | upper | truncate(100) }}
</body>
</html>

# Arquivo: app.py (uso com Flask ou puro)
from jinja2 import Environment, FileSystemLoader
from datetime import datetime

# Configurar o ambiente de templates
env = Environment(loader=FileSystemLoader('templates'))

# Dados para o template
dados = {
    'titulo': 'Página Inicial',
    'usuario': {
        'nome': 'Ana Silva',
        'logado': True,
        'login_em': datetime(2025, 1, 15, 14, 30)
    },
    'lista': ['Python', 'Jinja2', 'Templates', 'Web'],
    'texto': 'Este é um texto bem longo que será truncado pelo filtro.'
}

# Renderizar o template
template = env.get_template('template_exemplo.j2')
html_gerado = template.render(**dados)
print(html_gerado)  # Ou envie como resposta HTTP

# Arquivo: template_exemplo.j2

<!DOCTYPE html>

<html>

<head>

<title>{{ titulo }}</title>

</head>

<body>

<h1>Olá, {{ usuario.nome }}!</h1>

<ul>

{% for item in lista %}

<li>{{ loop.index }} - {{ item }}</li>

{% endfor %}

</ul>

{% if usuario.logado %}

<p>Você está logado desde {{ usuario.login_em.strftime('%d/%m/%Y') }}</p>

{% else %}

<a href="/login">Faça login</a>

{% endif %}

</body>

</html>

# Arquivo: app.py (uso com Flask ou puro)

from jinja2 import Environment, FileSystemLoader

from datetime import datetime

# Configurar o ambiente de templates

env = Environment(loader=FileSystemLoader('templates'))

# Dados para o template

dados = {

'titulo': 'Página Inicial',

'usuario': {

'nome': 'Ana Silva',

'logado': True,

'login_em': datetime(2025, 1, 15, 14, 30)

'lista': ['Python', 'Jinja2', 'Templates', 'Web'],

'texto': 'Este é um texto bem longo que será truncado pelo filtro.'

}

# Renderizar o template

template = env.get_template('template_exemplo.j2')

html_gerado = template.render(**dados)

print(html_gerado) # Ou envie como resposta HTTP

Jinja2 suporta filtros (como upper, truncate) e macros. Ele também permite funções personalizadas no ambiente. Portanto, é extremamente flexível para qualquer necessidade.

Django templates: integrado e seguro

Django Templates é o sistema nativo do framework Django. Ele é mais restritivo que o Jinja2 por razões de segurança. Quando usar Django Templates? Em projetos Django exclusivamente. A integração é perfeita e não requer configuração extra. A sintaxe é similar ao Jinja2, mas com diferenças sutis. Por exemplo, usa {% %} para lógica e {{ }} para variáveis. Além disso, os filtros também usam o pipe como separador. Exemplo de template Django:

<!-- templates/produtos/lista.html -->
{% extends "base.html" %}

{% block title %}Lista de Produtos{% endblock %}

{% block content %}
    <h2>Produtos disponíveis</h2>
    
    {% if produtos %}
        <table>
            <tr><th>Nome</th><th>Preço</th><th>Estoque</th></tr>
            {% for produto in produtos %}
                <tr>
                    <td>{{ produto.nome }}</td>
                    <td>R$ {{ produto.preco|floatformat:2 }}</td>
                    <td>
                        {% if produto.estoque > 0 %}
                            {{ produto.estoque }}
                        {% else %}
                            <span style="color:red">Esgotado</span>
                        {% endif %}
                    </td>
                </tr>
            {% empty %}
                <tr><td colspan="3">Nenhum produto cadastrado</td></tr>
            {% endfor %}
        </table>
    {% else %}
        <p>Carregando produtos...</p>
    {% endif %}
{% endblock %}

# views.py (Django)
from django.shortcuts import render
from .models import Produto

def lista_produtos(request):
    produtos = Produto.objects.all()
    return render(request, 'produtos/lista.html', {'produtos': produtos})

{% extends "base.html" %}

{% block title %}Lista de Produtos{% endblock %}

{% block content %}

<h2>Produtos disponíveis</h2>

{% if produtos %}

<table>

<tr><th>Nome</th><th>Preço</th><th>Estoque</th></tr>

{% for produto in produtos %}

<tr>

<td>{{ produto.nome }}</td>

<td>R$ {{ produto.preco|floatformat:2 }}</td>

<td>

{% if produto.estoque > 0 %}

{% else %}

<span style="color:red">Esgotado</span>

{% endif %}

</td>

</tr>

{% empty %}

<tr><td colspan="3">Nenhum produto cadastrado</td></tr>

{% endfor %}

</table>

{% else %}

<p>Carregando produtos...</p>

{% endif %}

{% endblock %}

# views.py (Django)

from django.shortcuts import render

from .models import Produto

def lista_produtos(request):

produtos = Produto.objects.all()

return render(request, 'produtos/lista.html', {'produtos': produtos})

Django Templates têm tags embutidas como {% url %} e {% csrf_token %}. Eles são mais lentos que Jinja2, mas perfeitamente adequados para 99% dos casos. A segurança contra XSS funciona automaticamente de forma rigorosa.

Jinja2 vs. django templates: qual escolher?

Jinja2 é mais rápido e flexível que Django Templates. Ele permite chamar funções Python diretamente no template. Django Templates são mais seguros e restritivos por design. Quando escolher Jinja2? Em projetos Flask, FastAPI ou fora do Django. Também quando você precisa de máxima liberdade sintática. Django Templates são ideais para projetos Django puros. A fórmula de performance pode ajudar na decisão: $P = \frac{T_{\text{Django}}}{T_{\text{Jinja2}}} \approx 1.5$ Portanto, Jinja2 é cerca de 50% mais rápido. No entanto, para a maioria das aplicações, a diferença é irrelevante. Ambos suportam herança, includes e filtros. Então, a escolha depende principalmente do seu framework principal. Se você usa Django, fique com Django Templates. Se usa Flask ou FastAPI, escolha Jinja2. Para projetos que geram e-mails ou relatórios, Jinja2 é mais versátil. Domine os dois e você estará preparado para qualquer cenário. Comece com o template engine do seu framework preferido. Depois, explore o outro para ampliar seus horizontes.

Django Models: Definindo Estruturas de Dados com Classe

Características fundamentais dos Django Models

Quando utilizar Django Models

Exemplo prático: blog com usuários e posts

Templates em Python

Jinja2: flexível e multiplataforma

Django templates: integrado e seguro

Jinja2 vs. django templates: qual escolher?