Django Web Framework (Python)

 línguas
O Django é um framework web do lado do servidor extremamente popular e
cheio de recursos, escrito em Python. O módulo mostra por que o Django é uma
das estruturas de servidor da Web mais populares, como configurar um
ambiente de desenvolvimento e como começar a usá-lo para criar seus próprios
aplicativos da web.

Pré-requisitosSeção
Antes de iniciar este módulo, você não precisa ter nenhum conhecimento do
Django. Idealmente, você precisaria entender o que é a programação da Web
do lado do servidor e os frameworks da Web lendo os tópicos em nosso módulo
de primeiros passos de programação do site do lado do servidor .
Um conhecimento geral de conceitos de programação e Python é
recomendado, mas não é essencial para entender os principais conceitos.
Nota : O Python é uma das linguagens de programação mais fáceis para os
novatos lerem e entenderem. Dito isto, se você quiser entender melhor este
módulo, existem inúmeros livros gratuitos e tutoriais disponíveis na Internet
para ajudá-lo. (novos programadores podem querer verificar a página Python
for Non Programmers no wiki python.org).

GuiasSeção
Introdução ao Django
Neste primeiro artigo do Django nós respondemos a pergunta "O que é o
Django?" e dar-lhe uma visão geral do que torna este framework web
especial. Vamos descrever os principais recursos, incluindo algumas
funcionalidades avançadas que não teremos tempo para abordar
detalhadamente neste módulo. Também mostraremos alguns dos
principais blocos de construção de uma aplicação Django, para lhe dar
uma ideia do que ela pode fazer antes de configurá-la e começar a jogar.

Configurando um ambiente de desenvolvimento do Django

Agora que você sabe o que é o Django, mostraremos como configurar e
testar um ambiente de desenvolvimento do Django no Windows, Linux
(Ubuntu) e Mac OS X - qualquer sistema operacional comum que você
esteja usando, este artigo deve fornecer a você o que você precisa ser
capaz de começar a desenvolver aplicativos do Django.

Tutorial do Django: o site da Biblioteca Local

O primeiro artigo da nossa série de tutoriais prático explica o que você
vai aprender e fornece uma visão geral da "biblioteca local" - um exemplo
de site em que estaremos trabalhando e evoluindo em artigos
subsequentes.

Tutorial do Django Parte 2: Criando um site esqueleto

 Este artigo mostra como você pode criar um projeto de site "esqueleto"
como base, que pode ser preenchido com configurações, URLs,
modelos, modos de exibição e modelos específicos do site.

Tutorial do Django Parte 3: Usando modelos

Este artigo mostra como definir modelos para o LocalLibrary site - os
modelos representam as estruturas de dados nas quais queremos
armazenar os dados de nosso aplicativo e também permitem que o
Django armazene dados em um banco de dados para nós (e os
modifique mais tarde). Explica o que é um modelo, como ele é declarado
e alguns dos principais tipos de campo. Ele também mostra brevemente
algumas das principais maneiras de acessar os dados do modelo.
Tutorial do Django Parte 4: Site Administrativo do Django
Agora que criamos modelos para o site da LocalLibrary , usaremos o
site do Django Admin para adicionar alguns dados de livros
"reais". Primeiro, mostraremos a você como registrar os modelos no site
de administração e mostraremos como fazer login e criar alguns
dados. No final, mostramos algumas maneiras pelas quais você pode
melhorar ainda mais a apresentação do site de administração.
Django Tutorial Parte 5: Criando nossa home page
Agora, estamos prontos para adicionar o código para exibir nossa
primeira página inteira - uma página inicial da LocalLibrary que mostra
quantos registros temos de cada tipo de modelo e fornece links de
navegação da barra lateral para nossas outras páginas. Ao longo do
caminho, obteremos experiência prática ao escrever mapas e
visualizações de URLs básicos, obtendo registros do banco de dados e
usando modelos.
Tutorial do Django Parte 6: Lista genérica e visualizações detalhadas
Este tutorial estende nosso site LocalLibrary , adicionando listas e
páginas detalhadas para livros e autores. Aqui aprenderemos sobre
visualizações genéricas baseadas em classes e mostraremos como elas
podem reduzir a quantidade de código que você precisa escrever para
casos de uso comuns. Também entraremos no tratamento de URLs com
mais detalhes, mostrando como realizar a correspondência básica de
padrões.
Tutorial do Django Parte 7: Estrutura de Sessões
Este tutorial estende nosso site LocalLibrary , adicionando um contador
de visitas baseado em sessão à home page. Este é um exemplo
relativamente simples, mas mostra como você pode usar a estrutura de
sessão para fornecer um comportamento persistente para usuários
anônimos em seus próprios sites.
Parte 8 do tutorial do Django: Autenticação e permissões do usuário
Neste tutorial, mostraremos como permitir que os usuários façam login
em seu site com suas próprias contas e como controlar o que podem
fazer e ver com base no fato de estarem ou não logados e de
suas permissões . Como parte dessa demonstração, ampliaremos
o site da LocalLibrary , adicionando páginas de login e logout e páginas
específicas de usuários e funcionários para a visualização de livros que
foram emprestados.
Django Tutorial Parte 9: Trabalhando com Formulários
 Neste tutorial, mostraremos como trabalhar com HTML Forms no Django
e, em particular, a maneira mais fácil de escrever formulários para criar,
atualizar e excluir instâncias de modelo. Como parte dessa
demonstração, ampliaremos o site da LocalLibrary para que os
bibliotecários possam renovar livros e criar, atualizar e excluir autores
usando nossos próprios formulários (em vez de usar o aplicativo
administrativo).
Django Tutorial Parte 10: Testando um aplicativo da web do Django
Conforme os sites crescem, tornam-se mais difíceis de testar
manualmente - não apenas há mais para testar, mas à medida que as
interações entre os componentes se tornam mais complexas, uma
pequena alteração em uma área pode exigir muitos testes adicionais
para verificar seu impacto em outras áreas. Uma forma de mitigar esses
problemas é escrever testes automatizados, que podem ser executados
de maneira fácil e confiável sempre que você fizer uma alteração. Este
tutorial mostra como automatizar o teste de unidade do seu site usando
o framework de teste do Django.
Django Tutorial Parte 11: Implementando o Django para produção
Agora você criou (e testou) um site incrível da LocalLibrary , você vai
querer instalá-lo em um servidor web público para que ele possa ser
acessado pela equipe da biblioteca e membros pela Internet. Este artigo
fornece uma visão geral de como você pode encontrar um host para
implantar seu site e o que você precisa fazer para preparar seu site para
a produção.
Segurança do aplicativo da web do Django
Proteger os dados do usuário é uma parte essencial do design de
qualquer site. Anteriormente, explicamos algumas das ameaças de
segurança mais comuns no artigo Segurança na Web - este artigo
fornece uma demonstração prática de como as proteções internas do
Django lidam com essas ameaças.

Introdução ao Django
 línguas
Visão geral: DjangoNext

Neste primeiro artigo do Django, respondemos a pergunta "O que é o

Django?" e dar-lhe uma visão geral do que torna este framework web
especial. Vamos descrever os principais recursos, incluindo algumas das
funcionalidades avançadas que não teremos tempo para abordar
detalhadamente neste módulo. Nós também mostraremos alguns dos principais
blocos de construção de uma aplicação Django (embora você ainda não tenha
um ambiente de desenvolvimento para testá-lo).
Pré- Alfabetização básica em informática. Uma compreensão geral da programação de
requisitos: sites do lado do servidor e, em particular, da mecânica de interações cliente-servidor
em sites .
 Objetivo: Para se familiarizar com o que é o Django, quais funcionalidades ele fornece e os
principais blocos de construção de uma aplicação Django.

O que é o Django? Seção

O Django é um framework web Python de alto nível que permite o rápido
desenvolvimento de sites seguros e de fácil manutenção. Construído por
desenvolvedores experientes, o Django cuida de grande parte do trabalho de
desenvolvimento web, para que você possa se concentrar em escrever seu
aplicativo sem precisar reinventar a roda. É gratuito e de código aberto, tem
uma comunidade próspera e ativa, ótima documentação e muitas opções de
suporte gratuito e pago.

O Django ajuda você a escrever softwares que são:

Completo
O Django segue a filosofia "Baterias incluídas" e fornece quase tudo que
os desenvolvedores podem querer fazer "fora da caixa". Como tudo que
você precisa é parte do "produto", tudo funciona perfeitamente em
conjunto, segue princípios de design consistentes e possui uma
documentação extensa e atualizada .
Versátil
O Django pode ser (e tem sido) usado para construir praticamente
qualquer tipo de site - desde sistemas de gerenciamento de conteúdo e
wikis até redes sociais e sites de notícias. Ele pode trabalhar com
qualquer estrutura do lado do cliente e pode fornecer conteúdo em
praticamente qualquer formato (incluindo HTML, feeds RSS, JSON, XML,
etc.). O site que você está lendo atualmente é baseado no Django!

Internamente, embora forneça opções para praticamente qualquer

funcionalidade que você queira (por exemplo, vários bancos de dados
populares, mecanismos de modelos, etc.), também pode ser estendido
para usar outros componentes, se necessário.

Seguro
O Django ajuda os desenvolvedores a evitar muitos erros comuns de
segurança, fornecendo uma estrutura que foi projetada para "fazer as
coisas certas" para proteger o site automaticamente. Por exemplo, o
Django fornece uma maneira segura de gerenciar contas de usuário e
senhas, evitando erros comuns, como colocar informações de sessão em
cookies vulneráveis (em vez disso, os cookies contêm apenas uma
chave e os dados reais são armazenados no banco de dados) ou
armazenando senhas diretamente em vez de um hash de senha.

Um hash de senha é um valor de comprimento fixo criado ao enviar a

senha por meio de uma função hash criptográfica. O Django pode
verificar se uma senha digitada está correta, executando-a através da
função hash e comparando a saída com o valor do hash armazenado. No
entanto, devido à natureza "unidirecional" da função, mesmo que um
valor de hash armazenado seja comprometido, é difícil para um invasor
 descobrir a senha original.

O Django permite proteção contra muitas vulnerabilidades por padrão,

incluindo injeção de SQL, script entre sites, falsificação de solicitações
entre sites e clickjacking (consulte Segurança do site para obter mais
detalhes sobre esses ataques).
Escalável
O Django usa uma arquitetura “ shared-nothing ” baseada em
componentes (cada parte da arquitetura é independente das outras e,
portanto, pode ser substituída ou alterada, se necessário). Ter uma
separação clara entre as diferentes partes significa que ele pode ser
dimensionado para aumentar o tráfego adicionando hardware em
qualquer nível: servidores de armazenamento em cache, servidores de
banco de dados ou servidores de aplicativos. Alguns dos sites mais
visitados escalaram com sucesso o Django para atender suas demandas
(por exemplo, Instagram e Disqus, para citar apenas dois).
Sustentável
O código do Django é escrito usando princípios e padrões de design que
encorajam a criação de código que pode ser mantido e reutilizado. Em
particular, faz uso do princípio Don't Repeat Yourself (DRY) para que não
haja duplicação desnecessária, reduzindo a quantidade de código. O
Django também promove o agrupamento de funcionalidades
relacionadas em "aplicativos" reutilizáveis e, em um nível inferior, agrupa
o código relacionado em módulos (nos moldes do padrão Model View
Controller (MVC) ).
Portátil
O Django é escrito em Python, que é executado em muitas
plataformas. Isso significa que você não está preso a nenhuma
plataforma de servidor em particular e pode executar seus aplicativos em
vários tipos de Linux, Windows e Mac OS X. Além disso, o Django é bem
suportado por muitos provedores de hospedagem, que geralmente
fornecem infraestrutura específica e documentação para hospedagem de
sites do Django.

De onde veio? Seção

O Django foi inicialmente desenvolvido entre 2003 e 2005 por uma equipe da
web responsável pela criação e manutenção de sites de jornais. Depois de criar
vários sites, a equipe começou a fatorar e reutilizar muitos códigos comuns e
padrões de design. Este código comum evoluiu para um framework de
desenvolvimento web genérico, que foi open-source como o projeto "Django"
em julho de 2005.

O Django continua a crescer e a melhorar, desde o seu primeiro lançamento

