Introdução às visualizações do Django
Visualizações são centrais no padrão de arquitetura do Django e é essencial que qualquer desenvolvedor que trabalhe com esse framework tenha um sólido domínio de como trabalhar com elas. Se você for novato no desenvolvimento de aplicativos de Web com o Django ou simplesmente precisar recapitular as visualizações, temos o que você precisa.
Compreender melhor as visualizações ajudará você a progredir mais rapidamente no seu projeto com o Django. Quer você esteja trabalhando em um back-end de API ou em fluxos de interface de usuário na Web, é crucial saber como usar as visualizações.
Continue lendo para descobrir o que são as visualizações do Django, quais são os seus diferentes tipos e as melhores práticas para se trabalhar com elas, e ver exemplos de casos de uso.
O que são as visualizações do Django?
As visualizações são um componente central do padrão de arquitetura MTV (“model-template-view”, “modelo-template-visualização”) do Django. Essencialmente, elas funcionam como intermediárias entre modelos e templates, processando as solicitações dos usuários e retornando respostas.
Talvez você já tenha encontrado visualizações no padrão MVC (modelo-visualização-controlador). Porém, essas visualizações são ligeiramente diferentes das visualizações do Django e não têm uma correspondência exata. As visualizações do Django são essencialmente controladores no MVC, enquanto as templates do Django correspondem grosseiramente às visualizações do MVC. Isso torna vital compreender as nuances das visualizações do Django, mesmo que você já esteja familiarizado com as visualizações no contexto do MVC.
No Django, as visualizações são parte da interface de usuário e lidam com a lógica e o processamento dos dados de solicitações de Web enviadas aos seus aplicativos e sites que usam o Django. Elas renderizam as suas templates no que o usuário vê quando visualiza a sua página da Web. Cada visualização baseada em uma função ou classe recebe uma solicitação de um usuário, busca o dado em seus modelos, aplica a lógica de negócios ou o processamento de dados e depois prepara e retorna uma resposta a uma template por HTTP.
Essa resposta pode ser qualquer coisa que um navegador de Web possa mostrar e tipicamente é uma página em HTML. Porém, as visualizações do Django também podem retornar imagens, documentos em XML, redirecionamentos, páginas de erro e muito mais.
Renderização e passagem de dados para templates
O Django fornece o atalho render() para simplificar a renderização de templates de dentro das visualizações. Esse atalho ajuda a evitar o código repetitivo para carregar a template e criar a resposta manualmente.
O PyCharm oferece complementação inteligente do código, que automaticamente sugere a função render() de django.shortcuts quando você começa a digitá-la nas suas visualizações. Ele também reconhece nomes de templates e fornece complementação automática em caminhos de templates, ajudando você a evitar erros de digitação e outros.
O usuário fornece a solicitação, o nome da template e um dicionário de contexto, que alimentam a template com dados. Depois que os dados necessários forem obtidos, a visualização os passa para a template, onde eles podem ser renderizados e apresentados ao usuário.
from django.shortcuts import render
def my_view(request):
# Some business logic to obtain data
data_to_pass = {'variable1': 'value1', 'variable2': 'value2'}
# Pass the data to the template
return render(request, 'my_template.html', context=data_to_pass)
Neste exemplo, data_to_pass é um dicionário que contém os dados que você deseja enviar para a template. Em seguida, a função render é usada para renderizar a template (my_template.html) com os dados de contexto fornecidos.
Agora você pode acessar e mostrar os dados na sua template (my_template.html).
{{ variable1 }}
{{ variable2 }}
Na template, você pode usar chaves duplas ({{ }}) para indicar variáveis de template, que serão substituídas pelos valores dos dados de contexto passados pela visualização.
O PyCharm oferece complementação e realce de sintaxe para tags, variáveis e loops de templates do Django. Também oferece linting dentro do editor para erros comuns. Isso permite que você se concentre em criar as visualizações e lidar com a lógica, em vez de gastar tempo preenchendo manualmente os elementos da template ou depurando erros comuns.
Visualizações baseadas em funções
O Django tem dois tipos de visualizações: baseadas em funções e em classes.
As visualizações baseadas em funções são criadas usando funções simples em Python e geralmente se dividem em quatro categorias básicas: criação, leitura (“read”), atualização (“update”) e exclusão (“delete”) — CRUD. Esta é a base de qualquer framework no desenvolvimento. Essas funções recebem uma solicitação por HTTP e retornam uma resposta pelo mesmo protocolo.
from django.http import HttpResponse
def my_view(request):
# View logic goes here
context = {"message": "Hello world"}
return HttpResponse(render(request, "mytemplate.html", context))
Este trecho de código lida com a lógica da visualização, prepara um dicionário de contexto para passar os dados a uma template renderizada e retorna o código em HTML final da template em um objeto de resposta.
Visualizações baseadas em funções são simples e diretas. A lógica fica contida em uma única função em Python, em vez de espalhada pelos métodos de uma classe, tornando essas visualizações as mais adequadas para casos de usos com muito pouco processamento.
O PyCharm permite que você gere automaticamente a estrutura def my_view(request) usando templates dinâmicas. Essas templates são trechos predefinidos de código que podem ser expandidos para código reutilizável. Esse recurso poupa tempo e garante uma estrutura consistente às suas definições de visualizações.
Para invocar templates dinâmicas, basta pressionar ⌘J, digitar Listview e pressionar a tecla TAB.
Além disso, o PyCharm inclui uma janela de ferramentas Django Structure, onde você pode ver uma lista de todas as visualizações do seu projeto do Django, organizadas por aplicativo. Isso permite localizar visualizações rapidamente, navegar entre elas e identificar a qual arquivo pertence cada visualização.
Visualizações baseadas em classes
O Django introduziu as visualizações baseadas em classes, para que os usuários não precisem escrever o mesmo código repetidas vezes. Elas não substituem as visualizações baseadas em funções, mas têm certas aplicações e vantagens, especialmente em casos que requerem uma lógica complexa.
As visualizações baseadas em classes do Django fornecem classes-pais reutilizáveis que implementam diversos padrões e recursos tipicamente necessários para visualizações de aplicativos de Web. Você pode obter as suas visualizações dessas classes-pais para reduzir o código repetitivo.
As visualizações baseadas em classes oferecem classes-pais genéricas, como:
ListViewDetailViewCreateView- E muito mais.
Veja abaixo dois trechos semelhantes de código, demonstrando uma BookListView simples. O primeiro trecho mostra uma implementação que usa as convenções-padrão baseadas em classes, enquanto o segundo ilustra como personalizar a visualização especificando parâmetros adicionais.
Implementação básica:
from django.views.generic import ListView
from .models import Book
class BookListView(ListView):
model = Book
# The template_name is omitted because Django defaults to 'book_list.html'
# based on the convention of _list.html for ListView.
Quando BookListView é renderizada, consulta automaticamente os registros de Book e os passa sob a variável books ao renderizar book_list.html. Isso significa que você pode criar uma visualização para listar objetos rapidamente, sem precisar reescrever a lógica subjacente.
Implementação personalizada:
from django.views.generic import ListView
from .models import Book
class BookListView(ListView):
model = Book
# You can customize the view further by adding additional attributes or methods
def get_queryset(self):
# Example of customizing the queryset to filter books
return Book.objects.filter(is_available=True)
Neste segundo trecho, introduzimos o método personalizado get_queryset(), que permite filtrar mais precisamente os registros mostrados na visualização. Isso demonstra como as visualizações baseadas em classes podem ser ampliadas além da sua funcionalidade-padrão para atenderem às necessidades do seu aplicativo.
Visualizações baseadas em classes também definem métodos que se atrelam a partes essenciais do ciclo de vida de solicitações e respostas, tais como:
get()— lógica para solicitaçõesGET.post()— lógica para solicitaçõesPOST.dispatch()— determina qual método chamar,get()oupost().
Esses tipos de visualizações fornecem uma estrutura e oferecem personalização quando necessária, tornando-as adequadas para casos elaborados de uso.
O PyCharm oferece templates dinâmicas para visualizações baseadas em classes, como ListView, DetailView e TemplateView, permitindo gerar classes inteiras de visualizações em segundos, incluindo métodos reutilizáveis e docstrings.
Criação de visualizações personalizadas baseadas em classes
Você também pode criar suas próprias classes de visualizações, criando subclasses das classes genéricas do Django e personalizando-as conforme as suas necessidades.
Estes são alguns casos de uso nos quais você talvez queira criar as suas próprias classes:
- Para adicionar lógica de negócios, como cálculos complicados.
- Para misturar diversas classes-pais genéricas e seus recursos.
- Para gerenciar sessões ou estados entre várias solicitações.
- Para otimizar o acesso a bancos de dados com consultas personalizadas.
- Para reutilizar lógica comum de renderização entre diferentes áreas.
Uma visualização personalizada baseada em classes pode se parecer com isto:
from django.views.generic import View
from django.shortcuts import render
from . import models
class ProductSalesView(View):
def get(self, request):
# Custom data processing
sales = get_sales_data()
return render(request, "sales.html", {"sales": sales})
def post(self, request):
# Custom form handling
form = SalesSearchForm(request.POST)
if form.is_valid():
results = models.Sale.objects.filter(date__gte=form.cleaned_data['start_date'])
context = {"results": results}
return render(request, "search_results.html", context)
# Invalid form handling
errors = form.errors
return render(request, "sales.html", {"errors": errors})
Aqui, manipuladores get e post personalizados permitem preservar os já existentes entre solicitações.
Quando usar cada tipo de visualização
Tanto as visualizações baseadas em funções quanto as baseadas em classes podem ser úteis, dependendo da complexidade e das necessidades da lógica de visualização.
As principais diferenças são que as visualizações baseadas em classes:
- Promovem a reutilização através de subclasses e da herança do comportamento das classes-pais.
- São ideais para gerenciar estados entre solicitações.
- Fornecem mais estrutura e aplicam mais disciplina.
Você poderia usá-las ao trabalhar com:
- Páginas de dashboards com lógica complexa de renderização.
- Páginas voltadas para o público que mostram dados dinâmicos.
- Portais administrativos para o gerenciamento de conteúdo.
- Páginas de listas ou de detalhamento envolvendo modelos de bancos de dados.
Por outro lado, as visualizações baseadas em funções:
- São mais simples e requerem menos código para serem criadas.
- Podem ser mais fáceis de entender para desenvolvedores em Python.
- São altamente flexíveis e têm menos restrições.
Seus casos de uso incluem:
- Prototipação de ideias.
- Visualização de CRUD simples ou de banco de dados.
- Páginas de chegada ou de marketing.
- Endpoints de API para atender a solicitações de Web.
Em resumo, visualizações baseadas em funções são flexíveis, diretas e mais fáceis de compreender. Porém, em casos mais complexos, você precisará criar mais código não reutilizável.
As visualizações baseadas em classes do Django obrigam a que haja uma estrutura e são reutilizáveis, mas podem ser mais desafiadoras para compreender e implementar, além de mais difíceis de depurar.
Visualizações e URLs
Como já definimos, no Django, visualizações são funções ou classes que determinam como uma template será renderizada. Cada visualização está associada a um padrão específico de URL, encaminhando ao lugar certo as solicitações que chegarem.
É importante compreender a relação entre as visualizações e as URLs, para gerenciar o fluxo do seu aplicativo de forma eficaz.
Cada visualização corresponde a um padrão de URL, definido no arquivo urls.py do seu aplicativo do Django. Esse mapeamento de URLs garante que quando um usuário navegar até um determinado endereço no seu aplicativo, o Django saiba exatamente qual visualização invocar.
Vamos dar uma olhada em uma configuração simples de URL:
from django.urls import path
from .views import BookListView
urlpatterns = [
path('books/', BookListView.as_view(), name='book-list'),
]
Nesta configuração, quando um usuário visita /books/, entra em ação a BookListView, para renderizar a lista de livros. Mapeando claramente URLs a visualizações, você torna a sua base de código mais fácil de ler e mais organizada.
Simplifique o gerenciamento de URLs com o PyCharm
À medida que o seu aplicativo cresce, pode se tornar desafiador gerenciar e visualizar endpoints no Django. O PyCharm ataca esse problema com sua janela de ferramentas Endpoints, que fornece uma visualização centralizada de todos os padrões, visualizações associadas e métodos de HTTP do seu aplicativo. Esse recurso permite visualizar uma lista de todos os endpoints do seu projeto, facilitando rastrear quais visualizações estão vinculadas a determinadas URLs.
Em vez de pesquisar em diversos arquivos urls.py, você pode localizar instantaneamente as visualizações correspondentes e navegar até elas com apenas um clique. Isso é especialmente útil em projetos maiores do Django, em que configurações de URLs se estendam por vários arquivos, ou ao trabalhar em equipes onde seja crucial determinar rapidamente o contexto.
Além disso, a janela de ferramentas Endpoints permite visualizar todos os endpoints em uma interface semelhante a uma tabela. Cada linha mostra o caminho da URL, o método de HTTP (GET, POST, etc.) e a função ou classe de visualização associada a um determinado endpoint.
Esse recurso não apénas aumenta a produtividade, mas também melhora a navegação pelo código, permitindo que você identifique facilmente padrões de URLs que estejam duplicados ou faltando. Esse nível de visibilidade é valioso para depurar problemas de roteamento ou incorporar novos desenvolvedores a um projeto.
Confira este vídeo para saber mais sobre a janela de ferramentas Endpoints e os benefícios que você pode ter com ela.
Melhores práticas para usar as visualizações do Django
Estas são algumas diretrizes que podem ajudar você a criar visualizações bem estruturadas e fáceis de manter.
Mantenha o foco das visualizações
As visualizações devem se concentrar em processar solicitações, buscar dados, passar dados para as templates e controlar o fluxo e os redirecionamentos. Deve-se lidar com uma lógica de negócios complicada e com processamentos complexos em outro lugar, como nos métodos do modelo ou em classes dedicadas de serviço.
Porém, tome cuidado para não sobrecarregar os seus modelos com excesso de lógica, pois isso pode levar ao padrão nocivo de “modelo gordo” no Django. A documentação do Django sobre visualizações dá mais insights sobre como estruturá-las adequadamente.
Mantenha as visualizações e templates enxutas
É melhor manter as visualizações e templates enxutas. As visualizações devem cuidar do processamento de solicitações e da obtenção de dados, enquanto as templates devem se concentrar na apresentação, com o mínimo de lógica.
Processamentos complexos devem ser feitos em Python, fora das templates, para facilitar a manutenção e os testes. Para saber mais sobre isso, confira a documentação do Django sobre templates.
Desassocie as consultas a bancos de dados
Extrair as consultas a bancos de dados para gerenciadores ou repositórios separados de modelos, em vez de colocá-las diretamente nas visualizações, pode ajudar a reduzir a duplicação. Consulte na documentação do Django sobre modelos orientações sobre como gerenciar interações com bancos de dados de forma eficaz.
Use visualizações genéricas baseadas em classes quando possível
As visualizações genéricas baseadas em classes do Django, como DetailView e ListView, permitem a reutilização sem que você precise escrever muito código. Escolha usá-las, em vez de reinventar a roda, para usar melhor o seu tempo. A documentação sobre visualizações genéricas é uma excelente fonte de informação para entender esses recursos.
Não há problema em usar visualizações baseadas em funções em casos simples
Em visualizações básicas, como atender a solicitações de APIs, uma função pode ser mais eficaz que uma classe. Reserve visualizações complexas baseadas em classes para fluxos complicados de interface de usuário. A página de documentação sobre como criar visualizações oferece exemplos úteis.
Estruture rotas e URLs de forma limpa
Organize as rotas e os manipuladores de visualizações, agrupando-os em aplicativos conforme sua funcionalidade. Isso facilita encontrar as coisas e navegar pelo código-fonte. Confira a documentação do Django sobre despachantes de URLs para ver as melhores práticas para estruturar as suas configurações de URLs.
Próximos passos
Agora que você já tem uma compreensão básica das visualizações no Django, você irá querer ir mais fundo nesse framework e saber quais são as próximas etapas.
- Recorde os seus conhecimentos de Django na nossa postagem de blog How to Learn Django, que é ideal para iniciantes ou para quem está procurando atualizar seus conhecimentos.
- Descubra como criar e executar o seu primeiro projeto em Django no PyCharm, com nosso tutorial sobre como criar um aplicativo básico de lista de afazeres, ou explore nossa lista completa de ideias de projetos em Django para ter mais inspiração.
- Explore o estado do Django para ver as últimas tendências no desenvolvimento em Django e ganhar mais inspiração.
- Se você ainda estiver decidindo qual framework para Python usar, nossos guias comparativos Django × Flask e Django × FastAPI podem ajudar.
Suporte ao Django no PyCharm
O PyCharm Professional é o melhor IDE de sua categoria para o desenvolvimento em Django. Ele permite que você programe mais rapidamente, com assistência à codificação específica para o Django, navegação e refatoração por todo o projeto e suporte total a templates do Django. Você pode se conectar com o seu banco de dados com um único clique e trabalhar com frameworks de TypeScript, JavaScript e front-end. O PyCharm também é imediatamente compatível com o Flask e o FastAPI.
Crie aplicativos melhores e otimize o seu código. Comece a usar o PyCharm agora mesmo, para ter uma experiência de desenvolvimento sem esforço no Django.
Artigo original em inglês por:
Subscribe to PyCharm Blog updates
