Tutorial Django: Introdução ao Django 5.0

Django é uma estrutura web Python de tamanho único que foi inspirada em Ruby on Rails e usa muitas das mesmas metáforas para tornar o desenvolvimento web rápido e fácil. Totalmente carregado e flexível, Django se tornou um dos frameworks web mais utilizados em Python.

Django inclui praticamente tudo que você precisa para construir uma aplicação web de qualquer tamanho, e sua popularidade torna fácil encontrar exemplos e ajuda para vários cenários. Além disso, o Django fornece ferramentas para permitir que seu aplicativo evolua e adicione recursos normalmente e migre seu esquema de dados (se houver).

O Django também tem a reputação de ser complexo, com muitos componentes e uma grande quantidade de configurações “ocultas” necessárias. Na verdade, você pode colocar um aplicativo Python simples em funcionamento em um tempo relativamente curto e, em seguida, expandir sua funcionalidade conforme necessário.

Este artigo orienta você na criação de um aplicativo Django 5.0 básico. Também abordaremos os recursos mais cruciais para desenvolvedores web na versão Django 5.

Instalando as principais bibliotecas do Django

Para instalar o Django 5.0, você precisará do Python 3.10 ou superior. Se você estiver preso a uma versão anterior do Python, poderá usar a versão 4; consulte a tabela de versões do Python do Django para descobrir quais versões você pode usar. Idealmente, use a versão mais recente do Python que suporta tudo o que você deseja fazer com seu projeto Django.

O primeiro passo é criar um ambiente virtual no qual você instalará o Django. Isso mantém o Django e suas bibliotecas associadas separadas da instalação base do Python, sempre uma boa prática.

Em seguida, instale o Django no ambiente virtual escolhido através do Python pip Utilitário:

pip install django

Isso instala as principais bibliotecas do Django e o django-admin utilitário de linha de comando usado para gerenciar projetos Django.

Criando um novo projeto Django

As instâncias do Django são organizadas em duas camadas: projetos e aplicativos.

A projeto é uma instância do Django com sua própria configuração de banco de dados, configurações e aplicativos. É melhor pensar em um projeto como um local para armazenar todas as configurações de nível de site que você usará.
Um aplicativo é uma subdivisão de um projeto, com percurso e lógica de renderização próprios. Vários aplicativos podem ser colocados em um único projeto Django.

Para criar um novo projeto Django do zero, entre no diretório onde deseja armazenar o projeto e digite:


django-admin startproject <project_name>

O <project_name> é o nome do projeto e do subdiretório onde o projeto será armazenado. Certifique-se de escolher um nome que provavelmente não colida com um nome usado internamente pelo Python ou Django. Um nome como myproj funciona bem.

O diretório recém-criado deve conter um manage.py arquivo, que é usado para controlar o comportamento do aplicativo a partir da linha de comando, e outro subdiretório (também com o nome do projeto) que contém os seguintes arquivos:

Um __init__.py arquivo, que é usado pelo Python para designar um subdiretório como um módulo de código.
settings.py, que contém as configurações usadas para o projeto. Muitas das configurações mais comuns serão pré-preenchidas para você.
urls.pyque lista as rotas ou URLs disponíveis para o seu projeto Django, ou para as quais o projeto retornará respostas.
wsgi.pyque é usado por servidores web compatíveis com WSGI, como Apache HTTP ou Nginx, para servir os aplicativos do seu projeto.
asgi.py, que é usado por servidores web compatíveis com ASGI para servir os aplicativos do seu projeto. ASGI é um padrão relativamente novo para servidores e aplicativos assíncronos e requer um servidor que o suporte, como uvicorn. O Django adicionou recentemente suporte nativo para aplicativos assíncronos, que também precisarão ser hospedados em um servidor compatível com assíncronos para serem totalmente eficazes.

Em seguida, teste o projeto para garantir que está funcionando. Na linha de comando no diretório que contém o arquivo do seu projeto manage.py arquivo, execute:


python manage.py runserver

Isso deve iniciar um servidor web de desenvolvimento disponível em http://127.0.0.1:8000/. Visite esse link e você verá uma página de boas-vindas simples informando que a instalação foi bem-sucedida.

Observe que o servidor web de desenvolvimento deve não ser usado para servir um projeto Django ao público. É apenas para testes locais e não foi projetado para escalar aplicativos voltados ao público.