(1.0) em setembro de 2008 até a recém-lançada versão 2.0 (2017). Cada
lançamento adicionou novas funcionalidades e correções de bugs, desde o
suporte a novos tipos de bancos de dados, mecanismos de modelos e
armazenamento em cache, até a adição de funções e classes de visualização
"genéricas" (que reduzem a quantidade de código que os desenvolvedores
precisam um número de tarefas de programação).
Nota : Confira as notas de lançamento no site do Django para ver o que mudou
nas versões recentes, e quanto trabalho está indo para tornar o Django melhor.
O Django é agora um próspero projeto colaborativo de código aberto, com
muitos milhares de usuários e colaboradores. Embora ainda tenha alguns
recursos que refletem sua origem , o Django evoluiu para uma estrutura versátil
capaz de desenvolver qualquer tipo de site.
Quão popular é o Django? Seção
Não há nenhuma medição prontamente disponível e definitiva da popularidade
das estruturas do lado do servidor (embora sites como o Hot
Frameworks tentem avaliar a popularidade usando mecanismos como a
contagem do número de projetos do GitHub e as perguntas do StackOverflow
para cada plataforma). Uma questão melhor é se o Django é "popular o
suficiente" para evitar os problemas de plataformas impopulares. Continua
evoluindo? Você pode obter ajuda se precisar? Existe uma oportunidade para
você receber um trabalho remunerado se aprender o Django?
Com base no número de sites de alto perfil que usam o Django, o número de
pessoas que contribuem para a base de código e o número de pessoas
fornecendo suporte gratuito e pago, então sim, o Django é uma estrutura
popular!

Os sites de alto perfil que usam o Django incluem: Disqus, Instagram, Fundação
Knight, Fundação MacArthur, Mozilla, National Geographic, Open Knowledge
Foundation, Pinterest e Open Stack (fonte: home page do Django ).
Django é opinativo? Seção
Estruturas da Web muitas vezes se referem a si mesmas como "opinativas" ou
"não publicadas".

Quadros opinativos são aqueles com opiniões sobre o "caminho certo" para
lidar com qualquer tarefa específica. Eles geralmente suportam o rápido
desenvolvimento em um domínio particular (resolvendo problemas de um tipo
particular) porque o jeito certo de fazer qualquer coisa é geralmente bem
entendido e bem documentado. No entanto, eles podem ser menos flexíveis na
solução de problemas fora de seu domínio principal e tendem a oferecer menos
opções para quais componentes e abordagens podem usar.
Estruturas não pintadas, em contraste, têm muito menos restrições sobre a
melhor maneira de unir os componentes para atingir uma meta, ou até mesmo
quais componentes devem ser usados. Eles tornam mais fácil para os
desenvolvedores usar as ferramentas mais adequadas para concluir uma tarefa
específica, mesmo que você precise encontrar esses componentes por conta
própria.

Django é "um pouco opinativo" e, portanto, oferece o "melhor dos dois

mundos". Ele fornece um conjunto de componentes para lidar com a maioria
das tarefas de desenvolvimento da Web e uma (ou duas) maneiras preferidas
de usá-las. No entanto, a arquitetura desacoplada do Django significa que você
geralmente pode escolher entre várias opções diferentes, ou adicionar suporte
para outras completamente novas, se desejar.
 Como é o código do Django? Seção
Em um site tradicional orientado a dados, um aplicativo da Web aguarda
solicitações HTTP do navegador da Web (ou outro cliente). Quando uma
solicitação é recebida, o aplicativo calcula o que é necessário com base na URL
e possivelmente em POSTdados ou GETdados. Dependendo do que for
necessário, ele poderá ler ou gravar informações de um banco de dados ou
executar outras tarefas necessárias para satisfazer a solicitação. O aplicativo
retornará uma resposta para o navegador da Web, geralmente criando
dinamicamente uma página HTML para o navegador exibir, inserindo os dados
recuperados em espaços reservados em um modelo HTML.
Os aplicativos da web do Django geralmente agrupam o código que manipula
cada uma dessas etapas em arquivos separados:

 URLs: Embora seja possível processar solicitações de cada URL única por
meio de uma única função, é muito mais fácil gravar uma função de exibição
separada para manipular cada recurso. Um mapeador de URLs é usado para
redirecionar solicitações HTTP para a visualização apropriada com base no
URL da solicitação. O mapeador de URLs também pode corresponder a
padrões específicos de cadeias ou dígitos que aparecem em um URL e
transmiti-los a uma função de visualização como dados.
 Visualização: Uma exibição é uma função de manipulador de solicitações, que
recebe solicitações HTTP e retorna respostas HTTP. Exibições acessam os
 dados necessários para satisfazer solicitações por meio de modelos e delegam
a formatação da resposta a modelos .
 Modelos: os modelos são objetos do Python que definem a estrutura dos
dados de um aplicativo e fornecem mecanismos para gerenciar (adicionar,
modificar, excluir) e consultar registros no banco de dados.
 Modelos: um modelo é um arquivo de texto que define a estrutura ou o layout
de um arquivo (como uma página HTML), com espaços reservados usados para
representar o conteúdo real. Uma visualização pode criar dinamicamente uma
página HTML usando um modelo HTML, preenchendo-a com dados de
um modelo . Um modelo pode ser usado para definir a estrutura de qualquer
tipo de arquivo; não precisa ser HTML!
Nota : O Django refere-se a esta organização como a arquitetura "Model View
Model (MVT)". Ele tem muitas semelhanças com a arquitetura mais familiar
do Model View Controller .
As seções abaixo lhe darão uma idéia de como essas partes principais de um
aplicativo do Django se parecerão (mais detalhadamente mais adiante no curso,
assim que configurarmos um ambiente de desenvolvimento).

Enviando o pedido para o entendimento correto (urls.py) Seção

Um mapeador de URL é normalmente armazenado em um arquivo
chamado urls.py . No exemplo abaixo, o mapper ( urlpatterns) define uma lista
de mapeamentos entre rotas ( padrões de URL específicos ) e funções de
visualização correspondentes. Se uma solicitação HTTP for recebida com uma
URL correspondente a um padrão especificado, a função de exibição associada
será chamada e passada na solicitação.
urlpatterns = [
path('admin/', admin.site.urls),
path('book/<int:id>/', views.book_detail, name='book_detail'),
path('catalog/', include('catalog.urls')),
re_path(r'^([0-9]+)/$', views.best),
]

O urlpatternsobjeto é uma lista de path() e / ou re_path() funções (as listas do

Python são definidas usando colchetes, onde os itens são separados por
vírgulas e podem ter uma vírgula final opcional . Por exemplo :)[item1, item2,
item3,] .
O primeiro argumento para ambos os métodos é uma rota (padrão) que será
correspondida. O path() método usa colchetes angulares para definir partes de
uma URL que serão capturadas e passadas para a função de exibição como
argumentos nomeados. A re_path() função usa uma abordagem flexível de
correspondência de padrões conhecida como expressão regular. Nós vamos
falar sobre isso em um artigo posterior!
O segundo argumento é outra função que será chamada quando o padrão for
correspondido. A notação views.book_detail indica que a função é
chamada book_detail()e pode ser encontrada em um módulo
chamado views (ou seja, dentro de um arquivo chamado views.py)
 Manusear o pedido (views.py) Seção
Visualizações são o coração do aplicativo da Web, recebendo solicitações
HTTP de clientes da Web e retornando respostas HTTP. No meio, eles
preparam os outros recursos do framework para acessar bancos de dados,
renderizar templates, etc.

O exemplo abaixo mostra uma função de visualização mínima index(), que

poderia ter sido chamada pelo nosso mapeador de URLs na seção
anterior. Como todas as funções de visualização, ele recebe
um HttpRequestobjeto como um parâmetro ( request) e retorna
um HttpResponseobjeto. Nesse caso, não fazemos nada com a solicitação e
nossa resposta simplesmente retorna uma string codificada. Mostraremos uma
solicitação que faz algo mais interessante em uma seção posterior.
# filename: views.py (Django view functions)

from django.http import HttpResponse

def index(request):
# Get an HttpRequest - the request parameter
# perform operations using information from the request.
# Return HttpResponse
return HttpResponse('Hello from Django!')

Nota : Um pouco de Python:

 Os módulos Python são "bibliotecas" de funções, armazenadas em arquivos
separados, que podemos usar em nosso código. Aqui nós importamos apenas
o HttpResponseobjeto do django.httpmódulo para que possamos usá-lo em nosso
ponto de vista: from django.http import HttpResponse . Existem outras maneiras
de importar alguns ou todos os objetos de um módulo.
 As funções são declaradas usando a defpalavra - chave como mostrado acima,
com parâmetros nomeados listados entre colchetes após o nome da função; a
linha inteira termina em dois pontos. Observe como as próximas linhas são
todas recuadas . O recuo é importante, pois especifica que as linhas de código
estão dentro desse bloco específico (a indentação obrigatória é um recurso
importante do Python e é um dos motivos pelos quais o código Python é tão
fácil de ler).
As visualizações geralmente são armazenadas em um arquivo
chamado views.py .
Definindo a seção demodelos de dados (models.py)
Os aplicativos da Web do Django gerenciam e consultam dados por meio de
objetos do Python chamados de modelos. Os modelos definem a estrutura dos
dados armazenados, incluindo os tipos de campo e possivelmente também seu
tamanho máximo, valores padrão, opções de lista de seleção, texto de ajuda
para documentação, texto de etiqueta para formulários etc. A definição do
modelo é independente do banco de dados subjacente você pode escolher um
 dentre vários como parte das configurações do seu projeto. Uma vez que você
escolheu qual banco de dados você quer usar, você não precisa falar
diretamente com ele - você apenas escreve sua estrutura de modelo e outro
código, e o Django lida com todo o trabalho sujo de se comunicar com o banco
de dados para você.
O trecho de código abaixo mostra um modelo muito simples do Django para
um Teamobjeto. A Teamclasse é derivada da classe django models.Model. Ele
define o nome da equipe e o nível da equipe como campos de caractere e
especifica um número máximo de caracteres a serem armazenados para cada
registro. O team_level pode ser um de vários valores, portanto, o definimos
como um campo de opção e fornecemos um mapeamento entre as opções a
serem exibidas e os dados a serem armazenados, junto com um valor padrão.
# filename: models.py

from django.db import models

class Team(models.Model):
team_name = models.CharField(max_length=40)

TEAM_LEVELS = (
('U09', 'Under 09s'),
('U10', 'Under 10s'),
('U11', 'Under 11s'),
... #list other team levels
)
team_level = models.CharField(max_length=3, choices=TEAM_LEVELS,
default='U11')

Nota : Um pouco de Python:

 O Python suporta "programação orientada a objetos", um estilo de programação
onde organizamos nosso código em objetos, que incluem dados e funções
relacionadas para operar nesses dados. Os objetos também podem herdar /
estender / derivar de outros objetos, permitindo que o comportamento comum
entre objetos relacionados seja compartilhado. Em Python, usamos a
palavra class- chave para definir o "blueprint" de um objeto. Podemos criar
várias instâncias específicas do tipo de objeto com base no modelo da classe.

Então, por exemplo, aqui temos uma Teamclasse, que deriva daModelclasse. Isso
significa que é um modelo e conterá todos os métodos de um modelo, mas
também podemos fornecer recursos especializados próprios. Em nosso modelo,
definimos os campos que nosso banco de dados precisará armazenar nossos
dados, dando-lhes nomes específicos. O Django usa essas definições, incluindo
os nomes dos campos, para criar o banco de dados subjacente.

Seção de consulta de dados (views.py)

O modelo do Django fornece uma API de consulta simples para pesquisar o
banco de dados. Isso pode corresponder a vários campos por vez usando
critérios diferentes (por exemplo, exatos, insensíveis a maiúsculas, maiores que,
etc.) e pode oferecer suporte a declarações complexas (por exemplo, você pode
especificar uma pesquisa em equipes do U11 que tenham um time nome que
começa com "Fr" ou termina com "al").

O snippet de código mostra uma função de visualização (manipulador de

recursos) para exibir todas as nossas equipes do U09. A linha em negrito
mostra como podemos usar a API de consulta do modelo para filtrar todos os
registros em que o team_level campo tenha exatamente o texto 'U09' (observe
como esse critério é transmitido à filter()função como um argumento com o
nome do campo e o tipo de correspondência separados por um sublinhado
duplo: team_level__exact ).
## filename: views.py

