Camada de Templates no Django

Sintaxe da Camada de Templates e Passagem de Valores

Sintaxe Básica

Na camada de templates do Django, utiliza-se {% %} para lógica como carregamento de arquvios, loops for e condicionais if. Para variáveis, emprega-se {{ }}, permitindo transferir dados do backend para o frontend. O acesso a valores de variáveis pode ser feito diretamente via nome ou por meio de atribtuos usando ponto, com consulta em dicionários, atributos/métodos ou índices numéricos.

Preparação do Código

Crie uma view de classe no arquivo views.py da aplicação, herdando de View do Django. Defina métodos get e post para tratar requisições HTTP.

from django.views import View
from django.shortcuts import render, HttpResponse

class DemonstracaoView(View):
    def get(self, request, *args, **kwargs):
        # Lógica para requisição GET
        return render(request, 'modelo.html', locals())
    
    def post(self, request, *args, **kwargs):
        # Lógica para requisição POST
        return HttpResponse("Resposta da view POST")

Registre a view na rota raiz do projeto no arquivo urls.py principal.

from django.contrib import admin
from django.urls import path
from app.views import DemonstracaoView

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', DemonstracaoView.as_view(), name='demo'),
]

Configure arquivos estáticos criando uma pasta static no projeto e adicionando-a em settings.py via STATICFILES_DIRS. No template, carregue arquivos estáticos com {% load static %}.

Passagem de Tipos de Dados

No método get da view, defina variáveis de diferentes tipos.

class DemonstracaoView(View):
    def get(self, request, *args, **kwargs):
        inteiro = 660
        flutuante = 2.06
        texto = 'avril lavigne'
        lista = [11, 22, 'aa']
        dicionario = {'escola': 'mit', 'nota': 1}
        booleano = True
        conjunto = {4, 5, 'f'}
        tupla = (7, 8, 'i')
        return render(request, 'modelo.html', locals())

No template, exiba essas variáveis.

<body>
    <p>Inteiro: {{ inteiro }}</p>
    <p>Flutuante: {{ flutuante }}</p>
    <p>Texto: {{ texto }}</p>
    <p>Texto com título: {{ texto.title }}</p>
    <p>Lista: {{ lista }}</p>
    <p>Elemento da lista: {{ lista.0 }}</p>
    <p>Dicionário: {{ dicionario }}</p>
    <p>Chaves do dicionário: {{ dicionario.keys }}</p>
    <p>Valor do dicionário: {{ dicionario.escola }}</p>
    <p>Booleano: {{ booleano }}</p>
    <p>Conjunto: {{ conjunto }}</p>
    <p>Tupla: {{ tupla }}</p>
</body>

Passagem de Funções e Classes

Funções sem parâmetros podem ser passadas, e o template renderiza seu valor de retorno. Para classes, passe o nome da classe ou objetos; a exibição pode ser customizada com métodos como __str__.

class DemonstracaoView(View):
    def get(self, request, *args, **kwargs):
        def calculo():
            return 42
        
        class Artista:
            def cantar(self):
                return "Música"
            def __str__(self):
                return "Instância de Artista"
        
        artista1 = Artista()
        return render(request, 'modelo.html', locals())

No template:

<body>
    <p>Função: {{ calculo }}</p>
    <p>Classe: {{ Artista }}</p>
    <p>Objeto: {{ artista1 }}</p>
</body>

Filtros

Uso Básico

Filtros modificam a exibição de variáveis usando o operador |. Por exemplo, uma string HTML não é renderizada como código por padrão.

class DemonstracaoView(View):
    def get(self, request, *args, **kwargs):
        html_str = '<a href="">Link</a>'
        return render(request, 'modelo.html', locals())

<body>
    {{ html_str }}
</body>

Filtros Comuns

length: Calcula o comprimento de strings ou listas: {{ html_str|length }}.
default: Exibe um valor padrão se a variável for vazia ou falsa: {{ valor|default:"N/A" }}.
filesizeformat: Formata tamanhos de arquivo legíveis: {{ tamanho|filesizeformat }}.
date: Formata objetos datetime: {{ tempo|date:"Y-m-d H:i:s" }}.
slice: Faz fatias em listas ou strings: {{ texto|slice:"1:5" }}.
truncatechars: Trunca texto com reticências: {{ descricao|truncatechars:10 }}.
cut: Remove caracteres específicos: {{ frase|cut:" " }}.
join: Junta itens de iteráveis: {{ lista|join:", " }}.
add: Soma valores numéricos: {{ numero|add:5 }}.
safe: Converte strings para HTML seguro no frontend: {{ html_str|safe }}.

No backend, use mark_safe para marcar strings como seguras.

from django.utils.safestring import mark_safe

class DemonstracaoView(View):
    def get(self, request, *args, **kwargs):
        html_seguro = mark_safe('<b>Texto negrito</b>')
        return render(request, 'modelo.html', locals())

Componentes Personalizados

Criando Filtros e Tags

Na pasta templatetags da aplicação, crie um módulo Python. Registre filtros e tags personalizados.

from django import template

registro = template.Library()

@registro.filter
def filtro_personalizado(valor, arg):
    return valor + arg

@registro.simple_tag(name='nova_tag')
def tag_simples(a, b):
    return a * b

@registro.inclusion_tag('parcial.html')
def tag_inclusao(dados):
    return {'itens': dados}

No template, carregue o módulo e use os componentes.

{% load meus_tags %}

{{ variavel|filtro_personalizado:10 }}
{% nova_tag 2 3 %}
{% tag_inclusao itens %}

Herança de Templates

Implementação

Use {% extends %} para herdar de templates base e {% block %} para definir seções substituíveis.

{# template_base.html #}
<html>
<head>{% block css %}{% endblock %}</head>
<body>
    {% block conteudo %}{% endblock %}
    {% block js %}{% endblock %}
</body>
</html>

{# template_filho.html #}
{% extends 'template_base.html' %}

{% block conteudo %}
    <p>Conteúdo específico.</p>
{% endblock %}

Utilize {{ block.super }} para manter o conteúdo do template pai em um bloco.

Tags: Django Python HTML template-filters template-tags

Publicado em 6-13 21:36 por Thomas

Doido Dev