Criando um aplicativo Django

A seguir, criaremos um aplicativo dentro deste projeto. Navegue até o mesmo diretório que manage.py e emita este comando:


python manage.py startapp myapp

Isso cria um subdiretório para um aplicativo chamado myapp que contém o seguinte:

A migrations diretório: contém o código usado para migrar o site entre versões de seu esquema de dados. Os projetos Django normalmente possuem um banco de dados, portanto o esquema do banco de dados – incluindo alterações no esquema – é gerenciado como parte do projeto.
admin.py: Contém objetos usados pelas ferramentas de administração integradas do Django. Se seu aplicativo tiver uma interface administrativa ou usuários privilegiados, você configurará os objetos relacionados aqui.
apps.py: fornece informações de configuração sobre o aplicativo para o projeto como um todo, por meio de um AppConfig objeto.
models.py: contém objetos que definem estruturas de dados usadas pelo seu aplicativo para fazer interface com bancos de dados.
tests.py: contém todos os testes usados para garantir que as funções e módulos do seu site estejam funcionando conforme esperado.
views.py: contém funções que renderizam e retornam respostas.

Para começar a trabalhar com o aplicativo, primeiro você precisa registrá-lo no projeto. Editar myproj/settings.py como segue, adicionando uma linha no topo do INSTALLED_APPS lista:


INSTALLED_APPS = (
    "myapp.apps.MyappConfig",
    "django.contrib.admin",
    ...

Se você olhar para dentro myproj/myapp/apps.pyvocê verá um objeto pré-gerado chamado MyappConfigque mencionamos aqui.

Adicionando rotas e visualizações ao seu aplicativo Django

Aplicações Django seguem um padrão básico para processar solicitações:

Quando uma solicitação recebida é recebida, o Django analisa a URL de um rota para aplicá-lo.
As rotas são definidas em urls.pycom cada rota ligada a um visualizar, significando uma função que retorna dados para serem enviados de volta ao cliente. As visualizações podem estar localizadas em qualquer lugar em um projeto Django, mas são melhor organizadas em seus próprios módulos.
As visualizações podem conter os resultados de um modeloque é um código que formata os dados solicitados de acordo com um determinado design.

Para ter uma ideia de como todas essas peças se encaixam, vamos modificar a rota padrão do nosso aplicativo de exemplo para retornar uma mensagem personalizada.

As rotas são definidas em urls.py em uma lista chamada urlpatterns. Se você abrir a amostra urls.pyVocê vai ver urlpatterns já predefinido:


urlpatterns = (
    path('admin/', admin.site.urls),
)

O path function – uma função interna do Django – pega uma rota e uma função de visualização como argumentos e gera uma referência para um caminho de URL. Por padrão, o Django cria um admin path que é usado para administração do site, mas precisamos criar nossas próprias rotas.

Adicione outra entrada, para que todo o arquivo fique assim:


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

urlpatterns = (
    path('admin/', admin.site.urls),
    path('myapp/', include('myapp.urls'))
)

O include função diz ao Django para procurar mais informações de padrão de rota no arquivo myapp.urls. Todas as rotas encontradas nesse arquivo serão anexadas à rota de nível superior myapp (por exemplo, http://127.0.0.1:8080/myapp).

A seguir, crie um novo urls.py em myapp e adicione o seguinte:


from django.urls import path
from . import views

urlpatterns = (
    path('', views.index)
)

Django coloca uma barra no início de cada URL, para especificar a raiz do site (/), apenas fornecemos uma string em branco como URL.

Agora, edite o arquivo myapp/views.py então fica assim:


from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world!")

django.http.HttpResponse é um Django embutido que gera uma resposta HTTP a partir de uma string fornecida. Observe que requestque contém as informações para uma solicitação HTTP recebida, deve ser passado como o primeiro parâmetro para uma função de visualização.

Pare e reinicie o servidor de desenvolvimento e navegue até http://127.0.0.1:8000/myapp/. Você deverá ver “”Olá, mundo!” aparecer no navegador.

Adicionando rotas com variáveis no Django

O Django pode aceitar rotas que incorporem variáveis como parte de sua sintaxe. Digamos que você queira aceitar URLs com o formato year/<int:year>. Você poderia fazer isso adicionando a seguinte entrada a urlpatterns:


path('year/', views.year)

A função de visualização views.year seria então invocado através de rotas como year/1996, year/2010e assim por diante, com a variável year passado como parâmetro para views.year.

Para experimentar você mesmo, adicione o acima urlpatterns entrada para myapp/urls.pyem seguida, adicione esta função a myapp/views.py:


def year(request, year):
    return HttpResponse('Year: {}'.format(year))

Se você navegar para /myapp/year/2010 em seu site, você deverá ver Year: 2010 exibido em resposta. Observe que rotas como /myapp/year/rutabaga gerará um erro porque o int: a restrição na variável ano permite apenas um número inteiro nessa posição. Muitas outras opções de formatação estão disponíveis para rotas.

Versões anteriores do Django tinham uma sintaxe mais complexa para rotas, que era difícil de analisar. Se você ainda precisar adicionar rotas usando a sintaxe antiga — por exemplo, para compatibilidade retroativa com um projeto Django antigo — você pode usar a função django.urls.re_path, que corresponde a rotas usando expressões regulares.

Modelos Django

A linguagem de template integrada do Django pode ser usada para gerar páginas web a partir de dados.

Os templates usados pelos aplicativos Django são armazenados em um diretório central para o projeto: <app_name>/templates/<app_name>/. Para nós myapp projeto, o diretório seria myapp/templates/myapp/. Esta estrutura de diretório pode parecer estranha, mas permitir que o Django procure por templates em múltiplos lugares evita colisões de nomes entre templates com o mesmo nome em múltiplas aplicações.

Na tua myapp/templates/myapp/ diretório, crie um arquivo chamado year.html com o seguinte conteúdo:


Year: {{year}}

Qualquer valor entre chaves duplas em um modelo é tratado como uma variável. Todo o resto é tratado literalmente.

Modificar myapp/views.py para ficar assim:


from django.shortcuts import render
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world!")

def year(request, year):
    data = {'year':year}
    return render(request, 'myapp/year.html', data)

O render função – um “atalho” do Django (uma combinação de vários recursos integrados por conveniência) – pega o existente request objeto, procura o modelo myapp/year.html na lista de locais de modelos disponíveis e passa o dicionário data para isso como contexto para o modelo. O modelo usa o dicionário como namespace para variáveis usadas no modelo. Neste caso, a variável {{year}} no modelo é substituído pelo valor da chave year no dicionário data (aquilo é, data("year")).

A quantidade de processamento que você pode fazer nos dados nos templates do Django é intencionalmente limitada. A filosofia do Django é impor a separação entre apresentação e lógica de negócios sempre que possível. Assim, você pode percorrer um objeto iterável e executar if/then/else testes, mas a modificação dos dados dentro de um modelo não é recomendada.

Por exemplo, você poderia codificar um teste “se” simples desta forma:


{% if year > 2000 %}
21st century year: {{year}}
{% else %}
Pre-21st century year: {{year}}
{% endif %}

O {% e %} marcadores delimitam blocos de código que podem ser executados na linguagem de template do Django.

Se quiser usar uma linguagem de processamento de modelos mais sofisticada, você pode trocar por algo como Jinja2 ou Mako. Django inclui integração back-end para Jinja2, mas você pode usar qualquer linguagem de modelo que retorne uma string – por exemplo, retornando essa string em um HttpResponse objeto como no caso do nosso "Hello, world!" rota.

Próximos passos com Django

O que você viu aqui cobre apenas os elementos mais básicos de uma aplicação Django. Django inclui muitos outros componentes para uso em projetos web. Vale a pena discutir tudo isso em detalhes separadamente, mas deixarei uma breve visão geral:

Bancos de dados e modelos de dados: o ORM integrado do Django permite definir estruturas de dados e relacionamentos entre eles para seu aplicativo, bem como caminhos de migração entre versões dessas estruturas.
Formulários: Django fornece uma maneira consistente para visualizações fornecerem formulários de entrada para um usuário, recuperar dados, normalizar os resultados e fornecer relatórios de erros consistentes.
Segurança e utilitários: Django inclui muitas funções integradas para cache, registro, manipulação de sessão, manipulação de arquivos estáticos e normalização de URLs. Ele também reúne ferramentas para necessidades comuns de segurança, como o uso de certificados criptográficos ou proteção contra falsificação entre sites ou clickjacking.