from django.shortcuts import render

from .models import Team

def index(request):
list_teams = Team.objects.filter(team_level__exact="U09")
context = {'youngest_teams': list_teams}
return render(request, '/best/index.html', context)

Essa função usa a render() função para criar o HttpResponseque é enviado de

volta ao navegador. Esta função é um atalho ; ele cria um arquivo HTML
combinando um modelo HTML especificado e alguns dados para inserir no
modelo (fornecidos na variável chamada " context"). Na próxima seção,
mostramos como o modelo contém os dados inseridos para criar o HTML.
Seção de processamento de dados (modelos HTML)
Os sistemas de modelos permitem que você especifique a estrutura de um
documento de saída, usando espaços reservados para dados que serão
preenchidos quando uma página for gerada. Os modelos geralmente são
usados para criar HTML, mas também podem criar outros tipos de
documentos. O Django suporta tanto o seu sistema nativo de templates como
outra popular biblioteca Python chamada Jinja2 (também pode ser feito para
suportar outros sistemas, se necessário).

O snippet de código mostra como o modelo HTML chamado

pela render()função na seção anterior pode parecer. Este modelo foi escrito sob
a suposição de que ele terá acesso a uma variável de lista
chamada youngest_teams quando é renderizada (contida na contextvariável
dentro da render()função acima). Dentro do esqueleto HTML, temos uma
expressão que primeiro verifica se a youngest_teamsvariável existe e depois a
itera em um forloop. Em cada iteração, o modelo exibe o team_namevalor de cada
equipe em um <li>elemento.
## filename: best/templates/best/index.html

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Home page</title>
</head>
<body>
 {% if youngest_teams %}
<ul>
{% for team in youngest_teams %}
<li>{{ team.team_name }}</li>
{% endfor %}
</ul>
{% else %}
<p>No teams are available.</p>
{% endif %}
</body>
</html>

O que mais você pode fazer? Seção

As seções anteriores mostram os principais recursos que você usará em quase
todos os aplicativos da Web: mapeamento de URLs, exibições, modelos e
modelos. Apenas algumas das outras coisas fornecidas pelo Django incluem:

 Formulários : Formulários HTML são usados para coletar dados do usuário

para processamento no servidor. O Django simplifica a criação, validação e
processamento de formulários.
 Autenticação e permissões do usuário : O Django inclui um sistema robusto
de autenticação e permissão de usuários que foi criado com a segurança em
mente.
 Cache : Criar conteúdo dinamicamente é muito mais intensivo em computação
(e lento) do que servir conteúdo estático. O Django fornece caching flexível para
que você possa armazenar toda ou parte de uma página renderizada para que
ela não seja renderizada novamente, exceto quando necessário.
 Site de administração : O site de administração do Django é incluído por
padrão quando você cria um aplicativo usando o esqueleto básico. Isso torna
trivialmente fácil fornecer uma página de administração para os administradores
do site criarem, editarem e visualizarem quaisquer modelos de dados em seu
site.
 Dados de serialização: o Django facilita a serialização e a exibição de seus
dados como XML ou JSON. Isso pode ser útil ao criar um serviço da Web (um
site que serve puramente dados a serem consumidos por outros aplicativos ou
sites e não exibe nada em si) ou ao criar um site no qual o código do lado do
cliente manipula todos os renderização de dados.
Seçãosumária
Parabéns, você completou o primeiro passo da sua jornada Django! Agora você
deve entender os principais benefícios do Django, um pouco sobre sua história
e mais ou menos como cada uma das partes principais de um aplicativo Django
pode parecer. Você também deve ter aprendido algumas coisas sobre a
linguagem de programação Python, incluindo a sintaxe de listas, funções e
classes.

Você já viu algum código real do Django acima, mas ao contrário do código do
lado do cliente, você precisa configurar um ambiente de desenvolvimento para
executá-lo. Esse é o nosso próximo passo.
 Configurando um ambiente de
desenvolvimento do Django
 línguas
AnteriorVisão geral: DjangoNext

Agora que você sabe o que é o Django, mostraremos como configurar e testar
um ambiente de desenvolvimento do Django no Windows, Linux (Ubuntu) e
macOS - qualquer sistema operacional comum que você esteja usando, este
artigo deve fornecer o que você precisa ser capaz de começar a desenvolver
aplicativos do Django.

Pré- Saiba como abrir um terminal / linha de comando. Saiba como instalar pacotes de software
requisitos: no sistema operacional do seu computador de desenvolvimento.

Objetivo: Ter um ambiente de desenvolvimento para o Django (2.0) rodando em seu computador.

Visão geral do ambiente de desenvolvimento do

DjangoSeção
O Django torna muito fácil configurar seu próprio computador para que você
possa começar a desenvolver aplicativos da web. Esta seção explica o que
você obtém com o ambiente de desenvolvimento e fornece uma visão geral de
algumas das suas opções de configuração e configuração. O restante do artigo
explica o método recomendado de instalar o ambiente de desenvolvimento do
Django no Ubuntu, macOS e Windows, e como você pode testá-lo.
Qual é o ambiente de desenvolvimento do Django? Seção
O ambiente de desenvolvimento é uma instalação do Django no seu
computador local que você pode usar para desenvolver e testar os aplicativos
do Django antes de implementá-los em um ambiente de produção.

As principais ferramentas que o próprio Django fornece são um conjunto de

scripts Python para criar e trabalhar com projetos Django, junto com um
simples servidor de desenvolvimentoque você pode usar para testar aplicações
locais (ie no seu computador, não em um servidor web externo) no navegador
da web do seu computador.
Existem outras ferramentas periféricas, que fazem parte do ambiente de
desenvolvimento, que não serão abordadas aqui. Estes incluem coisas como
um editor de texto ou IDE para edição de código, e uma ferramenta de
gerenciamento de controle de fonte como o Git para gerenciar com segurança
diferentes versões do seu código. Estamos assumindo que você já tem um
editor de texto instalado.
Quais são as opções de configuração do Django? Seção
 O Django é extremamente flexível em termos de como e onde ele pode ser
instalado e configurado. Django pode ser:

 Instalado em diferentes sistemas operacionais.

 Instalado a partir do código-fonte, do Python Package Index (PyPi) e, em muitos casos,
do aplicativo gerenciador de pacotes do computador host.
 Configurado para usar um dos vários bancos de dados, que também podem precisar
ser instalados e configurados separadamente.
 Executar no ambiente Python do sistema principal ou em ambientes virtuais separados
do Python.
Cada uma dessas opções requer configuração e configuração ligeiramente
diferentes. As subseções a seguir explicam algumas das suas escolhas. Para o
resto do artigo, mostraremos como configurar o Django em um pequeno número
de sistemas operacionais, e essa configuração será assumida em todo o
restante deste módulo.

Nota : Outras possíveis opções de instalação são abordadas na documentação

oficial do Django. Nós ligamos aos documentos apropriados abaixo .

Quais sistemas operacionais são suportados?

Os aplicativos da Web do Django podem ser executados em praticamente

qualquer máquina que possa executar a linguagem de programação do Python
3: Windows, macOS, Linux / Unix, Solaris, para citar apenas alguns. Quase
qualquer computador deve ter o desempenho necessário para executar o
Django durante o desenvolvimento.

Neste artigo, forneceremos instruções para o Windows, macOS e Linux / Unix.

Qual versão do Python deve ser usada?

Recomendamos que você use a versão mais recente disponível - no momento

da gravação, este é o Python 3.7.1.

O Python 3.5 ou posterior pode ser usado se necessário (o suporte ao Python

3.5 será descartado em versões futuras).

Nota : O Python 2.7 não pode ser usado com o Django 2.1 (A série Django 1.11.x
é a última a suportar o Python 2.7).

Onde podemos baixar o Django?

Existem três lugares para baixar o Django:

 O Python Package Repository (PyPi), usando a ferramenta pip . Esta é a melhor
maneira de obter a última versão estável do Django.
 Use uma versão do gerenciador de pacotes do seu computador. Distribuições do
Django que são empacotadas com sistemas operacionais oferecem um mecanismo
familiar de instalação. Observe, no entanto, que a versão empacotada pode ser
bastante antiga e só pode ser instalada no ambiente Python do sistema (que pode não
ser o que você deseja).
 Instalar a partir da fonte. Você pode obter e instalar a última versão do Django da
fonte. Isso não é recomendado para iniciantes, mas é necessário quando você está
pronto para começar a contribuir com o próprio Django.
Este artigo mostra como instalar o Django do PyPi, para obter a versão estável
mais recente.

Qual banco de dados?

O Django suporta quatro bancos de dados principais (PostgreSQL, MySQL,

Oracle e SQLite), e há bibliotecas comunitárias que fornecem níveis variados de
suporte para outros bancos de dados SQL e NoSQL
populares. Recomendamos que você selecione o mesmo banco de dados para
produção e desenvolvimento (embora o Django abstraia muitas das diferenças
de banco de dados usando seu Object-Relational Mapper (ORM), ainda
há possíveis problemasque devem ser evitados).
Para este artigo (e a maior parte deste módulo) estaremos usando o banco
de dados SQLite , que armazena seus dados em um arquivo. O SQLite é
destinado ao uso como um banco de dados leve e não suporta um alto nível de
simultaneidade. É, no entanto, uma excelente escolha para aplicativos que são
principalmente somente leitura.
Nota : O Django é configurado para usar o SQLite por padrão quando você
inicia o projeto do seu site usando as ferramentas padrão ( django-admin ). É uma
ótima opção quando você está começando porque não requer configuração ou
configuração adicional.

Instalando todo o sistema ou em um ambiente virtual Python?

Quando você instala o Python3, você obtém um único ambiente global que é
compartilhado por todo o código Python3. Embora você possa instalar qualquer
pacote Python que você goste no ambiente, só é possível instalar uma versão
específica de cada pacote por vez.

Nota : Aplicativos Python instalados no ambiente global podem entrar em

conflito uns com os outros (ou seja, se dependerem de versões diferentes do
mesmo pacote).
Se você instalar o Django no ambiente default / global, então você só poderá
direcionar uma versão do Django no computador. Isso pode ser um problema se
você quiser criar novos sites (usando a última versão do Django) enquanto
ainda mantém sites que dependem de versões mais antigas.
 Como resultado, os desenvolvedores experientes do Python / Django
geralmente executam aplicativos Python em ambientes virtuais independentes
do Python . Isso permite vários ambientes diferentes do Django em um único
computador. A própria equipe de desenvolvedores do Django recomenda que
você use ambientes virtuais do Python!
Este módulo pressupõe que você instalou o Django em um ambiente virtual, e
nós mostraremos como está abaixo.

Instalando o Python 3Seção

Para usar o Django, você terá que instalar o Python em seu sistema
operacional. Se você estiver usando o Python 3 , também precisará
da ferramenta Python Package Index - pip3- que é usada para gerenciar
(instalar, atualizar e remover) pacotes / bibliotecas Python usados pelo Django e
seus outros aplicativos Python.
Esta seção explica resumidamente como você pode verificar quais versões do
Python estão presentes e instalar novas versões conforme necessário, para o
Ubuntu Linux 18.04, macOS e Windows 10.

Nota : Dependendo da sua plataforma, você também poderá instalar o Python /

pip a partir do próprio gerenciador de pacotes do sistema operacional ou através
de outros mecanismos. Para a maioria das plataformas, você pode baixar os
arquivos de instalação necessários em https://www.python.org/downloads/ e
instalá-los usando o método específico da plataforma apropriado.
Seção Ubuntu 18.04
O Ubuntu Linux 18.04 LTS inclui o Python 3.6.6 por padrão. Você pode
confirmar isso executando o seguinte comando no terminal bash:

python3 -V
Python 3.6.6

No entanto, a ferramenta Índice de Pacotes do Python, que você precisará

instalar pacotes para o Python 3 (incluindo o Django), não está disponível por
padrão. Você pode instalar o pip3 no terminal bash usando:
sudo apt install python3-pip

Seção macOS
O macOS "El Capitan" e outras versões mais recentes não incluem o Python 3.
Você pode confirmar isso executando os seguintes comandos no terminal bash:

