Urls (Rotas) e Views

URLs (Rotas): São os caminhos que a aplicação utiliza para identificar e direcionar o usuário para o recurso correto.
Views são funções ou classes (com logica python) que contêm a lógica que define o que será exibido quando uma URL específica é acessada, basicamente lidam com a solicitação (request) recebida e definem a resposta do usuário.

Os arquivos urls.py são chamados de URLConfig. Cada aplicativo pode ter sua propria rota internamente, basta criar um arquivo urls.py para defini-las. alem de configurar a url do aplicativo principal para apontar para o aplicativo desejado.

Quando um cliente faz uma solicitação HTTP para um servidor Django, a view correspondente processa a solicitação e retorna um objeto HttpResponse contendo: O conteúdo da resposta (body): O que será exibido ou enviado ao cliente. O código de status HTTP: Indica o resultado do processamento (por exemplo, 200 OK, 404 Not Found) e Cabeçalhos HTTP opcionais: Informações adicionais sobre a resposta (como tipo de conteúdo, cookies, etc.).

Algumas classes e funções usadas para respostas Django:

Classe/Função Descrição Exemplo de Uso Importação
HttpResponse Base para todas as respostas HTTP; permite enviar conteúdo personalizado. return HttpResponse("Página carregada com sucesso!") from django.http import HttpResponse
HttpResponseRedirect Redireciona o cliente para outra URL. onde caminho passado para é relativo à raiz do site. return HttpResponseRedirect('/nova-url/') from django.http import HttpResponseRedirect
HttpResponseNotFound Retorna uma resposta HTTP 404 (Não encontrado). return HttpResponseNotFound("Página não encontrada") from django.http import HttpResponseNotFound
JsonResponse Retorna uma resposta JSON (usada para APIs e dados estruturados). return JsonResponse({'mensagem': 'Olá, Mundo!'}) from django.http import JsonResponse
render Renderiza um template com um contexto e retorna um objeto HttpResponse. return render(request, 'template.html', {'key': 'value'}) from django.shortcuts import render
reverse Gera URLs dinamicamente a partir de nomes definidos no urls.py.

reverse('nome_da_view', args=[valor]). 

url = reverse('produto_detalhe', args=[42])
print(url)  # 👉 '/produto/42/'

 from django.urls import reverse
Http404 Gera uma resposta HTTP 404 indicando que a página ou recurso não foi encontrado. python\nfrom django.http import Http404\nraise Http404("Página não encontrada") from django.http import Http404

 

Dynamic Path Segment (Rotas dinâmicas com placeholders) são usadas para capturar partes da URL e passá-las como parâmetros para a função de visualização (view). Isso permite que URLs sejam flexíveis e dinâmicas, como capturar identificadores ou nomes diretamente da URL. existem varios tipos de placesholders <int:identificador> (que tratara converterá como inteiro). O padrão do placeholder é <str: identificador>.. os identificadores são passados como argumento para a função.

url nomeada: Django utiliza o nome da rota (parametro name) para fins de reversão de URLs, e é uma string que serve para identificar a URL no código, como nas funções reverse() e na tag de template {% url %}.

Sua sintaxe é:
    path('<tipo:nome_do_parametro>/', sua_view, name='nome_da_view')

A função resolve() do módulo django.urls serve para descobrir qual view (e quais argumentos) está associada a uma determinada URL.

Tipos Comuns de Placeholders
Tipo Descrição Exemplo de URL Valor Capturado
str Captura qualquer string (sem barras). /nome/joao/ joao
int Captura apenas números inteiros. /idade/25/ 25
slug Captura strings com letras, números, -, _. /artigo/minha-historia/ minha-historia
uuid Captura identificadores UUID válidos. /produto/550e8400-e29b-41d4-a716-446655440000/ UUID válido
path Captura strings, incluindo barras (/). /docs/tutorial/python/ tutorial/python

<slug> um identificador simplificado e único, é uma parte da URL que identifica uma página específica de maneira legível e amigável. 
Normalmente, ele é criado a partir do título do conteúdo e transformado em um formato simples,  em letras minúsculas, com palavras separadas por hifens, e sem caracteres especiais. /como-usar-slugs-em-urls-amigaveis. No Django já vem embutido um transformador slug,que espera um parâmetro slug, que será capturado e passado para a view correspondente. O tipo slug instrui Django a validar que esse parâmetro contenha apenas caracteres válidos para um slug.


Veja mais: Rotas dinâmicas Documentação

Para os exemplos abaixo, leve em consideração a seguinte estrutura, para uma pagina de noticias:

 

| Definição de Urls e Views

urls.py 
from . import views
from django.urls import path

