O guia definitivo dos templates do Django
Os templates do Django são uma parte crucial desse framework. Compreender o que são e por que são úteis pode ajudar você a criar templates consistentes, adaptáveis e funcionais para os seus sites e aplicativos em Django.
Se você for novato nesse framework e estiver procurando configurar o seu primeiro projeto no Django, é vital dominar os templates. Neste guia, você encontrará tudo que precisa saber sobre os templates do Django, incluindo seus diferentes tipos e como usá-los.
O que são templates no Django?
Os templates são uma parte fundamental do framework Django. Eles permitem que você separe a apresentação visual do seu site do código subjacente. Um template contém as partes estáticas da saída desejada em HTML, além de uma sintaxe especial que descreve como será incluído o conteúdo dinâmico.
Em última instância, os templates podem gerar páginas completas de Web, enquanto as visualizações e modelos cuidam das consultas a bancos de dados e outras tarefas de processamento de dados. Essa separação garante um código limpo e fácil de manter, ao separar a lógica de negócios em HTML do código em Python no resto do seu projeto do Django. Sem os templates, você precisaria incluir o código em HTML diretamente dentro do seu código em Python, que ficaria difícil de ler e depurar.
Veja um exemplo de um template do Django contendo algum código em HTML, uma variável name e alguma lógica básica de if/else:
Welcome!
{% if name %}
Hello, {{ name }}!
{% else %}
Hello, Guest!
{% endif %}
{{ heading }}
Benefícios do uso de templates
Os desenvolvedores usam templates do Django para ajudá-los a criarem aplicativos confiáveis de forma rápida e eficiente. Outros benefícios importantes dos templates incluem:
- Código reutilizável: Pode-se criar componentes e layouts reutilizáveis para manter a consistência entre páginas e aplicativos.
- Manutenção mais fácil: A aparência das páginas Web pode ser modificada sem alterar a lógica subjacente.
- Melhor legibilidade: Pode-se manter o código em HTML limpo e compreensível, sem necessidade de uma lógica complexa.
- Herança de templates: Pode-se definir estruturas e layouts comuns para reduzir a duplicação e promover a consistência.
- Conteúdo dinâmico: É possível criar páginas Web personalizadas que se adaptam aos dados de entrada do usuário e a variações nos dados.
- Otimização de desempenho: Os templates podem ser colocadas em cache para melhorar o desempenho do aplicativo ou Web site.
Desafios e limitações
Embora os templates sejam essenciais para renderizar páginas Web no Django, eles devem ser usados com critério, especialmente em projetos complexos com conjuntos de dados maiores. Apesar da relativa simplicidade da linguagem de templates do Django, templates complexos demais, com inúmeras tags aninhadas, filtros e heranças, podem ficar difíceis de gerenciar e manter. Em vez de incorporar um excesso de lógica aos seus templates, procure manter o foco deles na apresentação. As opções de personalização também são limitadas, a menos que você crie os seus próprios filtros e tags personalizados.
Migrar para um outro mecanismo de templates pode ser um desafio, pois o mecanismo-padrão do Django é intimamente ligado ao framework. Porém, mudar para uma alternativa como o Jinja é relativamente simples e discutiremos essa possibilidade mais adiante neste guia.
Depuração de templates do Django
Em algumas situações, como quando aparecem problemas, pode ser útil ver como funciona o seu template. Para isso, você pode usar a depuração de templates.
A depuração de templates concentra-se em identificar erros na forma como o código em HTML e os dados dinâmicos interagem. Alguns problemas comuns são variáveis faltando, tags incorretas no template e erros de lógica.
Por sorte, o Django oferece ferramentas úteis como a {{ debug }} para inspecionar os seus templates, além de páginas de erro detalhadas que apontam onde está o problema. Isso facilita identificar e resolver problemas, garantindo que os seus templates sejam renderizados conforme o esperado.
Compreendendo a linguagem de templates do Django (Django Template Language — DTL)
A linguagem de templates do Django (Django Template Language — DTL) é o mecanismo de templates do framework, projetada para simplificar a criação de páginas Web dinâmicas. Ela associa de forma transparente o código em HTML a tags e filtros específicos do Django, permitindo que você gere conteúdo rico e orientado por dados diretamente a partir do seu aplicativo Django. Vamos explorar alguns dos principais recursos que tornam a DTL uma ferramenta poderosa para criar templates.
Sintaxe e estrutura básicas da DTL
Os templates do Django são escritos em uma combinação das sintaxes de HTML e DTL. A estrutura básica de um template do Django consiste de marcação de HTML com tags e variáveis do Django embutidas nela.
Veja um exemplo:
{{ heading }}
-
- {% for item in item_list %}
- {{ item.name }}
{% endfor %}
Variáveis, filtros e tags
A DTL tem vários recursos para trabalhar com variáveis, filtros e tags:
- Variáveis: As variáveis exibem dados dinâmicos nos seus templates. Elas ficam entre chaves duplas, como por exemplo
{{ variable_name }}. - Filtros: Os filtros modificam ou formatam o valor de uma variável antes de renderizá-la. Eles são aplicados usando uma barra vertical ( | ); por exemplo,
{{ variable_name|upper }}. - Tags: As tags controlam a lógica e o fluxo dos seus templates. Elas ficam dentro de blocos
{% %}e podem efetuar várias operações, como loops, condições e inclusões de templates.
O PyCharm, um IDE profissional para o desenvolvimento com o Django, simplifica o trabalho com templates do Django, fornecendo realce de sintaxe, que aplica padrões de cores a tags, variáveis e código em HTML para melhor legibilidade. Ele também oferece detecção de erros em tempo real, garantindo que você não deixe de fechar tags, nem use a sintaxe incorreta. Com complementação automática de variáveis e tags, você pode programar mais rapidamente e com menos erros.
Herança de templates e extensão de templates básicos
O sistema de herança de templates do Django permite que você crie um template básico contendo a estrutura-padrão e o layout do seu Web site ou aplicativo.
Em seguida, você pode criar templates-filhos que herdam as características do template básico e substituem blocos específicos de seções, conforme a necessidade. Isso encoraja a reutilização de código e a consistência entre os seus diferentes templates.
Para criar um template básico, define-se um bloco usando a tag {% block %}:
{% block content %}
{% endblock %}
Depois, os templates-filhos estendem os templates básicos e substituem certos blocos:
{% extends 'base.html' %}
{% block title %}My Page Title{% endblock %}
{% block content %}
My Page Content
This is the content of my page.
{% endblock %}
Tags de templates do Django
Tags são um elemento essencial dos templates do Django. Elas disponibilizam várias funções, desde loops e renderizações condicionais até a herança e a inclusão de templates.
Vamos explorá-las em mais detalhes.
Tags comuns de templates do Django
Há várias tags de templates no Django, mas estas são as que você provavelmente usará com mais frequência:
{% if %}: Esta tag permite que você renderize ou não conteúdo com base em uma condição específica. Ela costuma ser usada com as tags{% else %}e{% elif %}.{% for %}: Esta tag é usada para iterar em uma sequência, como uma lista ou conjunto de consultas, e renderizar conteúdo para cada item da sequência.{% include %}: Esta tag permite incluir o conteúdo de outro arquivo de template dentro da template atual. Ela facilita a reutilização de trechos comuns de templates em vários outros templates.{% block %}: Esta tag é usada em conjunto com a herança de templates. Ela define um bloco de conteúdo que pode ser substituído pelos templates-filhos ao estenderem um template básico.{% extends %}: Esta tag especifica o template básico cujos atributos o template atual deve herdar.{% url %}: Esta tag é usada para gerar uma URL para um padrão nomeado de URL no seu projeto do Django. Ela ajuda a manter os seus templates dissociados dos caminhos reais das URLs.{% load %}: Esta tag é usada para carregar tags e filtros personalizados de templates a partir de um módulo ou biblioteca do Python, permitindo estender a funcionalidade do sistema de templates do Django.
Estes são apenas alguns exemplos das muitas tags de templates disponíveis no Django. Tags como {% with %}, {% cycle %}, {% comment %} e outras podem fornecer funções adicionais para projetos avançados, ajudando a criar aplicativos personalizados e eficientes.
Como usar tags de templates
Aqui está um exemplo detalhado de como você poderia usar tags em um template do Django:
{% extends 'base.html' %}
{% load custom_filters %}
{% block content %}
{{ page_title }}
{% if object_list %}
-
- {% for obj in object_list %}
- {{ obj.name|truncate:25 }}
{% endfor %}
{% else %}
No objects found.
{% endif %}
{% include 'partials/pagination.html' %}
{% endblock %}
Neste exemplo, estendemos um template básico, carregamos filtros personalizados e depois definimos um bloco para o conteúdo principal.
Dentro do bloco, verificamos se existe object_list. Se existir, fazemos um loop através dessa lista e mostramos os nomes truncados de cada objeto. Se a lista estiver vazia, mostramos a mensagem “No objects found”.
Por fim, incluímos uma template parcial para paginação. Esse template é um trecho reutilizável de código em HTML que pode ser incluído em outros templates, permitindo que você gerencie e atualize elementos comuns (como a paginação) de forma mais eficiente.
Templates administrativos do Django
A interface administrativa incluída no Django é uma maneira amigável e intuitiva de gerenciar dados de aplicativos. Ela funciona através de um conjunto de templates que definem sua estrutura, seu layout e sua aparência.
Funcionalidade
Os templates administrativos do Django desempenham diversas tarefas:
- Autenticação: Controla a autenticação, o login e o logout dos usuários.
- Gerenciamento de modelos: Mostra listas de instâncias de modelos e cria, edita e exclui instâncias, conforme a necessidade.
- Renderização de formulários: Renderiza formulários para criar e editar instâncias de modelos.
- Navegação: Renderiza a estrutura de navegação da interface administrativa, incluindo o menu principal e submenus específicos de cada aplicativo.
- Paginação: Renderiza controles de paginação ao mostrar listas de instâncias de modelos.
- Histórico: Mostra e gerencia o histórico de alterações das instâncias de modelos.
Os templates administrativos incorporados ao Django fornecem uma base sólida para gerenciar os dados do seu aplicativo.
Personalização de templates administrativos
Embora os templates administrativos do Django ofereçam uma interface satisfatória e funcional desde a instalação, talvez você queira personalizar a aparência ou o comportamento dele para atender às necessidades específicas do seu projeto.
Você pode mudar elementos para corresponderem ao branding do seu projeto, melhorar a experiência do usuário ou adicionar recursos personalizados, exclusivos do seu aplicativo.
Há várias maneiras de fazer isso:
- Substituição de templates: Você pode substituir os templates administrativos padrão, criando templates com a mesma estrutura de arquivos e as mesmas convenções de nomenclatura no diretório de templates do seu projeto. Assim, o Django usará automaticamente os seus templates personalizados, em vez dos seus próprios.
- Extensão de templates básicos: Muitos dos templates administrativos do Django usam herança de templates. Você pode criar templates que estendem os templates administrativos básicos e substituem seções ou blocos específicos.
- Opções de templates: O Django tem várias opções de templates que permitem personalizar o comportamento da interface administrativa. Isso inclui mostrar certos campos, especificar quais deles devem ser editáveis e definir templates personalizados para campos específicos do modelo.
- Personalização do site administrativo: Você pode personalizar a aparência e o comportamento do site administrativo criando subclasses da classe
AdminSitee registrando o seu site administrativo personalizado no Django.
Templates de URLs no Django
Os templates de URLs oferecem uma maneira flexível de definir e gerar URLs para aplicativos Web no Django.
Compreendendo os templates de URLs
No Django, você define padrões de URLs no arquivo “urls.py” do projeto, usando a função “path” do módulo “django.urls”.
Alguns desses padrões de URLs são mapeados a funções (visualizações) do Python que processam as solicitações correspondentes de HTTP.
Veja um exemplo de padrão básico de URL no Django:
# urls.py
from django.urls import path
from . import views
urlpatterns = [
path('', views.home, name='home'),
path('about/', views.about, name='about'),
]
Neste exemplo, os padrões de URLs ' ' e 'about/' são mapeados às funções de visualização views.home e views.about, respectivamente.
Geração dinâmica de URLs com templates de URLs
Os templates de URLs do Django permitem incluir variáveis ou parâmetros em padrões de URLs. Isso significa que você pode criar URLs dinâmicas que representam diferentes instâncias do mesmo recurso ou incluem dados adicionais.
Se o seu arquivo “urls.py” incluir outros arquivos de URLs através de include(), o PyCharm automaticamente reúne e reconhece todas as rotas aninhadas, garantindo que as sugestões de nomes de URLs continuem exatas. Você também pode navegar até as definições de URLs dando um Ctrl+clique no nome de uma URL para saltar diretamente ao código-fonte correspondente, mesmo se a URL estiver definida em um arquivo-filho.
Vamos dar uma olhada em um exemplo de template de URL com uma variável:
# urls.py
urlpatterns = [
path('blog//', views.year_archive, name='blog_year_archive'),
]
Neste caso, a URL ‘blog//’ inclui uma variável “year”, do tipo int. Quando uma solicitação coincidir com esse padrão, o Django passará o valor de “year” como argumento para a função de visualização views.year_archive.
Como usar URLs no Django
No Django, as URLs são a base de qualquer aplicativo e funcionam associando solicitações do usuário às visualizações apropriadas. Ao definir padrões de URLs que coincidem com visualizações específicas, o Django garante que o seu site permaneça organizado e escalável.
Como usar templates de URLs com a função reverse do Django
A função reverse do Django permite gerar URLs com base em seus padrões nomeados de URLs. Essa função recebe o nome do padrão de URL como seu primeiro argumento, antes de quaisquer outros argumentos necessários, e retorna a URL correspondente.
Veja um exemplo prático:
# views.py
from django.shortcuts import render
from django.urls import reverse
def blog_post_detail(request, year, month, slug):
# ...
url = reverse('blog_post_detail', args=[year, month, slug])
return render(request, 'blog/post_detail.html', {'url': url})
A função “reverse” é usada para gerar a URL para o padrão de URL ‘blog_post_detail’, passando os valores do ano, do mês e do slug como argumentos.
Você pode então usar a URL retornada em templates ou em outras partes do aplicativo.
Usando tags de URLs em templates do Django
A tag de template {% url %} do Django é uma maneira elegante de gerar URLs diretamente dentro do seu template. Em vez de explicitar as URLs no código, você pode fazer referência a padrões nomeados de URLs. Isso torna os seus templates mais flexíveis e fáceis de gerenciar.
Veja um exemplo:
Leia mais
Neste caso, a tag {% url %} cria uma URL para a visualização blog_post_detail, passando os parâmetros year, month e slug. É importante assegurar que esses argumentos coincidam com o padrão de URL definido no seu arquivo “urls.py”, que deve se parecer com isto:
path('blog////', views.blog_post_detail, name='blog_post_detail'),
Esta abordagem ajuda a manter os seus templates limpos e adaptáveis, especialmente mais tarde, à medida que o seu projeto evoluir.
Templates do Jinja e do Django
Embora o Django incorpore um mecanismo de templates (a DTL), os desenvolvedores também têm a opção de usar alternativas, como o Jinja.
O Jinja é um mecanismo de templates popular, moderno e cheio de recursos para o Python. Ele foi desenvolvido para o framework de Web Flask, mas também é compatível com o Django.
O mecanismo foi projetado para ser rápido, seguro e altamente extensível. Seu amplo conjunto de recursos torna-o versátil para renderizar conteúdo dinâmico.
Estes são alguns dos principais recursos e vantagens do Jinja em relação à DTL do Django:
- Uma sintaxe mais concisa e intuitiva.
- Execução em uma sandbox, para mais segurança contra ataques de injeção de código.
- Um sistema de herança mais flexível e poderoso.
- Melhores ferramentas de depuração e mecanismos de geração de relatórios.
- Desempenho mais rápido ao trabalhar com templates complexos ou grandes conjuntos de dados.
- Maior funcionalidade, com filtros e macros incorporados, permitindo uma lógica de renderização mais complexa, sem atravancar o template.
O PyCharm detecta automaticamente o tipo de arquivo *.jinja e fornece realce de sintaxe, complementação de código e detecção de erros, além de suporte a filtros e extensões personalizados, garantindo uma experiência suave de desenvolvimento.
Apesar desses benefícios, também é importante lembrar que integrar o Jinja em um projeto do Django requer uma configuração inicial mais ampla e complexa.
Alguns desenvolvedores também podem preferir ficar com o mecanismo de template incorporado do Django, para manter tudo dentro do ecossistema do Django.
Programe mais rapidamente com templates dinâmicas no Django
Com o recurso de templates dinâmicos do PyCharm, você pode rapidamente incluir trechos comumente usados de código com um simples atalho de teclado.
Tudo que você precisa fazer é invocar os templates dinâmicos teclando ⌘J, digitando ListView e pressionando a tecla Tab.
Isso reduz a programação repetitiva, acelera o desenvolvimento e garante uma sintaxe consistente. Você pode até personalizar ou criar os seus próprios templates para atender a necessidades específicas do seu projeto. Este recurso é útil especialmente para a sintaxe da DTL, que frequentemente repete loops, condicionais e estruturas de blocos.
Uso de templates do Django: dicas e melhores práticas
Trabalhar com templates do Django é uma excelente maneira de gerenciar a camada de apresentação dos seus aplicativos Web.
Porém, é essencial seguir orientações e fazer otimizações de desempenho, para garantir que os seus templates sejam bem mantidos, seguros e sistemáticos.
Estas são algumas dicas e melhores práticas a se lembrar ao usar templates no Django:
- Separe a apresentação da lógica de negócios. Mantenha o foco dos templates em renderizar os dados e faça processamentos complexos em visualizações ou modelos.
- Organize os seus templates de forma lógica. Siga a estrutura de arquivos do Django separando os templates por aplicativo e função, usando subdiretórios se necessário.
- Use as convenções de nomenclatura do Django. O Django segue o princípio de que “as convenções são mais importantes que a configuração”, permitindo que você nomeie os seus templates de uma maneira específica, para que você não precise fornecer explicitamente os nomes dos templates. Por exemplo, ao usar visualizações baseadas em classes, como
ListView, o Django procura automaticamente um template com o nome de /_list.html, o que simplifica o seu código. - Divida tarefas elaboradas em componentes reutilizáveis. Promova a reutilização do código e torne a manutenção mais fácil usando tags, filtros e “includes” de templates.
- Siga convenções consistentes de nomenclatura. Use nomes claros e descritivos para os seus templates, tags e filtros. Isso facilita para os outros desenvolvedores lerem o seu código.
- Use os filtros seguros de renderização do Django. Sempre escape os dados fornecidos pelo usuário antes da renderização, para evitar vulnerabilidades de XSS.
- Documente lógica complexa nos templates. Faça comentários claros para explicar partes complicadas dos seus templates. Isso ajudará outras pessoas (e você mesmo, no futuro) a compreenderem o seu código.
- Faça profiling dos seus templates. Use as ferramentas de profiling do Django para encontrar e otimizar gargalos de desempenho, como loops ineficientes e lógica rebuscada.
Assista a este vídeo para explorar as dicas sobre o Django e os recursos do PyCharm em mais detalhes.
Conclusão
Quer você esteja desenvolvendo um Web site simples ou um aplicativo mais complicado, agora você já deve saber como criar templates que melhoram a experiência do usuário e simplificam o seu processo de desenvolvimento no Django.
Mas os templates são apenas um componente do framework Django. Explore nossas outras postagens de blog sobre o Django, além de recursos que podem ajudar você a aprender Django, descobrir os últimos recursos do Django e muito mais. Talvez você também queira se familiarizar com a documentação oficial do Django.
Suporte confiável ao Django no PyCharm
O PyCharm Professional está aí para ajudar a otimizar o fluxo de trabalho dos desenvolvedores em Django, desde completos iniciantes até desenvolvedores experientes.
O IDE para Django oferece assistência à codificação específica para o Django, depuração, pré-visualizações dinâmicas, navegação por todo o projeto e recursos de refatoração. O PyCharm inclui suporte total a templates do Django, permitindo que você os gerencie e edite facilmente. Você também pode se conectar ao seu banco de dados com apenas um clique e trabalhar tranquilamente com TypeScript, JavaScript e outros frameworks de front-end.
Para ver os detalhes completos de como trabalhar com templates do Django no PyCharm, consulte nossa documentação. Pode ser melhor para os que forem relativamente novatos no framework Django ler primeiro nosso tutorial abrangente, que cobre todas as etapas do processo de criar um novo aplicativo com o Django no PyCharm.
Pronto para começar? Baixe o PyCharm agora mesmo e desfrute de um processo de desenvolvimento mais produtivo.
Artigo original em inglês por:
Subscribe to PyCharm Blog updates