python3 -V
-bash: python3: command not found

Você pode instalar facilmente o Python 3 (junto com a ferramenta pip3 )

em python.org :
1. Baixe o instalador necessário:
1. Vá para https://www.python.org/downloads/
2. Selecione o botão Download Python 3.7.1 (o número exato da versão secundária
pode diferir).
2. Localize o arquivo usando o Finder e clique duas vezes no arquivo do pacote. Seguindo
os prompts de instalação.
Agora você pode confirmar a instalação bem-sucedida verificando o Python
3 como mostrado abaixo:
python3 -V
Python 3.7.1

Você também pode verificar se o pip3 está instalado listando os pacotes

disponíveis:
pip3 list

Seção do Windows 10
O Windows não inclui o Python por padrão, mas você pode instalá-lo facilmente
(junto com a ferramenta pip3 ) em python.org :
1. Baixe o instalador necessário:
1. Vá para https://www.python.org/downloads/
2. Selecione o botão Download Python 3.7.1 (o número exato da versão secundária
pode diferir).
2. Instale o Python clicando duas vezes no arquivo baixado e seguindo os prompts de
instalação
3. Certifique-se de marcar a caixa "Adicionar Python ao PATH"
Você pode então verificar se o Python 3 foi instalado inserindo o seguinte texto
no prompt de comando:

py -3 -V
Python 3.7.1

O instalador do Windows incorpora o pip3 (o gerenciador de pacotes Python)

por padrão. Você pode listar os pacotes instalados conforme mostrado:
pip3 list

Nota : O instalador deve configurar tudo o que você precisa para o comando
acima funcionar. Se, no entanto, você receber uma mensagem informando que o
Python não pode ser encontrado, talvez tenha esquecido de adicioná-lo ao
caminho do sistema. Você pode fazer isso executando o instalador novamente,
selecionando "Modificar" e marcando a caixa "Adicionar Python às variáveis de
ambiente" na segunda página.
Usando o Django dentro de um ambiente virtual
PythonSeção
As bibliotecas que usaremos para criar nossos ambientes virtuais
são virtualenvwrapper (Linux e macOS) e virtualenvwrapper-win (Windows),
que por sua vez usam a ferramenta virtualenv . As ferramentas de wrapper
criam uma interface consistente para gerenciar interfaces em todas as
plataformas.
Instalando a seção desoftware do ambiente virtual

Configuração do ambiente virtual do Ubuntu

Depois de instalar o Python e o pip, você pode instalar

o virtualenvwrapper (que inclui o virtualenv ). O guia de instalação oficial pode
ser encontrado aqui ou siga as instruções abaixo.
Instale a ferramenta usando o pip3 :
sudo pip3 install virtualenvwrapper

Em seguida, adicione as seguintes linhas ao final do seu arquivo de inicialização

do shell (este é um nome de arquivo oculto .bashrc em seu diretório
inicial). Eles definem o local onde os ambientes virtuais devem residir, o local
dos diretórios do projeto de desenvolvimento e o local do script instalado com
este pacote:
export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=' -p /usr/bin/python3 '
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh

Nota :
As variáveis VIRTUALENVWRAPPER_PYTHON e VIRTUALENVWRAPPER_VIRTUALENV_ARGS apon
tam para o local de instalação normal do Python3 e source
/usr/local/bin/virtualenvwrapper.shapontam para o local normal
do virtualenvwrapper.shscript. Se o virtualenv não funcionar quando você testá-
lo, uma coisa é verificar se o Python e o script estão no local esperado (e, em
seguida, alterar o arquivo de inicialização apropriadamente).

Você pode encontrar os locais corretos para o seu sistema usando os

comandos which virtualenvwrapper.sh e which python3.
Em seguida, recarregue o arquivo de inicialização executando o seguinte
comando no terminal:

source ~/.bashrc

Neste ponto você deve ver um monte de scripts sendo executados como
mostrado abaixo:

virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/premkproject

virtualenvwrapper.user_scripts creating
/home/ubuntu/.virtualenvs/postmkproject
...
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/preactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/postactivate
virtualenvwrapper.user_scripts creating
/home/ubuntu/.virtualenvs/get_env_details

Agora você pode criar um novo ambiente virtual com o mkvirtualenv comando.

Configuração do ambiente virtual do macOS

Configurar o virtualenvwrapper no macOS é quase exatamente igual ao do

Ubuntu (novamente, você pode seguir as instruções do guia de instalação
oficial ou abaixo.
Instale virtualenvwrapper (e empacotando virtualenv ) usando pip como
mostrado.
sudo pip3 install virtualenvwrapper

Em seguida, adicione as seguintes linhas ao final do seu arquivo de inicialização

do shell.

export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh

Nota : A VIRTUALENVWRAPPER_PYTHON variável aponta para o local de instalação

normal do Python3 e source /usr/local/bin/virtualenvwrapper.shaponta para o
local normal do virtualenvwrapper.shscript. Se o virtualenv não funcionar
quando você testá-lo, uma coisa é verificar se o Python e o script estão no local
esperado (e, em seguida, alterar o arquivo de inicialização apropriadamente).
Por exemplo, um teste de instalação no macOS acabou com as seguintes linhas
sendo necessárias no arquivo de inicialização:

export WORKON_HOME=$HOME/.virtualenvs
export
VIRTUALENVWRAPPER_PYTHON=/Library/Frameworks/Python.framework/Versions/3.7/bin
/python3
export PROJECT_HOME=$HOME/Devel
source
/Library/Frameworks/Python.framework/Versions/3.7/bin/virtualenvwrapper.sh

Você pode encontrar os locais corretos para o seu sistema usando os

comandos which virtualenvwrapper.she which python3.
Estas são as mesmas linhas do Ubuntu, mas o arquivo de inicialização é o
arquivo oculto de nome diferente .bash_profile em seu diretório inicial.
Nota : Se você não encontrar o .bash_profile para editar no finder, você também
pode abrir isto no terminal usando o nano.
Os comandos são parecidos com isto:
cd ~ # Navigate to my home directory
ls -la #List the content of the directory. YOu should see .bash_profile
nano .bash_profile # Open the file in the nano text editor, within the
terminal
# Scroll to the end of the file, and copy in the lines above
# Use Ctrl+X to exit nano, Choose Y to save the file.

Em seguida, recarregue o arquivo de inicialização fazendo a seguinte chamada

no terminal:

source ~/.bash_profile

Neste ponto, você pode ver um monte de scripts sendo executados (os mesmos
scripts da instalação do Ubuntu). Agora você deve ser capaz de criar um novo
ambiente virtual com o mkvirtualenv comando.

Configuração do ambiente virtual do Windows 10

Instalar o virtualenvwrapper-win é ainda mais simples do que configurar

o virtualenvwrapper porque você não precisa configurar onde a ferramenta
armazena informações do ambiente virtual (existe um valor padrão). Tudo o que
você precisa fazer é executar o seguinte comando no prompt de comando:
pip3 install virtualenvwrapper-win

Agora você pode criar um novo ambiente virtual com o mkvirtualenv comando
Criando uma Seção deAmbiente Virtual
Depois de instalar o virtualenvwrapper ou o virtualenvwrapper-win , trabalhar
com ambientes virtuais é muito semelhante em todas as plataformas.
Agora você pode criar um novo ambiente virtual com
o mkvirtualenv comando. Quando este comando for executado, você verá o
ambiente sendo configurado (o que você vê é um pouco específico da
plataforma). Quando o comando concluir o novo ambiente virtual estará ativo -
você pode ver isso porque o início do prompt será o nome do ambiente entre
parênteses (abaixo mostramos isso para o Ubuntu, mas a linha final é
semelhante para Windows / macOS) .
$ mkvirtualenv my_django_environment

Running virtualenv with interpreter /usr/bin/python3

...
virtualenvwrapper.user_scripts creating
/home/ubuntu/.virtualenvs/t_env7/bin/get_env_details
(my_django_environment) ubuntu@ubuntu:~$

Agora você está dentro do ambiente virtual, você pode instalar o Django e
começar a desenvolver.
 Nota : De agora em diante neste artigo (e na verdade o módulo), por favor,
assuma que quaisquer comandos são executados dentro de um ambiente virtual
Python como o que configuramos acima.
Usando uma seção deambiente virtual
Há apenas alguns outros comandos úteis que você deve saber (há mais na
documentação da ferramenta, mas esses são os que você usará regularmente):

 deactivate - Saia do ambiente virtual atual do Python

 workon - Listar ambientes virtuais disponíveis
 workon name_of_environment - Ativar o ambiente virtual especificado do Python
 rmvirtualenv name_of_environment - Remova o ambiente especificado.

Instalando o DjangoSeção
Uma vez que você tenha criado um ambiente virtual e chamado workon para
inseri-lo, você pode usar o pip3 para instalar o Django.
pip3 install django

Você pode testar se o Django está instalado executando o seguinte comando

(isso apenas testa que o Python pode encontrar o módulo do Django):

# Linux/macOS
python3 -m django --version
2.1.5

# Windows
py -3 -m django --version
2.1.5

Nota : Se o comando acima do Windows não mostrar um módulo django

presente, tente:

py -m django --version

No Windows Python 3, os scripts são iniciados com o prefixo do comando py -3,

embora isso possa variar dependendo da instalação específica. Tente omitir o -
3 modificador se você encontrar algum problema com os comandos. No Linux /
macOS, o comando épython3.
Importante : O restante deste módulo usa o comando Linux para chamar o
Python 3 ( python3). Se você está trabalhando no Windows, basta substituir este
prefixo por: py -3
Testando sua instalaçãoSeção
O teste acima funciona, mas não é muito divertido. Um teste mais interessante é
criar um projeto de esqueleto e vê-lo funcionando. Para fazer isso, primeiro
navegue em seu prompt de comando / terminal para onde deseja armazenar
seus aplicativos do Django. Crie uma pasta para o seu site de teste e navegue
para ela.
mkdir django_test
cd django_test

Você pode então criar um novo site esqueleto chamado " mytestsite " usando
a ferramenta django-admin como mostrado. Depois de criar o site, você pode
navegar até a pasta onde você encontrará o script principal para gerenciar
projetos, chamado manage.py .
django-admin startproject mytestsite
cd mytestsite

Podemos executar o servidor da web de desenvolvimento a partir dessa pasta

usando manage.py e o runservercomando, como mostrado.
$ python3 manage.py runserver
Performing system checks...

System check identified no issues (0 silenced).

You have 15 unapplied migration(s). Your project may not work properly until
you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.

December 16, 2018 - 07:06:30

Django version 2.1.5, using settings 'mytestsite.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Nota : O comando acima mostra o comando Linux / macOS. Você pode ignorar
os avisos sobre "15 migração (ões) não aplicada (s)" neste momento!
Uma vez que o servidor está em execução, você pode ver o site, navegando
para o seguinte URL no seu navegador web local: http://127.0.0.1:8000/. Você
deve ver um site assim:

ResumoSeção
Agora você tem um ambiente de desenvolvimento do Django instalado e
rodando no seu computador.

Na seção de testes, você também viu brevemente como podemos criar um novo
site do Django usando django-admin startprojecte executá-lo em seu
navegador usando o servidor da web de desenvolvimento ( python3 manage.py
runserver). No próximo artigo, expandimos esse processo, criando um aplicativo
da Web simples, mas completo.
 Tutorial do Django: o site da
Biblioteca Local
 línguas
AnteriorVisão geral: DjangoNext

O primeiro artigo da nossa série de tutoriais prático explica o que você

aprenderá e fornece uma visão geral do exemplo de site da "biblioteca local", no
qual estaremos trabalhando e evoluindo em artigos subsequentes.

Pré- Leia a introdução do Django . Para os artigos a seguir, você também

requisitos: precisará configurar um ambiente de desenvolvimento do Django .

Objetivo: Apresentar o aplicativo de exemplo usado neste tutorial e permitir que os leitores
entendam quais tópicos serão abordados.

visão globalSeção
Bem-vindo ao tutorial do Django "Biblioteca Local" do MDN, no qual
desenvolvemos um site que pode ser usado para gerenciar o catálogo de uma
biblioteca local.

Nesta série de artigos de tutorial você irá:

 Use as ferramentas do Django para criar um site e aplicativo esqueleto.

 Inicie e pare o servidor de desenvolvimento.
 Crie modelos para representar os dados da sua aplicação.
 Use o site de administração do Django para preencher os dados do seu site.
 Crie visualizações para recuperar dados específicos em resposta a diferentes
solicitações e modelos para renderizar os dados como HTML a serem exibidos
no navegador.
 Crie mapeadores para associar diferentes padrões de URL a visualizações
específicas.
 Adicione autorização do usuário e sessões para controlar o comportamento e o
acesso do site.
 Trabalhe com formulários.
 Escreva o código de teste para seu aplicativo.
 Use a segurança do Django de forma eficaz.
 Implemente seu aplicativo na produção.
Você já aprendeu sobre alguns desses tópicos e tocou brevemente nos
outros. No final da série de tutoriais, você deve saber o suficiente para
desenvolver aplicativos simples do Django por conta própria.
 O site da LocalLibrarySeção
LocalLibrary é o nome do site que criaremos e evoluiremos ao longo desta
série de tutoriais. Como seria de esperar, o objetivo do site é fornecer um
catálogo on-line para uma pequena biblioteca local, onde os usuários podem
procurar livros disponíveis e gerenciar suas contas.
Este exemplo foi cuidadosamente escolhido porque pode ser dimensionado
para mostrar o máximo ou mínimo de detalhes que precisamos, e pode ser
usado para exibir quase todos os recursos do Django. Mais importante, nos
permite fornecer um caminho guiado através da funcionalidade mais importante
no framework web Django:
 Nos primeiros artigos do tutorial, definiremos uma biblioteca simples somente
para navegação que os membros da biblioteca podem usar para descobrir
quais livros estão disponíveis. Isso nos permite explorar as operações comuns a
quase todos os sites: ler e exibir conteúdo de um banco de dados.
 Conforme avançamos, o exemplo da biblioteca se estende naturalmente para
demonstrar recursos mais avançados do Django. Por exemplo, podemos
estender a biblioteca para permitir que os usuários reservem livros e usar isso
para demonstrar como usar formulários e oferecer suporte à autenticação do
usuário.
Embora este seja um exemplo muito extensível, ele é chamado
de Biblioteca Local por um motivo - esperamos mostrar as informações
mínimas que o ajudarão a trabalhar com o Django rapidamente. Como
resultado, armazenaremos informações sobre livros, cópias de livros, autores e
outras informações importantes. No entanto, não armazenaremos informações
sobre outros itens que uma biblioteca pode armazenar ou forneceremos a
infraestrutura necessária para suportar vários sites de bibliotecas ou outros
recursos de "grande biblioteca".
Estou preso, onde posso obter a fonte?Seção
Enquanto você trabalha no tutorial, forneceremos os trechos de código
apropriados para você copiar e colar em cada ponto, e haverá outro código que
esperamos que você estenda (com alguma orientação).

Se você ficar preso, você pode encontrar a versão totalmente desenvolvida do

site no Github aqui .
ResumoSeção
Agora que você sabe um pouco mais sobre o site da LocalLibrary e o que você
vai aprender, é hora de começar a criar um projeto de esqueleto para conter
nosso exemplo.
 Tutorial do Django Parte 2: Criando
um site esqueleto
 línguas
AnteriorVisão geral: DjangoNext

Este segundo artigo em nosso Tutorial do Django mostra como você pode criar
um projeto de site "esqueleto" como base, que pode ser preenchido com
configurações, caminhos, modelos, visualizações e modelos específicos do site.
Pré- Configure um ambiente de desenvolvimento do Django .Revise
requisitos: o tutorial do Django .

Objetivo: Para poder usar as ferramentas do Django para iniciar seus próprios projetos de
novos sites.

visão globalSeção
Este artigo mostra como você pode criar um site "esqueleto", que pode ser
preenchido com configurações, caminhos, modelos, exibições e modelos
específicos do site (discutiremos isso em artigos posteriores).

O processo é direto:

1. Use a django-adminferramenta para criar a pasta do projeto, os modelos básicos

de arquivos e o script de gerenciamento de projetos ( manage.py ).
2. Use o manage.py para criar um ou mais aplicativos .
Nota : Um site pode consistir de uma ou mais seções, por exemplo, site
principal, blog, wiki, área de downloads, etc. O Django o incentiva a
desenvolver esses componentes como aplicativos separados , que poderiam ser
reutilizados em projetos diferentes, se desejado.
3. Registre os novos aplicativos para incluí-los no projeto.
4. Conecte o mapeador de caminho / URL para cada aplicativo.
Para o site da Biblioteca Local, a pasta do site e sua pasta de projeto serão
denominadas locallibrary , e teremos apenas um aplicativo
denominado catálogo . A estrutura de pastas de nível superior será, portanto, a
seguinte:
locallibrary/ # Website folder
manage.py # Script to run Django tools for this project (created
using django-admin)
locallibrary/ # Website/project folder (created using django-admin)
catalog/ # Application folder (created using manage.py)