# Cria uma lista de configurações para urls apontando para funções views
urlpatterns = [
    path("", views.index),

    # Rota dinâmica que captura a categoria da notícia
    path('<str:categoria>/', views.noticia_categoria, name='noticia_categoria'),

    # Rota dinâmica de inteiro para a categoria da notícia, mas o caminho será id/numero_inteiro
    path('id/<int:categoria>/', views.noticia_categoria, name='noticia_categoria'),
]

Recebe a url, e a função a ser executada! As funções que tratam as solicitações são importadas do arquivo views.py. Nesse caso ao acessar "noticias/"(definido na urlconfig do arquivo principal) a função index do arquivo views.py tratará a solicitação. Não é possivel fazer a mesma rota para dois tipos (inteiro e string por exemplo). por isso adicionamos o id/ na rota para ser tratado pela mesma função. 

views.py 
from django.http import HttpResponse

# Função que trata as solicitações para index
def index(request):
    return HttpResponse("Resposta simples para a solicitação da pagina noticias/")

# Função para exibir notícias com base na categoria
def noticia_categoria(request, categoria):

    # Verifica se o parâmetro categoria é um número inteiro
    if isinstance(categoria, int):
        return HttpResponse(f"Exibindo notícias da categoria por numero inteiro: {categoria}")
    else:
        return HttpResponse(f"Exibindo notícias da categoria: {categoria}")

Nesse caso a rota será tratada para os dois tipos, inteiro e strings. Acessando /noticias/tecnologia/ a Resposta será: "Exibindo notícias da categoria: tecnologia" e acessando /noticias/id/1: Exibindo notícias da categoria por numero inteiro: 1

urls.py 
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    # Adiciono o nome do caminho e o nome do aplicativo.arquivoURL incluso
    path("noticias/", include("meu_app.urls"))
]

Arquivo de rotas principal do projeto. Nele deve ser adicionado as rotas de todos os aplicativos através do include.

| Exemplo Slug

<slug> um identificador simplificado e único, é uma parte da URL que identifica uma página específica de maneira legível e amigável. 
Normalmente, ele é criado a partir do título do conteúdo e transformado em um formato simples,  em letras minúsculas, com palavras separadas por hifens, e sem caracteres especiais. /como-usar-slugs-em-urls-amigaveis. No Django já vem embutido um transformador slug,que espera um parâmetro slug, que será capturado e passado para a view correspondente. O tipo slug instrui Django a validar que esse parâmetro contenha apenas caracteres válidos para um slug.

url_slug.py 
from django.urls import path
from . import views
urlpatterns = [
    path("postagens/<slug:slug>", views.postagem, name="postagem-detalhada")
]
views_slug.py 
from django.http import JsonResponse

def postagem(request, slug):
    """
    Exemplo de uma view que utiliza slug para identificar uma postagem.
    """
    # Simulação de um dicionário de postagens para exemplo
    postagens = {
        "introducao-django": "Uma introdução completa ao Django.",
        "como-usar-slugs": "Entenda como usar slugs em URLs do Django.",
        "melhores-praticas-django": "Melhores práticas para desenvolver com Django."
    }

    # Busca a postagem pelo slug fornecido
    conteudo = postagens.get(slug, "Postagem não encontrada.")

    # Retorna uma resposta JSON com o slug e o conteúdo da postagem
    return JsonResponse({
        "slug": slug,
        "conteudo": conteudo
    })

Nesse exemplo temos dois apps no mesmo projeto e Ambos têm uma URL chamada "list":

  • products (produtos)

  • blog (blog)

urls_app_name.py 
# O namespace deve ser declarado no urls.py principal, caso queira escalar o produto posteriormente
urlpatterns = [
    path('admin/', admin.site.urls),
    
    path('blog/', include('blog.urls', namespace='blog')),
    path('produtos/', include('products.urls', namespace='products')),
]

# products/urls.py
app_name = 'products'
urlpatterns = [
    path('', views.products_list, name='list'),  # products:list
]

# blog/urls.py
app_name = 'blog'
urlpatterns = [
    path('', views.blog_list, name='list'),  # blog:list
]

# se os apps estivessem SEM O app_name
reverse('list')  # Ambíguo! o Django não saberia qual "list" você quer usar!

# COM O app_name
reverse('products:list')  # Correto! Refere-se à URL do app 'products'
reverse('blog:list')      # Refere-se à URL do app 'blog'

# E em templates
{% url 'products:list' %}
{% url 'blog:list' %}

A variável app_name dentro de um arquivo urls.py é um recurso do Django para organizar os nomes de URLs entre diferentes apps. Ele serve para criar um namespace (espaço de nomes) para as urlpatterns daquele app. 

app_name não é reservada em Python, mas é uma variável especial reconhecida pelo Django quando você está usando include() com namespaces. Ela deve estar presente no urls.py do app se você for usar namespace no include(), por questões de escalabilidade.