As seções a seguir discutem as etapas do processo em detalhes e mostram

como você pode testar as alterações. No final do artigo, discutimos algumas das
outras configurações de todo o site que você também pode fazer neste estágio.
 Criando o projetoSeção
Primeiro abra um prompt de comando / terminal, verifique se você está em
seu ambiente virtual , navegue até onde deseja armazenar seus aplicativos do
Django (faça com que seja fácil encontrá-lo dentro da pasta de documentos ) e
crie uma pasta para seu novo site ( neste caso: django_projects ). Então entre
na pasta usando o comando cd:
mkdir django_projects
cd django_projects

Crie o novo projeto usando o django-admin startproject comando conforme

mostrado e navegue até a pasta.
django-admin startproject locallibrary
cd locallibrary

A django-adminferramenta cria uma estrutura de pastas / arquivos, como

mostrado abaixo:
locallibrary/
manage.py
locallibrary/
__init__.py
settings.py
urls.py
wsgi.py

Nosso diretório de trabalho atual deve ser algo como isto:

../django_projects/locallibrary/

A subpasta do projeto locallibrary é o ponto de entrada para o site:

 __init__.py é um arquivo vazio que instrui o Python a tratar esse diretório como
um pacote Python.
 O settings.py contém todas as configurações do site. É aqui que registramos
os aplicativos que criamos, a localização de nossos arquivos estáticos, detalhes
de configuração do banco de dados etc.
 O urls.py define os mapeamentos de URL para visualização do site. Embora
isso possa conter todo o código de mapeamento de URL, é mais comum
delegar parte do mapeamento a aplicativos específicos, como você verá mais
adiante.
 wsgi.py é usado para ajudar sua aplicação Django a se comunicar com o
servidor web.Você pode tratar isso como clichê.
O script manage.py é usado para criar aplicativos, trabalhar com bancos de
dados e iniciar o servidor da web de desenvolvimento.
Criando o aplicativo de catálogoSeção
Em seguida, execute o seguinte comando para criar o aplicativo
de catálogo que viverá dentro do nosso projeto localibrary (isso deve ser
executado na mesma pasta que o manage.py do seu projeto ):
 python3 manage.py startapp catalog

Nota : o comando acima é para Linux / macOS X. No Windows, o comando deve

ser: py -3 manage.py startapp catalog
Se você estiver trabalhando no Windows, faça a substituição de python3com py -
3todo este módulo.
Se você estiver usando o Python 3.7.0 ou posterior, só deverá usar py manage.py
startapp catalog

A ferramenta cria uma nova pasta e a preenche com arquivos para as diferentes
partes do aplicativo (mostradas em negrito abaixo). A maioria dos arquivos é
nomeada de acordo com sua finalidade (por exemplo, as visualizações devem
ser armazenadas em views.py , modelos em models.py , testes em tests.py ,
configuração do site de administração em admin.py , registro de aplicativos
em apps.py ) e conter algum código clichê mínimo para trabalhar com os
objetos associados.
O diretório do projeto atualizado agora deve ter esta aparência:

locallibrary/
manage.py
locallibrary/
catalog/
admin.py
apps.py
models.py
tests.py
views.py
__init__.py
migrations/

Além disso, agora temos:

 Uma pasta de migrações , usada para armazenar "migrações" - arquivos que

permitem atualizar automaticamente seu banco de dados à medida que você
modifica seus modelos.
 __init__.py - um arquivo vazio criado aqui para que o Django / Python
reconheça a pasta como um pacote Python e permita que você use seus
objetos dentro de outras partes do projeto.
Nota : Você notou o que está faltando na lista de arquivos acima? Embora exista
um local para suas visualizações e modelos, não há lugar para você colocar seus
mapeamentos de URL, modelos e arquivos estáticos. Mostraremos como criá-las
mais adiante (elas não são necessárias em todos os sites, mas são necessárias
neste exemplo).

Registrando o aplicativo de catálogoSeção

Agora que o aplicativo foi criado, temos que registrá-lo no projeto para que ele
seja incluído quando qualquer ferramenta for executada (por exemplo, para
adicionar modelos ao banco de dados). Aplicativos são registrados,
adicionando-os à INSTALLED_APPSlista nas configurações do projeto.
Abra o arquivo de configurações do projeto django_projects / locallibrary /
locallibrary / settings.py e encontre a definição para a INSTALLED_APPS lista. Em
seguida, adicione uma nova linha no final da lista, como mostrado em negrito
abaixo.
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'catalog.apps.CatalogConfig',
]

A nova linha especifica o objeto de configuração do aplicativo ( CatalogConfig)

que foi gerado para você em /locallibrary/catalog/apps.py quando você criou
o aplicativo.
Nota : Você notará que já existem muitos
outros INSTALLED_APPS (e MIDDLEWAREmais abaixo no arquivo de
configurações). Estes permitem o suporte para o site de
administraçãodo Django e como resultado muitas das funcionalidades que ele
usa (incluindo sessões, autenticação, etc).

Especificando o banco de dadosSeção

Este também é o ponto em que você normalmente especificaria o banco de
dados a ser usado para o projeto - faz sentido usar o mesmo banco de dados
para desenvolvimento e produção, sempre que possível, a fim de evitar
pequenas diferenças de comportamento. Você pode descobrir as diferentes
opções em Bancos de Dados (Django docs).
Usaremos o banco de dados SQLite para este exemplo, porque não esperamos
exigir muito acesso simultâneo em um banco de dados de demonstração, e
também porque não requer nenhum trabalho adicional para configurar! Você
pode ver como este banco de dados é configurado em settings.py (mais
informações também estão incluídas abaixo):
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}

Como estamos usando o SQLite, não precisamos fazer mais nenhuma

configuração aqui. Vamos continuar!

Outras configurações do projetoSeção

O arquivo settings.py também é usado para configurar um número de outras
configurações, mas neste ponto você provavelmente só quer mudar
o TIME_ZONE - isso deve ser igual a uma string da lista padrão de fusos
horários do banco de dados tz (a coluna TZ na tabela contém os valores
 desejados). Altere seu TIME_ZONEvalor para uma dessas strings apropriadas para
seu fuso horário, por exemplo:
TIME_ZONE = 'Europe/London'

Existem duas outras configurações que você não vai mudar agora, mas que
você deve estar ciente de:

 SECRET_KEY. Esta é uma chave secreta que é usada como parte da estratégia de
segurança de sites do Django. Se você não estiver protegendo esse código em
desenvolvimento, precisará usar um código diferente (talvez lido em uma
variável ou arquivo de ambiente) ao colocá-lo em produção.
 DEBUG. Isso permite que os logs de depuração sejam exibidos em erro, em vez
de respostas de código de status HTTP. Isso deve ser definido como Falseem
produção, pois as informações de depuração são úteis para os invasores, mas,
por enquanto, podemos mantê-las definidas para True.
Conectando o mapeador de URLsSeção
O site é criado com um arquivo de mapeamento de URL ( urls.py ) na pasta do
projeto. Embora você possa usar esse arquivo para gerenciar todos os
mapeamentos de URL, é mais comum adiar os mapeamentos para o aplicativo
associado.
Abra locallibrary / locallibrary / urls.py e observe o texto instrucional que
explica algumas das formas de usar o mapeador de URLs.
"""locallibrary URL Configuration

The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/2.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path

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

Os mapeamentos de URL são gerenciados por meio da urlpatternsvariável, que

é uma listade path()funções do Python . Cada path() função associa um padrão
de URL a uma exibição específica , que será exibida quando o padrão for
correspondido ou com outra lista de código de teste de padrão de URL (nesse
segundo caso, o padrão se tornará a "URL de base" para padrões definidos no
módulo de destino). A urlpatterns lista define inicialmente uma única função
que mapeia todas as URLs com o padrão admin / para o
módulo admin.site.urls, que contém as próprias definições de mapeamento de
URL do aplicativo Administration.
Nota : A rota em path()é uma cadeia que define um padrão de URL para
corresponder. Esta string pode incluir uma variável nomeada (entre colchetes
angulares), por exemplo 'catalog/<id>/'. Esse padrão corresponderá a uma
URL como / catalog / any_chars / e passará any_chars para a view como uma
string com o nome do parâmetro id. Discutimos os métodos de caminho e os
padrões de rota em tópicos posteriores.
Adicione as linhas abaixo à parte inferior do arquivo para adicionar um novo
item à urlpatternslista. Este novo item inclui um path()que encaminha
solicitações com o padrão catalog/ para o módulo catalog.urls(o arquivo com a
URL relativa /catalog/urls.py ).
# Use include() to add paths from the catalog application
from django.urls import include
from django.urls import path

urlpatterns += [
path('catalog/', include('catalog.urls')),
]

Agora vamos redirecionar o URL raiz do nosso site (isto é 127.0.0.1:8000) para o
URL 127.0.0.1:8000/catalog/; este é o único aplicativo que usaremos neste
projeto, então podemos também. Para fazer isso, usaremos uma função de
visualização especial ( RedirectView), que toma como primeiro argumento a
nova URL relativa para redirecionar para ( /catalog/) quando o padrão de URL
especificado na path()função é correspondido (a URL raiz, nesse caso).
Adicione as seguintes linhas, novamente à parte inferior do arquivo:

#Add URL maps to redirect the base URL to our application

from django.views.generic import RedirectView
urlpatterns += [
path('', RedirectView.as_view(url='/catalog/', permanent=True)),
]

Deixe o primeiro parâmetro da função path vazio para implicar '/'. Se você
escrever o primeiro parâmetro como '/', o Django dará o seguinte aviso quando
você iniciar o servidor de desenvolvimento:

System check identified some issues:

WARNINGS:
?: (urls.W002) Your URL pattern '/' has a route beginning with a '/'.
Remove this slash as it is unnecessary.
If this pattern is targeted in an include(), ensure the include() pattern has
a trailing '/'.

O Django não oferece arquivos estáticos como CSS, JavaScript e imagens por
padrão, mas pode ser útil para o servidor web de desenvolvimento fazer isso
enquanto você cria seu site. Como adição final a esse mapeador de URL, você
pode ativar a veiculação de arquivos estáticos durante o desenvolvimento,
anexando as linhas a seguir.

Adicione o seguinte bloco final à parte inferior do arquivo agora:

# Use static() to add url mapping to serve static files during development
(only)
from django.conf import settings
from django.conf.urls.static import static

urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

Nota : Há várias maneiras de estender a urlpatternslista (acima, apenas

acrescentamos um novo item da lista usando o +=operador para separar
claramente o código antigo e o novo). Poderíamos ter apenas incluído este novo
mapa de padrões na definição da lista original:

urlpatterns = [

caminho ('admin /', admin.site.urls),

path ('catalog /', include ('catalog.urls')),

path ('', RedirectView.as_view (url = '/ catalog /', permanent = True)),

] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

Além disso, incluímos a linha de importação ( from django.urls import include)

com o código que a utiliza (assim, é fácil ver o que adicionamos), mas é comum
incluir todas as linhas de importação no topo de um arquivo Python.
Como etapa final, crie um arquivo dentro de sua pasta de catálogo
chamado urls.py e adicione o seguinte texto para definir o (vazio)
importado urlpatterns. É aqui que vamos adicionar nossos padrões à medida
que construímos o aplicativo.
from django.urls import path
from . import views

urlpatterns = [

Testando o framework do siteSeção

Neste ponto, temos um projeto esqueleto completo. O site não faz nada ainda,
mas vale a pena executá-lo para garantir que nenhuma das nossas alterações
tenha quebrado nada.
Antes de fazermos isso, devemos primeiro executar uma migração de banco de
dados . Isso atualiza nosso banco de dados para incluir quaisquer modelos em
nossos aplicativos instalados (e remove alguns avisos de compilação).
Seção de Migração de Banco de Dados em Execução
O Django usa um Object-Relational-Mapper (ORM) para mapear as definições
de modelo no código do Django para a estrutura de dados usada pelo banco de
dados subjacente. À medida que mudamos nossas definições de modelo, o
Django rastreia as alterações e pode criar scripts de migração de banco de
dados (em / locallibrary / catalog / migrations / ) para migrar automaticamente
a estrutura de dados subjacente no banco de dados para corresponder ao
modelo.
Quando criamos o site, o Django adicionou automaticamente vários modelos
para uso pela seção de administração do site (que veremos mais
adiante). Execute os seguintes comandos para definir tabelas para esses
modelos no banco de dados (certifique-se de estar no diretório que
contém manage.py ):
python3 manage.py makemigrations
python3 manage.py migrate

Importante : você precisará executar os comandos acima toda vez que seus
modelos forem alterados de forma a afetar a estrutura dos dados que precisam
ser armazenados (incluindo a adição e remoção de modelos inteiros e campos
individuais).
O makemigrations comando cria (mas não aplica) as migrações para todos os
aplicativos instalados em seu projeto (você também pode especificar o nome do
aplicativo para executar apenas uma migração para um único projeto). Isso lhe
dá a chance de verificar o código para essas migrações antes que elas sejam
aplicadas - quando você é um especialista em Django, você pode escolher
ajustá-las ligeiramente!
O migratecomando realmente aplica as migrações ao seu banco de dados (o
Django rastreia quais foram adicionadas ao banco de dados atual).
Nota : Veja Migrações (Django docs) para informações adicionais sobre os
comandos de migração menos usados.

Executando a seção dosite

Durante o desenvolvimento, você pode testar o site primeiro exibindo- o usando
o servidor da Web de desenvolvimento e visualizando-o no navegador da Web
local.
Nota : O servidor da Web de desenvolvimento não é robusto ou com
desempenho suficiente para uso em produção, mas é uma maneira muito fácil
de colocar seu site do Django em funcionamento durante o desenvolvimento
para oferecer um teste rápido conveniente. Por padrão, ele irá servir o site para o
seu computador local ( http://127.0.0.1:8000/), mas você também pode
especificar outros computadores em sua rede para servir. Para obter mais
informações, consulte django-admin e manage.py: runserver (Django docs).
Execute o servidor da web de desenvolvimento chamando o runservercomando
(no mesmo diretório que manage.py ):
python3 manage.py runserver
Performing system checks...

System check identified no issues (0 silenced).

August 15, 2018 - 16:11:26
Django version 2.1, using settings 'locallibrary.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

Quando o servidor estiver em execução, você poderá visualizar o site

navegando http://127.0.0.1:8000/em seu navegador da Web local. Você deve
ver uma página de erro do site que se parece com isso:

Não se preocupe! Essa página de erro é esperada porque não temos páginas /
URLs definidas no catalogs.urlsmódulo (para o qual somos redirecionados
quando obtemos uma URL para a raiz do site).
Nota : A página acima demonstra um ótimo recurso do Django - registro
automatizado de depuração. Uma tela de erro será exibida com informações
úteis sempre que uma página não puder ser encontrada ou qualquer erro for
levantado pelo código. Nesse caso, podemos ver que o URL que fornecemos não
corresponde a nenhum dos nossos padrões de URL (conforme listado). O
registro será desativado durante a produção (quando colocarmos o site ao vivo
na Web), caso em que uma página menos informativa, mas mais fácil de usar,
será exibida.
Neste ponto, sabemos que o Django está funcionando!

Observação : você deve executar novamente as migrações e testar novamente o

site sempre que fizer alterações significativas. Não demora muito tempo!

Desafie-seSeção
O catálogo / diretório contém arquivos para as visualizações, modelos e outras
partes do aplicativo. Abra esses arquivos e inspecione o clichê.
Como você viu acima, um mapeamento de URL para o site Admin já foi
adicionado no urls.pydo projeto . Navegue até a área administrativa em seu
navegador e veja o que acontece (você pode inferir o URL correto do
mapeamento acima).
ResumoSeção
Agora você criou um projeto de site esqueleto completo, que pode ser
preenchido com URLs, modelos, visualizações e modelos.

Agora que o esqueleto do site da Biblioteca Local está completo e em

execução, é hora de começar a escrever o código que faz este site fazer o que
deve fazer.
 Tutorial do Django Parte 3: Usando
modelos
 línguas
AnteriorVisão geral: DjangoNext

Este artigo mostra como definir modelos para o site da LocalLibrary . Explica o
que é um modelo, como ele é declarado e alguns dos principais tipos de
campo. Ele também mostra brevemente algumas das principais maneiras de
acessar os dados do modelo.
Pré-requisitos: Tutorial do Django Parte 2: Criando um site esqueleto .

Objetivo: Ser capaz de projetar e criar seus próprios modelos, escolhendo campos apropriadamente.

visão globalSeção
Os aplicativos da Web do Django acessam e gerenciam dados por meio de
objetos do Python chamados de modelos. Os modelos definem a estrutura dos
dados armazenados, incluindo os tipos de campo e possivelmente também seu
tamanho máximo, valores padrão, opções de lista de seleção, texto de ajuda
para documentação, texto de etiqueta para formulários etc. A definição do
modelo é independente do banco de dados subjacente você pode escolher um
dentre vários como parte das configurações do seu projeto. Uma vez que você
escolheu qual banco de dados você quer usar, você não precisa falar
diretamente com ele - você apenas escreve sua estrutura de modelo e outro
código, e o Django lida com todo o trabalho sujo de se comunicar com o banco
de dados para você.
Este tutorial mostra como definir e acessar os modelos para o exemplo
do site da LocalLibrary.
Criando os modelos da LocalLibrarySeção
Antes de entrar e começar a codificar os modelos, vale a pena dedicar alguns
minutos para pensar sobre quais dados precisamos armazenar e as relações
entre os diferentes objetos.

Sabemos que precisamos armazenar informações sobre livros (título, resumo,

autor, linguagem escrita, categoria, ISBN) e que podemos ter várias cópias
disponíveis (com id globalmente exclusivo, status de disponibilidade,
etc.). Podemos precisar armazenar mais informações sobre o autor do que
apenas seu nome, e pode haver vários autores com os mesmos nomes ou
nomes semelhantes. Queremos ser capazes de classificar informações com
base no título do livro, autor, idioma escrito e categoria.

Ao projetar seus modelos, faz sentido ter modelos separados para cada "objeto"
(grupo de informações relacionadas). Nesse caso, os objetos óbvios são livros,
instâncias de livros e autores.
Você também pode querer usar modelos para representar opções de lista de
seleção (por exemplo, como uma lista suspensa de opções), em vez de
codificar as opções no próprio site - isso é recomendado quando todas as
opções não são conhecidas antecipadamente ou podem mudança. Os
candidatos óbvios a modelos neste caso incluem o gênero de livro (por
exemplo, ficção científica, poesia francesa, etc.) e idioma (inglês, francês,
japonês).

Uma vez que decidimos sobre nossos modelos e campo, precisamos pensar
sobre os relacionamentos. O Django permite que você defina relacionamentos
que são um para um ( OneToOneField), um para muitos ( ForeignKey) e muitos
para muitos ( ManyToManyField).
Com isso em mente, o diagrama de associação da UML abaixo mostra os
modelos que definiremos nesse caso (como caixas). Como acima, criamos
modelos para livro (os detalhes genéricos do livro), instância de livro (status de
cópias físicas específicas do livro disponível no sistema) e autor. Também
decidimos ter um modelo para o gênero, para que os valores possam ser
criados / selecionados através da interface administrativa. Decidimos não ter um
modelo para o BookInstance:status - codificamos os valores ( LOAN_STATUS)
porque não esperamos que isso mude. Dentro de cada uma das caixas você
pode ver o nome do modelo, os nomes e tipos de campos, e também os
métodos e seus tipos de retorno.
O diagrama também mostra as relações entre os modelos, incluindo
suas multiplicidades . As multiplicidades são os números no diagrama que
mostram os números (máximo e mínimo) de cada modelo que podem estar
presentes no relacionamento. Por exemplo, a linha de conexão entre as caixas
mostra que Livro e um Gênero estão relacionados. Os números próximos ao
modelo Gênero mostram que um livro deve ter um ou mais gêneros (quantos
você quiser), enquanto os números do outro lado da linha ao lado do modelo
Livro mostram que um Gênero pode ter zero ou muitos associados livros.
Nota : A próxima seção fornece uma cartilha básica explicando como os modelos
são definidos e usados. Ao lê-lo, considere como vamos construir cada um dos
modelos no diagrama acima.
Primer modeloSeção
Esta seção fornece uma breve visão geral de como um modelo é definido e
alguns dos campos e argumentos de campo mais importantes.

Seção de definição de modelo

Os modelos geralmente são definidos no arquivo models.py de um
aplicativo . Eles são implementados como subclasses
de django.db.models.Modele podem incluir campos, métodos e metadados. O
 fragmento de código abaixo mostra um modelo "típico",
denominado MyModelName:
from django.db import models

class MyModelName(models.Model):
"""A typical class defining a model, derived from the Model class."""

# Fields
my_field_name = models.CharField(max_length=20, help_text='Enter field
documentation')
...

# Metadata
class Meta:
ordering = ['-my_field_name']

# Methods
def get_absolute_url(self):
"""Returns the url to access a particular instance of MyModelName."""
return reverse('model-detail-view', args=[str(self.id)])

def __str__(self):
"""String for representing the MyModelName object (in Admin site
etc.)."""
return self.my_field_name

Nas seções abaixo, exploraremos detalhadamente cada um dos recursos

dentro do modelo:

Campos

Um modelo pode ter um número arbitrário de campos, de qualquer tipo - cada

um representa uma coluna de dados que queremos armazenar em uma de
nossas tabelas de banco de dados. Cada registro de banco de dados (linha)
consistirá em um de cada valor de campo. Vamos ver o exemplo abaixo:

my_field_name = models.CharField(max_length=20, help_text='Enter field

documentation')

Nosso exemplo acima tem um único campo chamado my_field_name, do

tipo models.CharField- o que significa que esse campo conterá sequências de
caracteres alfanuméricos. Os tipos de campo são atribuídos usando classes
específicas, que determinam o tipo de registro usado para armazenar os dados
no banco de dados, juntamente com os critérios de validação a serem usados
quando os valores são recebidos de um formulário HTML (ou seja, o que
constitui um valor válido). Os tipos de campo também podem receber
argumentos que especifiquem como o campo é armazenado ou pode ser
usado. Neste caso, estamos dando ao nosso campo dois argumentos:
 max_length=20 - Afirma que o comprimento máximo de um valor neste campo é de 20
caracteres.
 help_text='Enter field documentation' - fornece um rótulo de texto para exibir para
ajudar os usuários a saber qual valor fornecer quando esse valor é inserido por um
usuário por meio de um formulário HTML.
O nome do campo é usado para se referir a ele em consultas e modelos. Os
campos também têm um rótulo, que é especificado como um argumento
( verbose_name) ou inferido ao se capitalizar a primeira letra do nome da variável
do campo e substituindo quaisquer sublinhados por um espaço (por
exemplo my_field_name, teria um rótulo padrão de Meu nome de campo).
A ordem em que os campos são declarados afetará sua ordem padrão se um
modelo for renderizado em um formulário (por exemplo, no site Admin), embora
isso possa ser substituído.

Argumentos do campo comum

Os seguintes argumentos comuns podem ser usados ao declarar muitos / a
maioria dos diferentes tipos de campo:

 help_text : Fornece um rótulo de texto para formulários HTML (por exemplo, no site
admin), conforme descrito acima.
 verbose_name : um nome legível para o campo usado nos rótulos de campo. Se não
for especificado, o Django irá inferir o nome detalhado do nome do campo.
 padrão : o valor padrão do campo. Isso pode ser um valor ou um objeto que pode ser
chamado, caso em que o objeto será chamado toda vez que um novo registro for
criado.
 null : Se True, o Django irá armazenar valores NULLem branco como no banco de dados
para campos onde isto é apropriado (a CharFieldirá armazenar uma string vazia). O
padrão é False.
 blank : Se True, o campo tiver permissão para ficar em branco nos seus formulários. O
padrão é False, o que significa que a validação de formulário do Django forçará você a
inserir um valor. Isso é frequentemente usado com null=True, porque se você for
permitir valores em branco, também deseja que o banco de dados possa representá-los
adequadamente.
 escolhas : um grupo de escolhas para este campo. Se isso for fornecido, o widget de
formulário correspondente padrão será uma caixa de seleção com essas opções, em
vez do campo de texto padrão.
 primary_key : If True, define o campo atual como a chave primária do modelo (uma
chave primária é uma coluna especial do banco de dados designada para identificar
exclusivamente todos os registros de tabela diferentes). Se nenhum campo for
especificado como a chave primária, o Django adicionará automaticamente um campo
para essa finalidade.
Existem muitas outras opções - você pode ver a lista completa de opções de
campo aqui .
Tipos de campo comuns
A lista a seguir descreve alguns dos tipos de campos mais usados.

 CharField é usado para definir strings de comprimento fixo de tamanho médio a

curto. Você deve especificar max_lengthos dados a serem armazenados.
 TextField é usado para grandes cadeias de comprimento arbitrário. Você pode
especificar um max_lengthpara o campo, mas isso é usado somente quando o campo é
exibido em formulários (ele não é imposto no nível do banco de dados).
 IntegerField é um campo para armazenar valores inteiros (número inteiro) e para
validar valores inseridos como números inteiros em formulários.
 DateField e DateTimeField são usados para armazenar / representar datas e
informações de data / hora (como Python datetime.datein e datetime.datetimeobjects,
respectivamente). Esses campos também podem declarar os parâmetros (mutuamente
exclusivos) auto_now=True(para definir o campo para a data atual toda vez que o
modelo é salvo), auto_now_add(para definir apenas a data em que o modelo é criado
pela primeira vez) e default(para definir uma data padrão pode ser substituído pelo
usuário).
 EmailField é usado para armazenar e validar endereços de e-mail.
 FileField e ImageField são usados para carregar arquivos e imagens, respectivamente
( ImageFieldsimplesmente adiciona uma validação adicional de que o arquivo enviado
é uma imagem). Estes têm parâmetros para definir como e onde os arquivos enviados
são armazenados.
 O AutoField é um tipo especial de IntegerFieldincrementos automáticos. Uma chave
primária desse tipo é automaticamente adicionada ao seu modelo se você não
especificar explicitamente uma.
 O ForeignKey é usado para especificar um relacionamento um-para-muitos com outro
modelo de banco de dados (por exemplo, um carro tem um fabricante, mas um
fabricante pode fabricar muitos carros). O lado "um" do relacionamento é o modelo que
contém a chave.
 ManyToManyField é usado para especificar um relacionamento muitos-para-muitos
(por exemplo, um livro pode ter vários gêneros e cada gênero pode conter vários
livros). Em nosso aplicativo de biblioteca, vamos usá-los de maneira muito
semelhante ForeignKeys, mas eles podem ser usados de maneiras mais complicadas
para descrever as relações entre os grupos. Estes têm o parâmetro on_deletepara
definir o que acontece quando o registro associado é excluído (por exemplo, um valor
de models.SET_NULLsimplesmente definir o valor para NULL).
Existem muitos outros tipos de campos, incluindo campos para diferentes tipos
de números (inteiros grandes, inteiros pequenos, flutuantes), booleanos, URLs,
slugs, ids únicos e outras informações "relacionadas ao tempo" (duração,
tempo, etc.) . Você pode ver a lista completa aqui .

Metadados

Você pode declarar metadados em nível de modelo para seu modelo

declarando class Meta, conforme mostrado.
class Meta:
ordering = ['-my_field_name']

Um dos recursos mais úteis desses metadados é controlar a ordem padrão de

registros retornados quando você consulta o tipo de modelo. Você faz isso
especificando a ordem de correspondência em uma lista de nomes de campos
para o orderingatributo, como mostrado acima. A ordem dependerá do tipo de
campo (os campos de caractere são classificados em ordem alfabética,
enquanto os campos de data são classificados em ordem cronológica). Como
mostrado acima, você pode prefixar o nome do campo com um símbolo de
menos (-) para inverter a ordem de classificação.
Então, como exemplo, se optássemos por ordenar livros como este por padrão:

ordering = ['title', '-pubdate']

os livros seriam classificados em ordem alfabética por título, de AZ e depois por
data de publicação dentro de cada título, do mais recente ao mais antigo.

Outro atributo comum é verbose_nameum nome detalhado para a classe no

singular e no plural:
verbose_name = 'BetterName'

Outros atributos úteis permitem que você crie e aplique novas "permissões de
acesso" para o modelo (as permissões padrão são aplicadas automaticamente),
permita a ordenação com base em outro campo ou declare que a classe é
"abstrata" (uma classe base que você não pode criar registros para, e em vez
disso, serão derivados para criar outros modelos).

Muitas das outras opções de metadados controlam qual banco de dados deve
ser usado para o modelo e como os dados são armazenados (eles são
realmente úteis somente se você precisar mapear um modelo para um banco de
dados existente).

A lista completa de opções de metadados está disponível aqui: Model metadata

options(Django docs).

Métodos

Um modelo também pode ter métodos.

Minimamente, em cada modelo você deve definir o método de classe

Python padrão __str__()para retornar uma string legível para cada
objeto. Essa sequência é usada para representar registros individuais no site
de administração (e em qualquer outro lugar que você precise se referir a uma
instância de modelo). Muitas vezes isso retornará um campo de título ou nome
do modelo.
def __str__(self):
return self.field_name

Outro método comum a incluir nos modelos do Django é get_absolute_url(),

que retorna uma URL para exibir registros de modelos individuais no site (se
você definir esse método, o Django adicionará automaticamente um botão
"Visualizar no Site" às telas de edição de registro do modelo no site Admin
). Um padrão típico get_absolute_url()é mostrado abaixo.
def get_absolute_url(self):
"""Returns the url to access a particular instance of the model."""
return reverse('model-detail-view', args=[str(self.id)])

Nota : Supondo que você usará URLs como /myapplication/mymodelname/2para

exibir registros individuais para seu modelo (onde "2" é idpara um registro
específico), você precisará criar um mapeador de URL para passar a resposta e
id para uma "exibição de detalhes do modelo" ( que fará o trabalho necessário
para exibir o registro). A reverse()função acima é capaz de "inverter" o seu
mapeador de url (no caso acima chamado 'model-detail-view' ) para criar uma
URL do formato correto.
Claro que para fazer este trabalho você ainda tem que escrever o mapeamento
de URL, visão e modelo!
Você também pode definir quaisquer outros métodos que desejar e chamá-los
de seu código ou modelos (desde que eles não utilizem nenhum parâmetro).

Seção de gerenciamento de modelo

Depois de definir suas classes de modelo, você pode usá-las para criar,
atualizar ou excluir registros e executar consultas para obter todos os registros
ou subconjuntos específicos de registros. Mostraremos a você como fazer isso
no tutorial quando definirmos nossas visualizações, mas aqui está um breve
resumo.

Criando e modificando registros

Para criar um registro, você pode definir uma instância do modelo e, em

seguida, chamar save().
# Create a new record using the model's constructor.
record = MyModelName(my_field_name="Instance #1")

# Save the object into the database.

record.save()

Nota : Se você não declarou nenhum campo como um primary_key, o novo

registro receberá um automaticamente, com o nome do campo id. Você poderia
consultar este campo depois de salvar o registro acima e ele teria um valor de 1.
Você pode acessar os campos nesse novo registro usando a sintaxe de ponto e
alterar os valores. Você precisa chamar save()para armazenar valores
modificados no banco de dados.
# Access model field values using Python attributes.
print(record.id) # should return 1 for the first record.
print(record.my_field_name) # should print 'Instance #1'

# Change record by modifying the fields, then calling save().

record.my_field_name = "New Instance Name"
record.save()

Procurando por registros

Você pode procurar registros que correspondam a um determinado critério

usando o objectsatributo do modelo (fornecido pela classe base).
Nota : Explicar como procurar registros usando nomes de campos e modelos
"abstratos" pode ser um pouco confuso. Na discussão abaixo, vamos nos referir a
um Bookmodelo com titlee genrecampos, onde o gênero também é um modelo
com um único campo name.
Podemos obter todos os registros de um modelo como QuerySet,
usando objects.all(). O QuerySeté um objeto iterável, o que significa que
contém um número de objetos que podemos iterar / percorrer.
all_books = Book.objects.all()

O filter()método do Django nos permite filtrar o retornado QuerySetpara

corresponder a um campo de texto ou numérico especificado em relação a um
critério específico. Por exemplo, para filtrar por livros que contenham "wild" no
título e, em seguida, contá-los, poderíamos fazer o seguinte.
wild_books = Book.objects.filter(title__contains='wild')
number_wild_books = Book.objects.filter(title__contains='wild').count()

Os campos a serem correspondidos e o tipo de correspondência são definidos

no nome do parâmetro de filtro, usando o
formato: field_name__match_type(observe o sublinhado
duploentre titlee containsacima). Acima, estamos filtrando titlecom uma
correspondência de maiúsculas e minúsculas. Existem muitos outros tipos de
jogos que você pode fazer: icontains(maiúsculas e
minúsculas), iexact(correspondência exata de maiúsculas e
minúsculas), exact(jogo case-sensitive exato) e in, gt(maior que), startswithetc.
A lista completa está aqui .
Em alguns casos, você precisará filtrar um campo que defina um
relacionamento um-para-muitos com outro modelo (por exemplo,
a ForeignKey). Nesse caso, você pode "indexar" campos no modelo relacionado
com sublinhados duplos adicionais. Por exemplo, para filtrar livros com um
padrão de gênero específico, você terá que indexar nameno genrecampo, como
mostrado abaixo:
# Will match on: Fiction, Science fiction, non-fiction etc.
books_containing_genre = Book.objects.filter(genre__name__icontains='fiction')

Nota : Você pode usar sublinhados (__) para navegar quantos níveis de
relacionamentos ( ForeignKey/ ManyToManyField) desejar. Por exemplo, um Bookque
tenha tipos diferentes, definidos usando um relacionamento "cover" adicional,
pode ter um nome de parâmetro:type__cover__name__exact='hard'.
Há muito mais que você pode fazer com as consultas, incluindo pesquisas para
trás de modelos relacionados, encadeando filtros, retornando um conjunto
menor de valores, etc. Para obter mais informações, consulte Fazendo
consultas (Django Docs).
Definindo os modelos LocalLibrarySeção
Nesta seção, começaremos a definir os modelos para a
biblioteca. Abra models.py (em / locallibrary / catalog /) . O clichê na parte
superior da página importa o módulo de modelos , que contém a classe base do
modelo da models.Modelqual nossos modelos herdarão.
from django.db import models
# Create your models here.

Seção de modelo de gênero

Copie o Genrecódigo do modelo mostrado abaixo e cole-o na parte inferior do
seu models.pyarquivo. Este modelo é usado para armazenar informações sobre
a categoria do livro - por exemplo, se é ficção ou não-ficção, romance ou
história militar, etc. Como mencionado acima, criamos o Gênero como modelo e
não como texto livre ou como um lista de seleção para que os valores possíveis
possam ser gerenciados pelo banco de dados em vez de serem codificados.
class Genre(models.Model):
"""Model representing a book genre."""
name = models.CharField(max_length=200, help_text='Enter a book genre
(e.g. Science Fiction)')

def __str__(self):
"""String for representing the Model object."""
return self.name

O modelo tem um único CharFieldcampo ( name), que é usado para descrever o

gênero (este é limitado a 200 caracteres e tem alguns help_text. No final do
modelo, declaramos um __str__()método, que simplesmente retorna o nome do
gênero definido por um determinado Nenhum nome detalhado foi definido,
portanto o campo será chamado Nameem formulários.
Seção de modelo de livro
Copie o modelo Book abaixo e cole-o novamente na parte inferior do arquivo. O
modelo de livro representa todas as informações sobre um livro disponível em
um sentido geral, mas não uma "instância" ou "cópia" física específica
disponível para empréstimo. O modelo usa a CharFieldpara representar o
livro titlee isbn(note como o isbnespecifica seu rótulo como "ISBN" usando o
primeiro parâmetro sem nome porque o rótulo padrão seria "Isbn"). O modelo
usa TextFieldpara o summary, porque esse texto pode precisar ser bastante
longo.
from django.urls import reverse # Used to generate URLs by reversing the URL
patterns

class Book(models.Model):
"""Model representing a book (but not a specific copy of a book)."""
title = models.CharField(max_length=200)

# Foreign Key used because book can only have one author, but authors can
have multiple books
# Author as a string rather than object because it hasn't been declared
yet in the file
author = models.ForeignKey('Author', on_delete=models.SET_NULL, null=True)

summary = models.TextField(max_length=1000, help_text='Enter a brief

description of the book')
isbn = models.CharField('ISBN', max_length=13, help_text='13 Character <a
href="https://www.isbn-international.org/content/what-isbn">ISBN number</a>')

# ManyToManyField used because genre can contain many books. Books can
cover many genres.
 # Genre class has already been defined so we can specify the object above.
genre = models.ManyToManyField(Genre, help_text='Select a genre for this
book')

def __str__(self):
"""String for representing the Model object."""
return self.title

def get_absolute_url(self):
"""Returns the url to access a detail record for this book."""
return reverse('book-detail', args=[str(self.id)])

O gênero é um ManyToManyField, de modo que um livro pode ter vários gêneros e

um gênero pode ter muitos livros. O autor é declarado como ForeignKey,
portanto, cada livro terá apenas um autor, mas um autor pode ter muitos livros
(na prática, um livro pode ter vários autores, mas não nesta implementação!)
Nos dois tipos de campo, a classe de modelo relacionada é declarada como o
primeiro parâmetro sem nome usando a classe de modelo ou uma cadeia
contendo o nome do modelo relacionado. Você deve usar o nome do modelo
como uma string se a classe associada ainda não tiver sido definida neste
arquivo antes de ser referenciada! Os outros parâmetros de interesse
no authorcampo são null=True, o que permite que o banco de dados armazene
um Nullvalor se nenhum autor for selecionado e on_delete=models.SET_NULL, que
definirá o valor do autor para Nullse o registro do autor associado for excluído.
O modelo também define __str__(), usando o titlecampo do livro para
representar um Bookregistro. O método final, get_absolute_url()retorna uma URL
que pode ser usada para acessar um registro detalhado para este modelo (para
isso funcionar, teremos que definir um mapeamento de URL que tenha o
nome book-detaile definir uma visão e um modelo associados).
Seção do modelo BookInstance
Em seguida, copie o BookInstancemodelo (mostrado abaixo) sob os outros
modelos. A BookInstancerepresenta uma cópia específica de um livro que
alguém pode pedir emprestado e inclui informações sobre se a cópia está
disponível ou em que data ela é esperada, "impressão" ou detalhes da versão e
um ID exclusivo para o livro na biblioteca.
Alguns dos campos e métodos agora serão familiares. O modelo usa

 ForeignKeypara identificar o associado Book(cada livro pode ter muitas cópias, mas
uma cópia só pode ter uma Book).
 CharField para representar a impressão (lançamento específico) do livro.

import uuid # Required for unique book instances

class BookInstance(models.Model):
"""Model representing a specific copy of a book (i.e. that can be borrowed
from the library)."""
id = models.UUIDField(primary_key=True, default=uuid.uuid4,
help_text='Unique ID for this particular book across whole library')
book = models.ForeignKey('Book', on_delete=models.SET_NULL, null=True)
imprint = models.CharField(max_length=200)
due_back = models.DateField(null=True, blank=True)

LOAN_STATUS = (
 ('m', 'Maintenance'),
('o', 'On loan'),
('a', 'Available'),
('r', 'Reserved'),
)

status = models.CharField(
max_length=1,
choices=LOAN_STATUS,
blank=True,
default='m',
help_text='Book availability',
)

class Meta:
ordering = ['due_back']

def __str__(self):
"""String for representing the Model object."""
return f'{self.id} ({self.book.title})'

Além disso, declaramos alguns novos tipos de campo:

 UUIDFieldé usado para o idcampo para defini-lo como primary_keypara este

modelo. Esse tipo de campo aloca um valor único globalmente para cada instância (um
para cada livro que você pode encontrar na biblioteca).
 DateFieldé usado para a due_backdata (na qual espera-se que o livro esteja disponível
depois de ser emprestado ou em manutenção). Esse valor pode
ser blankou null(necessário para quando o livro estiver disponível). O metadata do
modelo ( Class Meta) usa esse campo para ordenar registros quando eles são
retornados em uma consulta.
 statusé um CharFieldque define uma lista de escolha / seleção. Como você pode ver,
nós definimos uma tupla contendo tuplas de pares de valores-chave e passamos para o
argumento de escolhas. O valor em um par de chave / valor é um valor de exibição que
um usuário pode selecionar, enquanto as chaves são os valores que são realmente
salvos se a opção for selecionada. Também definimos um valor padrão de 'm'
(manutenção), pois inicialmente os livros serão criados indisponíveis antes de serem
estocados nas prateleiras.
O modelo __str__()representa o BookInstanceobjeto usando uma combinação de
seu ID exclusivo e o Booktítulo associado .
Nota : Um pequeno Python:
 Começando com Python 3.6, você pode usar a sintaxe da cadeia de interpolação
(também conhecido como F-cordas): f'{self.id} ({self.book.title})'.
 Em versões mais antigas deste tutorial, estávamos usando uma sintaxe de string
formatada , que também é uma forma válida de formatação de strings no Python (por
exemplo '{0} ({1})'.format(self.id,self.book.title)).
Seção de modelo de autor
Copie o Authormodelo (mostrado abaixo) abaixo do código existente
em models.py .
Todos os campos / métodos agora devem estar familiarizados. O modelo define
um autor como tendo um nome, sobrenome, data de nascimento e (opcional)
data de morte. Especifica que, por padrão, __str__()retorna o nome
no sobrenome , a ordem do primeiro nome . O get_absolute_url()método inverte
 o author-detailmapeamento de URL para obter o URL para exibir um autor
individual.
class Author(models.Model):
"""Model representing an author."""
first_name = models.CharField(max_length=100)
last_name = models.CharField(max_length=100)
date_of_birth = models.DateField(null=True, blank=True)
date_of_death = models.DateField('Died', null=True, blank=True)

class Meta:
ordering = ['last_name', 'first_name']

def get_absolute_url(self):
"""Returns the url to access a particular author instance."""
return reverse('author-detail', args=[str(self.id)])

def __str__(self):
"""String for representing the Model object."""
return f'{self.last_name}, {self.first_name}'

Execute novamente as migrações do banco de

dadosSeção
Todos os seus modelos foram criados agora. Agora, execute novamente as
migrações de banco de dados para adicioná-las ao banco de dados.

python3 manage.py makemigrations

python3 manage.py migrate

Modelo de linguagem - desafioSeção

Imagine um benfeitor local doando uma série de novos livros escritos em outro
idioma (digamos, farsi). O desafio é descobrir como eles seriam melhor
representados no site da nossa biblioteca e adicioná-los aos modelos.

Algumas coisas a considerar:

 Deve "linguagem" ser associado a um Book, BookInstanceou algum outro objeto?

 As diferentes linguagens devem ser representadas usando o modelo, um campo de
texto livre ou uma lista de seleção codificada?
Depois de decidir, adicione o campo. Você pode ver o que decidimos no
Github aqui .
Não se esqueça de que, após uma alteração em seu modelo, você deve
executar novamente as migrações do banco de dados para adicionar as
alterações.

python3 manage.py makemigrations

python3 manage.py migrate
ResumoSeção
Neste artigo, aprendemos como os modelos são definidos e usamos essas
informações para projetar e implementar modelos apropriados para
o site da LocalLibrary .
Neste ponto, desviaremos brevemente da criação do site e confira o site de
administração do Django . Este site nos permitirá adicionar alguns dados à
biblioteca, os quais podemos exibir usando nossas exibições e modelos (ainda
a serem criados).