Django 2 por Exemplo

Construir poderosas e confiáveis ​aplicativos Python web a partir do zero

Antonio Melé
BIRMINGHAM - MUMBAI
Django 2 por Exemplo
Copyright © 2018 Packt Publishing

Todos os direitos reservados. Nenhuma parte deste livro pode ser reproduzida, armazenada em um sistema de recuperação ou transmitida de qualquer
forma ou por qualquer meio, sem a prévia autorização por escrito do editor, exceto no caso de citações breves incorporados em artigos ou críticas.

Todos os esforços foram feitos na preparação deste livro para garantir a precisão das informações apresentadas. No entanto, a informação contida
neste livro é vendido sem garantia, expressa ou implícita. Nem o autor, nem Packt Publishing ou seus revendedores e distribuidores, será
responsabilizado por quaisquer danos causados ​ou alegadamente causados ​direta ou indiretamente por este livro.

Packt Publishing tem se esforçado para fornecer informações marca sobre todas as empresas e produtos mencionados neste livro através da
utilização adequada de capitais. No entanto, Packt Publishing não pode garantir a precisão das informações.

Editor de conteúdo de desenvolvimento: Arun Nadar

Editor Técnico: Prajakta Mhatre
Editor de cópia: Dhanya Baburaj e SAFIs Edição
Coordenador de projeto: Sheejal Shah
revisor: SAFIs edição
indexador: Rekha Nair
Coordenador de produção: Nilesh Mohite

Publicado pela primeira vez: maio 2018

de referência de produção: 1250518

Publicado por Packt Publishing Ltd. Livery Lugar

35 Livery Rua Birmingham B3 2PB, Reino Unido.

ISBN 978-1-78847-248-7

www.packtpub.com
Para minha irmã
mapt.io

MAPT é uma biblioteca digital on-line que lhe dá acesso total ao longo
5.000 livros e vídeos, bem como principais ferramentas da indústria para ajudar a planejar o seu
desenvolvimento pessoal e avançar em sua carreira. Para mais informações, por favor visite
nosso website.
Por que se inscrever?

Gastar menos tempo aprendendo e mais tempo de codificação com eBooks e

vídeos práticos de mais de 4,000 profissionais da indústria

Melhorar a sua aprendizagem com Planos de Habilidade construído especialmente para você

Obter um eBook livre ou vídeo a cada mês

MAPT é totalmente pesquisável

Copiar e colar, imprimir e conteúdo favorito

PacktPub.com
Você sabia que Packt ofertas eBook versões de cada livro publicado, com arquivos PDF
e ePub disponíveis? Você pode atualizar para a versão eBook em www.PacktPub.com e como um
cliente livro impresso, você tem direito a um desconto na cópia eBook. Entrar em contato
com a gente no service@packtpub.com para mais detalhes.

em www.PacktPub.com , você também pode ler uma coleção de artigos técnicos gratuitos, inscrever-se para
uma série de boletins de notícias livres, e receber descontos e ofertas exclusivas em livros e
eBooks Packt.
contribuintes
Sobre o autor
Antonio Melé é o Investir CTO da Exo e fundador da Zenx TI. Antonio tem vindo a
desenvolver projectos Django desde 2006 para clientes em várias indústrias. Ele tem
trabalhado como o CTO e como um consultor de tecnologia para várias startups de base
tecnológica, e ele conseguiu equipes de desenvolvimento a construção de projetos para
grandes empresas digitais. Antonio possui mestrado em Ciência da Computação pela
Universidad Pontificia Comillas. Seu pai inspirou sua paixão por computadores e
programação.
O que este livro cobre
Capítulo 1 , Construindo um aplicativo de blog, apresenta o quadro através da criação de um
aplicativo de blog. Você vai criar as básicos modelos de blog, visões, modelos e URLs
para exibir mensagens de blog. Você vai aprender a construir QuerySets com o Django
ORM, e você vai configurar site de administração do Django.

Capítulo 2 , Aprimorando seu Blog com recursos avançados, ensina como lidar com formas e modelos
de formulários, e-mails enviar com Django, e integrar aplicativos de terceiros. Você vai
implementar um sistema de comentários para o seu blog e permitir que seus usuários para
mensagens compartilhar via e-mail. O capítulo também orienta durante o processo de criação
de um sistema de marcação.

Capítulo 3 , Estendendo o aplicativo de blog, explora como criar tags e filtros modelo personalizado. O
capítulo também mostra como usar a estrutura de mapa do site e criar um feed RSS para suas
mensagens. Você vai completar o seu aplicativo de blog através da construção de um motor de
busca com recursos de pesquisa de texto completo do PostgreSQL.

Capítulo 4 , Construindo um Web site social, explica como construir um site social. Você vai usar a
estrutura de autenticação Django para criar visualizações de conta de usuário. Você vai
aprender como criar um modelo de perfil de usuário personalizada e construir autenticação
social no seu projeto usando grandes redes sociais.

Compartilhamento de conteúdo em seu site, ensina como transformar sua

capítulo 5 ,

aplicação social em um site de bookmarking imagem. Você vai definir

muitos-para-muitos relacionamentos para modelos, e você vai criar um bookmarklet
AJAX em JavaScript e integrá-lo em seu projeto. O capítulo mostra como gerar
miniaturas de imagens e criar decoradores personalizados para o seu
Visualizações.

Capítulo 6 , Rastreamento ações do usuário, mostra-lhe como construir um sistema seguidor para os
usuários. Você vai completar sua imagem site de bookmarking, criando um aplicativo de fluxo de
atividade do usuário. Você vai aprender como otimizar QuerySets, e você vai trabalhar com sinais.
Você vai integrar Redis em seu projeto para contar visualizações de imagem.

Capítulo 7 , Construir uma loja on-line, explora como criar uma loja online. Você vai construir modelos
de catálogo, e você vai criar um carrinho de compras usando sessões Django. Você vai
construir um processador de contexto para o carrinho de compras, e você vai aprender como
implementar o envio de notificações assíncronas aos usuários usando aipo.

Capítulo 8 , Gerenciar pagamentos e ordens, explica como integrar um gateway de pagamento em

sua loja. Você também vai personalizar o site de administração para encomendas de
exportação para arquivos CSV, e você vai gerar faturas PDF dinamicamente.

Capítulo 9 , Estendendo sua loja, ensina como criar um sistema de cupom para aplicar descontos
para encomendas. Os shows capítulo como adicionar internacionalização ao seu projeto e
como traduzir modelos. Você também vai construir um mecanismo de recomendação
produto usando Redis.

Capítulo 10 , Construir uma plataforma de e-Learning, orienta na criação de uma plataforma de

e-learning. Você irá adicionar acessórios ao seu projeto, use herança modelo, criar campos
personalizados do modelo, uso visualizações baseadas em classe, e gerenciar grupos e
permissões. Você vai criar um sistema de gerenciamento de conteúdo e formsets punho.

Capítulo 11 , Renderização e cache de conteúdo, mostra-lhe como criar um sistema de registo dos
alunos e gerenciar o ingresso dos alunos em cursos. Você irá processar o conteúdo do
curso diverso e você vai aprender como usar o framework de cache.

Capítulo 12 , A construção de uma API, explora a construção de uma API RESTful para o seu
projeto usando o framework Django REST.

Capítulo 13 , Indo ao vivo, mostra como configurar um ambiente de produção usando uWSGI e
NGINX, e como protegê-lo com SSL. O capítulo explica como construir um middleware
personalizado e criar comandos de gerenciamento personalizados.
Sobre os revisores
Norbert Máté é um desenvolvedor web. Ele começou sua carreira em volta
2008. A sua primeira linguagem de programação como um desenvolvedor web profissional
foi PHP, em seguida, ele se mudou para JavaScript / Node.js e quadro Python / Django /
Django REST. Ele é apaixonado por arquitetura de software, padrões de projeto, e um
código limpo. Norbert foi o revisor de outro livro Django Django RESTful Web Services por
Packt Publishing.

Eu gostaria de agradecer a minha esposa para seu apoio.

Packt está à procura de autores como você

Se você está interessado em se tornar um autor para Packt, visite auth ors.packtpub.com e aplicar hoje.
Temos trabalhado com milhares de desenvolvedores e profissionais de tecnologia, assim como
você, para ajudá-los a compartilhar sua visão com a comunidade global de tecnologia. Você
pode fazer uma aplicação geral, aplicar-se para um tema quente específico que estamos a
recrutar um autor para, ou enviar sua própria idéia.
Índice
Folha de rosto

Direitos de autor e Créditos

Django 2 por Exemplo

Dedicação Packt

Upsell

Por que se inscrever?

PacktPub.com

contribuintes

Sobre o autor

Sobre os revisores

Packt está à procura de autores como você

Prefácio

Que este livro é para

O que este livro aborda Para tirar o máximo proveito deste

livro

Faça o download dos arquivos de código de exemplo

Convenções usadas
 Entrar em contato

Rever

1. Construindo um aplicativo Blog

Instalando o Django

Criar um ambiente Python isolado

Instalando o Django com pip

Criando seu primeiro projeto

Executando o servidor de desenvolvimento

configurações do projeto

Projetos e aplicações

Criando uma aplicação

Projetando o esquema de dados do blog

Ativando o aplicativo

Criação e aplicação de migrações

Criando um site de administração para os seus modelos

Criando um superusuário

O site de administração do Django

Adicionando seus modelos para o site de administração

Personalizar a forma como os modelos são exibidos

 Trabalhando com QuerySet e gestores

criação de objetos

Atualizando objetos Recebendo

objetos

Utilizando o filtro () Método

Usando excluir ()

Usando order_by ()

Excluindo objetos

Quando QuerySets são avaliados

Criando gerentes modelo

O edifício da lista e detalhe visualizações

Criação de lista e detalhe visualizações

Adicionando padrões de URL para os seus pontos de vista

URLs canônicas para modelos

A criação de modelos para os seus pontos de vista

adicionando a paginação

Usando visualizações baseadas em classe

resumo

2. Aprimorando seu Blog com funcionalidades avançadas

Compartilhando mensagens de e-mail

Criando formas com Django

 Manipulação de formas nas vistas

Enviar e-mails com Django

Renderizando formulários em modelos

Criando um sistema de comentário

Criando formas de modelos

Manipulação ModelForms em vista

Adicionando comentários para o modelo pós detalhe

Ao aumentar a funcionalidade marcação

Recuperando mensagens de similaridade

resumo

3. Estendendo o aplicativo de blog

Criação de tags e filtros de template personalizados

Criação de tags de modelos personalizados

Criação de filtros de templates personalizados

Adicionando um mapa do site para o seu site

Criação de feeds para o seu blog Adição de pesquisa de texto

completo para o seu blog

Instalando o PostgreSQL

pesquisas de pesquisa simples

Pesquisando contra vários campos

Construir uma visão de pesquisa

 Verificação e hierarquizando os resultados

consultas de ponderação

Pesquisando com o semelhança trigrama

Outros motores de busca de texto completo

resumo

4. Construindo um Web site social

Criando um projeto de website sociais

Iniciando seu projeto de site social,

Usando a estrutura de autenticação Django

Criando uma visão de login

Usando visualizações de autenticação do Django

visualizações de login e logout

Alterar as vistas de senha

Repor vistas senha

registro do usuário e perfis de usuário

O registro do usuário Estendendo o modelo

de usuário

Usando um modelo de usuário personalizada

Usando a estrutura de mensagens

 Construir uma autenticação personalizada backend Adicionando

autenticação sociais ao seu site

Autenticação usando Facebook

Autenticação usando o Twitter

Autenticação usando Google

resumo

5. Compartilhamento de conteúdo em seu site

Criando um site imagem bookmarking

Construção do modelo de imagem

A criação de muitos-para-muitos relacionamentos

Registrar o modelo de imagem no local de administração

Publicação de conteúdo de outros sites

Limpeza campos do formulário

Substituindo o método save () de um ModelForm

Construindo um bookmarklet com jQuery

Criando uma vista de detalhe para imagens

Criação de miniaturas de imagens usando SORL-thumbnail Adicionando ações

AJAX com jQuery

Carregando jQuery

Cross-Site Request Forgery em solicitações de AJAX

Performing solicitações de AJAX com jQuery

 Criando decoradores personalizados para seus pontos de vista

Acrescentando AJAX pagination às suas exibições de lista

resumo

6. Rastreamento de Ações do Usuário

Construção de um sistema seguidor

A criação de muitos-para-muitos relacionamentos com um intermediário

modelo

Criação de exibições de lista e detalhe para perfis de usuário

Construir uma vista AJAX a seguir usuários

Construindo um aplicativo fio de actividade genérica

Usando a estrutura contenttypes

Adicionando relações genéricas para seus modelos

Evitando ações duplicadas no fluxo de atividade

Adicionando ações do usuário para o fluxo de atividade

Exibindo o fio de actividade

Otimizando QuerySets que envolvem objetos relacionados

Usando select_related ()

Usando prefetch_related ()

Criando modelos para acções

Usando sinais para desnormalizar contagem

Trabalhando com sinais

 aulas de configuração do aplicativo

Usando Redis para armazenar telas de itens

Instalando Redis

Usando Redis com Python

Armazenamento de telas de itens em Redis

Armazenando um ranking no Redis

Próximos passos com Redis

resumo

7. Construir uma Loja Online

Criando um projeto de loja online

Criando modelos do catálogo de produtos

Registrar modelos do catálogo no site de administração

Construção de visualizações de catálogo

Criando modelos de catálogo

Construção de um carrinho de compras

Usando sessões do Django

configurações da sessão

expiração de sessão

Armazenar carrinhos de compras em sessões Criando vistas

carrinho de compras

Adicionando itens ao carrinho

 Construir um modelo para exibir o carrinho

A adição de produtos ao carrinho

Atualizando quantidades do produto no carrinho

Criando um processador de contexto para o carro atual

processadores de contexto

Definir o carrinho para o contexto de solicitação

Registrar os pedidos dos clientes

Criando modelos de ordem

Incluindo modelos de ordem no local de administração

Criação de pedidos de clientes

O lançamento de tarefas assíncronas com aipo

Instalando Aipo

Instalando RabbitMQ

Adicionando aipo ao seu projeto

Adicionando tarefas assíncronas para a sua aplicação

Aipo monitoramento

resumo

8. Gerenciar pagamentos e ordens

Integrando um gateway de pagamento

 Criando uma conta de sandbox Braintree

Instalar o módulo de Braintree Python Integrando o gateway de

pagamento

Integrando Braintree usando Hospedado Campos

pagamentos de teste

indo ao vivo

Exportação ordens de arquivos CSV

Adicionando ações personalizadas para o site de administração

Estendendo o site de administração com o costume vê Gerando faturas PDF

dinamicamente

Instalando WeasyPrint

Criando um modelo de PDF

Renderização de arquivos PDF

O envio de arquivos PDF por e-mail

resumo

9. Estendendo sua loja

Criando um sistema de cupons

A construção dos modelos de cupom

Aplicando um cupom para o carrinho de compras

 Aplicando cupons para ordens

Adicionando internacionalização e localização

Internacionalização com Django

configurações de internacionalização e localização

comandos de gestão de internacionalização

Como adicionar traduções para um projeto de Django

Como Django determina o idioma atual

Preparando o nosso projeto de internacionalização código Traduzindo Python

traduções padrão

traduções preguiçosos

Traduções incluindo variáveis

formas plurais em traduções

Traduzindo seu próprio código

traduzindo modelos

O {% trans%} tag

O {% blocktrans%} tag

Traduzindo os modelos de loja

Usando a interface de tradução Rosetta

traduções distorcido

padrões de URL para a internacionalização

 Adicionando um prefixo linguagem para padrões de URL

Traduzindo padrões de URL

Permitindo que os usuários modelos tradução da linguagem switch

com django-parler

Instalando django-parler

Traduzindo campos do modelo

Integrando traduções na administração

local

Criando migrações para traduções modelo

Adaptação vistas para traduções

localização Format

Usando django-localflavor para campos de formulário Validar

Construir um mecanismo de recomendação

Recomendando produtos com base em compras anteriores

resumo

10. Construir uma plataforma de e-Learning

Configurando o projeto de e-learning a construção dos

modelos de curso

Registrar os modelos no local de administração

Usando luminárias para fornecer & # xA0, os dados iniciais para modelos
Criando modelos de conteúdo diversificado

Usando herança modelo

modelos abstratos

herança modelo multi-table

modelos de proxy

Criando os modelos de conteúdo

Criação de campos personalizados de modelo

Adicionando ordenação de módulos de conteúdo e objetos

Criação de um CMS

Adicionando um sistema de autenticação

Criação de modelos de autenticação

Criando visões baseadas em classe

Usando mixins para vistas baseadas em classes que trabalham

com grupos e permissões

Restringir o acesso a pontos de vista baseados em classe

Gerenciando módulos do curso e conteúdo

Usando formsets para módulos do curso

Adição de conteúdo a módulos do curso

Gerenciando módulos e conteúdos Reordenação

módulos e conteúdos

Usando mixins de django-cintas

 resumo

11. Renderização e cache de conteúdo

Exibindo cursos Adição de inscrição de estudante

Criando uma visão de inscrição de estudante

Se matricular em cursos

Acessando o conteúdo do curso

Renderização de diferentes tipos de conteúdo

Usando a estrutura de cache

backends de cache disponíveis

Instalando o Memcached

Configurações de cache

Adicionando Memcached ao seu projeto

monitoramento Memcached

níveis de cache

Usando o baixo nível de cache API

Cache baseado em dados dinâmicos

O cache de fragmentos caching vistas

 Usando o cache por site

resumo

12. A construção de uma API

A construção de uma API RESTful

Instalando o framework Django RESTO

definindo serializers

analisadores compreensão e prestadores

O edifício da lista e detalhe visualizações

Criando serializers aninhados

Construção de vistas personalizadas

autenticação de manipulação

Adicionando permissões para vistas

Criando vista conjuntos e roteadores

Adicionando ações adicionais para visualizar conjuntos

Criação de permissões personalizadas

Serialização de conteúdos do curso

resumo

13. indo ao vivo

Criando um ambiente de produção

Gerenciando configurações para diversos ambientes

usando PostgreSQL
 Verificando seu projeto

Servindo Django através WSGI

Instalando uWSGI

Configurando uWSGI

Instalando NGINX

O ambiente de produção

Configurando NGINX

Servindo ativos estáticos e mídia Protegendo conexões

com SSL

Criando um certificado SSL

Configurando NGINX para usar SSL

Configurando o nosso projeto para SSL

Criando um middleware personalizado

Criando um middleware subdomínio

Servindo vários subdomínios com NGINX

Implementar comandos de gerenciamento personalizado

resumo

Outros Livros você pode apreciar

Deixe um comentário - deixar outros leitores saibam o que você pensa

Prefácio
Django é um poderoso framework web Python que incentiva o desenvolvimento rápido e, design
limpo pragmática, oferecendo uma curva de aprendizagem relativamente rasas. Isto torna mais
atraente para ambos os novatos e programadores especializados.

Este livro irá guiá-lo através de todo o processo de desenvolvimento de aplicações

web profissionais com Django. O livro abrange não só os aspectos mais relevantes do
quadro, mas também ensina como integrar outras tecnologias populares em seus
projetos Django.

O livro irá orientá-lo através da criação de aplicações do mundo real, resolução de

problemas comuns e implementar as melhores práticas com uma abordagem
passo-a-passo que é fácil de seguir.

Depois de ler este livro, você vai ter uma boa compreensão de como Django funciona
e como construir, aplicações web práticas avançadas.
Que este livro é para
Este livro é destinado a desenvolvedores com conhecimento Python que desejam aprender
Django de forma pragmática. Talvez você é completamente novo para Django, ou você já
sabe um pouco, mas você deseja obter o máximo proveito dela. Este livro vai ajudar você a
dominar áreas mais relevantes do quadro através da construção de projetos práticos a partir
do zero. Você precisa ter familiaridade com conceitos de programação, a fim de ler este livro.
Algum conhecimento prévio de HTML e JavaScript é assumido.
Para tirar o máximo proveito deste livro

Para tirar o máximo proveito deste livro, é recomendável que você tem bom
conhecimento de Python. Você também deve estar confortável com HTML e
JavaScript. Antes de ler este livro, é recomendável que você leu partes 1 a 3 da
documentação tutorial oficial do Django no https://docs.djangoproject.com/en/2.0/intro/tutorial01/ .
Faça o download dos arquivos de código de
exemplo
Você pode baixar os arquivos de código de exemplo para este livro de sua conta em www.packtpub.com
. Se você comprou este outro lugar do livro, você pode visitar www.packtpub.com/support e se registrar para
ter os arquivos por e-mail diretamente para você.

Você pode baixar os arquivos de código, seguindo estes passos:

1. Ligar ou registo no www.packtpub.com .

2. Selecione a guia Suporte.
3. Clique no Código Downloads e Errata.

4. Digite o nome do livro na caixa de pesquisa e siga as instruções na tela.

Uma vez que o arquivo é baixado, certifique-se de que você descompactar ou extrair a pasta
usando a versão mais recente de:

WinRAR / 7-Zip para Windows

Zipeg / izip / UnRarX para Mac

7-Zip / PeaZip para Linux

O pacote de código para o livro também está hospedado no GitHub em https: // Githu
b.com/PacktPublishing/Django-2-by-Example . No caso de haver uma atualização para o código, ele será
atualizado no repositório GitHub existente.
Temos também outros pacotes de código a partir do nosso rico catálogo de livros e
vídeos disponíveis no https://github.com/PacktPublishing/ . Vê-los!
Convenções usadas
Há uma série de convenções de texto utilizados ao longo deste livro.

CodeInText: Indica palavras de código em texto, nomes de tabelas de banco de dados, nomes de pastas,
nomes de arquivos, extensões de arquivos, caminhos, URLs manequim, a entrada do usuário, e alças
Twitter. Aqui está um exemplo: "Você pode desativar seu ambiente a qualquer momento com o desativar comando."

Um bloco de código é definido como se segue:

de django.contrib administrador de importação de .models

importar Publicar

admin.site.register (Post)

Quando queremos chamar a atenção para uma determinada parte de um bloco de código, as linhas ou
itens relevantes são definidos em negrito:

INSTALLED_APPS = [

'Django.contrib.admin', 'django.contrib.auth',

'django.contrib.contenttypes', 'django.contrib.sessions',

'django.contrib.messages', 'django.contrib.staticfiles',

'Blog.apps.BlogConfig',

Qualquer entrada de linha de comando ou de saída é escrito da seguinte forma:

$ Python blogue manage.py startapp

Negrito: Indica um novo termo, uma importante palavra ou palavras que você
vê na tela. Por exemplo, palavras menus ou caixas de diálogo aparecem no texto como
este. Aqui está um exemplo: "Preencha o formulário e clique no botão Salvar".

Avisos ou notas importantes aparecer assim.

Dicas e truques aparecer assim.

Entrar em contato
O feedback dos nossos leitores é sempre bem-vindo.

Comentários gerais: O email feedback@packtpub.com e mencionar o título do livro no assunto da

mensagem. Se você tiver dúvidas sobre qualquer aspecto deste livro, envie um email
para questions@packtpub.com.

errata: Embora tenhamos tomado todos os cuidados para garantir a precisão de nosso
conteúdo, erros acontecem. Se você encontrou um erro neste livro, ficaríamos muito gratos
se você iria relatar isso para nós. Por favor visite www.packtpub.com/submit-errata , seleção de seu livro,
clicando no link Errata Formulário de Apresentação, e inserindo os detalhes.

Pirataria: Se você se deparar com quaisquer cópias ilegais de nossos trabalhos em qualquer formulário
na Internet, ficaríamos muito gratos se você poderia nos fornecer o endereço de localização ou nome
do site. Entre em contato conosco
copyright@packtpub.com com um link para o material.

Se você estiver interessado em se tornar um autor: Se há um tema que você

tem experiência em e está interessado em qualquer escrito ou contribuindo para
um livro, por favor visita authors.packtpub.com .
Rever
Por favor, deixe um comentário. Depois de ter lido e utilizado este livro, por que não deixar um
comentário sobre o site que você comprou de? potenciais leitores podem então ver e usar a
sua opinião imparcial para tomar decisões de compra, nós da Packt pode entender o que você
pensa sobre nossos produtos e nossos autores podem ver o seu feedback sobre o seu livro.
Obrigado!

Para mais informações sobre Packt, visite packtpub.com .

Construindo um aplicativo Blog
Neste livro, você vai aprender a construir projetos completos Django, pronto para uso em
produção. No caso de você não tiver instalado Django ainda, você vai aprender como fazê-lo
na primeira parte deste capítulo. Este capítulo aborda como criar um aplicativo simples blog
usando Django. O propósito deste capítulo é para ter uma idéia geral de como funciona a
estrutura, entender como os diferentes componentes interagem uns com os outros, e
fornecê-lo com as habilidades para criar facilmente projetos Django com uma funcionalidade
básica. Você será guiado através da criação de um projeto completo sem entrar em detalhes
sobre todos os detalhes. Os componentes estruturais diferentes serão abordados em detalhes
ao longo deste livro.

Este capítulo irá cobrir os seguintes tópicos:

Instalando o Django e criar seu primeiro projeto

Projetando modelos e gerar migrações modelo

Criando um site de administração para os seus modelos

Trabalhando com QuerySet e gestores

Edifício Vistas, modelos e URLs

Adicionando a paginação para exibições de lista

Usando pontos de vista com base na classe do Django

Instalando o Django
Se você já instalou o Django, você pode pular esta seção e saltar directamente para o Criando
seu primeiro projeto seção. Django vem como um pacote Python e, portanto, pode ser
instalado em qualquer ambiente Python. Se você ainda não instalou o Django ainda, o
seguinte é um guia rápido para instalar Django para o desenvolvimento local.

Django 2.0 requer Python versão 3.4 ou superior. Nos exemplos para este livro, vamos usar
Python 3.6.5. Se você estiver usando Linux ou MacOS X, você provavelmente tem o Python
instalado. Se você estiver usando o Windows, você pode baixar um instalador Python em https://www.python.org
/ downloads / windows / .

Se você não tiver certeza se Python está instalado no seu computador, você pode
verificar-lo digitando Pitão no shell. Se você ver algo como o seguinte, em seguida, Python
está instalado no seu computador:

Python 3.6.5 (v3.6.5: f59c0932b4, 28 de março, 2018, 03:03:55) [GCC 4.2.1 (Apple Inc. construir 5666) (ponto 3)] no

darwin Type "help", "copyright", " créditos" ou 'licença' para mais informações.

>>>

Se a sua versão Python instalada é menor do que 3,4, ou se Python não está instalado
no seu computador, baixe Python 3.6.5 do https: //www.p ython.org/downloads/ e instalá-lo .

Desde que você vai usar Python 3, você não tem que instalar um banco de dados. Esta versão
Python vem com um banco de dados embutido SQLite. SQLite é um banco de dados leve que
você pode usar com Django para o desenvolvimento. Se você planeja implantar seu aplicativo em
um ambiente de produção, você deve usar uma base de dados avançada, como PostgreSQL,
MySQL, ou Oracle. Você pode obter mais informações
sobre como obter o seu banco de dados rodando com Django na https://docs.djangoproject.com/en/2.0/topics/install/#database-installat
.
Criar um ambiente Python isolado

Recomenda-se que você usa virtualenv para criar ambientes Python isolados, de modo que você
pode usar diferentes versões de pacotes para diferentes projetos, o que é muito mais
prático do que instalar pacotes Python em todo o sistema. Outra vantagem da utilização virtualenv
é que você não vai precisar de privilégios de administração para instalar pacotes Python.
Execute o seguinte comando no seu shell para instalar

virtualenv:

pip instalar virtualenv

Depois de instalar virtualenv, criar um ambiente isolado com o seguinte comando:

virtualenv my_env

Isto irá criar uma my_env / diretório, incluindo seu ambiente Python. Quaisquer
bibliotecas Python de instalar, enquanto o seu ambiente virtual está ativo entrará no my_env
/ lib / python3.6 / site-packages

diretório.

Se o seu sistema vem com Python 2.X e tiver instalado o Python 3.x, você tem que dizer virtualenv usar
o último.

Você pode localizar o caminho onde Python 3 é instalado e usá-lo para criar o
ambiente virtual com os seguintes comandos:

zenx $ que python3

/Library/Frameworks/Python.framework/Versions/3.6/bin/python3 zenx $ virtualenv my_env -p

 /Library/Frameworks/Python.framework/Versions/3.6/bin/python3

Execute o seguinte comando para ativar o seu ambiente virtual:

my_env fonte / bin / activate

O prompt shell irá incluir o nome do ambiente virtual ativa entre parênteses,
como se segue:

(My_env) laptop: ~ zenx $

Você pode desativar o seu ambiente a qualquer momento com o desativar

comando.

Você pode encontrar mais informações sobre virtualenv em

https://virtualenv.pypa.io/en/latest/ .

Em cima de virtualenv, você pode usar virtualenvwrapper. Esta ferramenta fornece wrappers que
tornam mais fácil para criar e gerenciar seus ambientes virtuais. Você pode baixá-lo https:
//virtualenvwrapper.readth edocs.io/en/latest/ .
Instalando o Django com pip
o pip sistema de gerenciamento de pacotes é o método preferido para a instalação do
Django. Python 3.6 vem com pip pré-instalado, mas você pode encontrar pip instruções de
instalação em
https://pip.pypa.io/en/stable/installing/ .

Execute o seguinte comando na janela de comandos para instalar Django com pip:

pip instalar Django == 2.0.5

Django será instalado no Python site-packages / diretório do seu ambiente virtual.

Agora, verifique se Django foi instalado com sucesso. Corre

Pitão em um terminal, importação Django, e verificar a sua versão, como segue:

>>> django import

>>> django.get_version () '2.0.5'

Se você obter o resultado anterior, Django foi instalado com sucesso em sua
máquina.

Django pode ser instalado em várias outras maneiras. Você pode encontrar um guia de
instalação completa no https://docs.djangoproject.com/en/2.0/topics/install/ .
Criando seu primeiro projeto
Nosso primeiro projeto Django será a construção de um blog completo. Django fornece um
comando que permite que você crie uma estrutura de arquivo de projeto inicial. Execute o seguinte
comando a partir de seu shell:

django-admin startproject mysite

Isto irá criar um projeto Django com o nome meu site.

Evite dar nomes a projetos built-in módulos Python ou Django, a fim de conflitos a evitar.

Vamos dar uma olhada na estrutura do projeto gerado:

meu site/

manage.py

meusite /

__init__.py

settings.py urls.py

wsgi.py

Esses arquivos são os seguintes:

manage.py: Este é um utilitário de linha de comando usado para interagir com o seu

projeto. É um wrapper fino ao redor do django-admin.py

ferramenta. Você não precisa para editar este arquivo.

meu site/: Este é o diretório do projeto, que consiste nos seguintes arquivos:

__init__.py: Um arquivo vazio que diz ao Python para tratar a

 meu site diretório como um módulo Python.

settings.py: Isso indica configurações e configuração para o seu projeto

e contém as definições iniciais.

urls.py: Este é o lugar onde seus padrões de URL viver. Cada URL

definido aqui é mapeado para uma vista.

wsgi.py: Esta é a configuração para executar o seu projeto como um Web

Server Gateway Interface (WSGI) aplicação.

o gerado settings.py arquivo contém as configurações do projeto, incluindo uma configuração

básica de usar um banco de dados SQLite 3 e uma lista com o nome INSTALLED_APPS, que contém
aplicações comuns Django que são adicionados ao seu projeto por padrão. Vamos passar
por essas aplicações no final do configurações do projeto seção.

Para completar a configuração do projeto, vamos precisar para criar as tabelas no banco
de dados exigida pelos aplicativos listados em INSTALLED_APPS. Abra o shell e execute os
seguintes comandos:

cd mysite

python manage.py migrar

Você vai notar uma saída que termina com as seguintes linhas:

Aplicando contenttypes.0001_initial ... OK aplicando

auth.0001_initial ... OK aplicando admin.0001_initial ... OK

Aplicando admin.0002_logentry_remove_auto_add ... OK aplicando

contenttypes.0002_remove_content_type_name ... OK aplicando

auth.0002_alter_permission_name_max_length ... OK aplicando

auth.0003_alter_user_email_max_length ... OK aplicando auth.0004_alter_user_username_opts ... OK

aplicando auth.0005_alter_user_last_login_null ... OK aplicação auth

.0006_require_contenttypes_0002 ... Aplicando auth.0007_alter_validators_add_error_messages OK ...

OK
 Aplicando auth.0008_alter_user_username_max_length ... OK aplicando

auth.0009_alter_user_last_name_max_length ... OK aplicando sessions.0001_initial ... OK

As linhas anteriores são as migrações de banco de dados que são aplicadas pelo Django. Ao
aplicar as migrações, as mesas para os pedidos iniciais são criados no banco de dados. Você
vai aprender sobre a
migrar comando de gestão no Criação e aplicação de migrações seção deste
capítulo.
Executando o servidor de desenvolvimento

Django vem com um servidor web leve para executar seu código rapidamente, sem a necessidade
de gastar tempo configurando um servidor de produção. Quando você executa o servidor de
desenvolvimento Django, ele mantém a verificação de alterações em seu código. Ele recarrega
automaticamente, libertando-o de recarregá-lo manualmente após alterações no código. No entanto,
ele pode não notar algumas ações, como adicionar novos arquivos ao seu projeto, assim você terá
que reiniciar o servidor manualmente nesses casos.

Inicie o servidor de desenvolvimento, digitando o seguinte comando a partir da pasta

raiz do seu projeto:

python manage.py runserver

Você deve ver algo como isto:

Realizando verificações de sistemas ...

verificação do sistema identificou nenhum problema (0 silenciada). 06 de maio de

2018 - 17:17:31

Django versão 2.0.5, usando as configurações 'mysite.settings' Iniciando servidor de

desenvolvimento em http://127.0.0.1:8000/ Saia do servidor com CONTROL-C.

Agora, aberta http://127.0.0.1:8000/ no seu browser. Você deverá ver uma página informando que o
projeto está sendo executado com sucesso, como mostrado na imagem seguinte:
A tela acima, indica que o Django está em execução. Se você der uma olhada no
seu console, você verá o OBTER solicitar realizada por seu navegador:

[06 / Maio / 2018 17:20:30] "GET / HTTP / 1.1" 200 16348

Cada solicitação HTTP é registrada no console do servidor de desenvolvimento. Qualquer erro que
ocorre durante a execução do servidor de desenvolvimento também será exibido no console.

Você pode indicar Django para executar o servidor de desenvolvimento em um host personalizado e porto ou

dizer-lhe para executar o projeto, carregar um arquivo de configurações diferentes, como segue:

python manage.py runserver 127.0.0.1:8001 \

- - settings = mysite.settings

Quando você tem que lidar com vários ambientes que requerem diferentes configurações, você pode criar
um arquivo de configurações diferentes para cada ambiente.

Lembre-se que este servidor destina-se apenas para o desenvolvimento e não é adequado
para uso em produção. A fim de colocar o Django em um ambiente de produção, você deve
executá-lo como uma aplicação WSGI usando um servidor web real, como Apache,
Gunicorn, ou uWSGI. Você pode encontrar mais informações sobre como implantar o
Django com diferentes servidores web em https://docs.djangoproject.com/en/2.0/howto/deployment/wsgi/ .

Capítulo 13 , Indo ao vivo, explica como configurar um ambiente de produção

para seus projetos Django.
configurações do projeto
a céu aberto Vamos settings.py arquivo e dê uma olhada na configuração do nosso projeto. Existem
várias configurações que Django inclui neste arquivo, mas estes são apenas uma parte de todas as
configurações do Django disponíveis. Você pode ver todas as configurações e seus valores padrão
em
https://docs.djangoproject.com/en/2.0/ref/settings/ .

As configurações a seguir valem a pena olhar:

DEPURAR é um booleano que transforma o modo de depuração do projeto ligado e desligado.

Se ele é definido como Verdade, Django irá exibir páginas de erro detalhadas quando uma

exceção não pega é jogado pelo seu aplicativo. Quando você move para um ambiente de

produção, lembre-se que você tem que configurá-lo para Falso. Nunca implantar um site em

produção com DEPURAR ligado, porque você vai expor dados sensíveis relacionados com o

projecto.

ALLOWED_HOSTS não é aplicada enquanto modo de depuração está ligada, ou quando os testes são

executados. Uma vez que você mover seu site para produção e set DEPURAR para Falso, você terá que

adicionar o seu domínio / host para essa configuração, a fim de permitir que ele para servir seu

site Django.

INSTALLED_APPS é uma configuração que você terá que editar para todos os projetos. Esta

configuração diz ao Django que aplicações estão ativas para este site. Por padrão, o

Django inclui as seguintes aplicações:

django.contrib.admin: Um site de administração

 django.contrib.auth: Uma estrutura de autenticação

django.contrib.contenttypes: Uma estrutura para lidar com tipos de conteúdo

django.contrib.sessions: Um framework de sessão

django.contrib.messages: Um quadro de mensagens

django.contrib.staticfiles: Um framework para gerenciar arquivos estáticos

MIDDLEWARE é uma lista que contém middleware para ser executado.

ROOT_URLCONF indica o módulo Python, onde os padrões de URL raiz de sua

aplicação são definidos.

BANCOS DE DADOS é um dicionário que contém as definições para todos os bancos de dados a

ser utilizado no projeto. Deve haver sempre um banco de dados padrão. A configuração

padrão usa um banco de dados SQLite3.

LANGUAGE_CODE define o código de idioma padrão para este site Django.

USE_TZ diz ao Django para suporte fuso horário ativar / desativar. Django vem com

suporte para datetime timezone-aware. Esta configuração está definido para Verdade quando

você cria um novo projeto usando o startproject comando de gerenciamento.

Não se preocupe se você não entender muito sobre o que você está vendo. Você vai aprender
as diferentes configurações do Django nos capítulos seguintes.
Projetos e aplicações
Ao longo deste livro, você encontrará o projeto termos e aplicação mais e mais. Em
Django, um projeto é considerado uma instalação Django com alguns ajustes. Um
aplicativo é um grupo de modelos, visualizações, modelos e URLs. Aplicativos interagem
com a estrutura para fornecer algumas funcionalidades específicas e pode ser reutilizado
em vários projetos. Você pode pensar no projeto como o seu site, que contém várias
aplicações, tais como um blog, wiki, ou fórum, que pode ser utilizado por outros projetos
também.
Criando uma aplicação
Agora, vamos criar nossa primeira aplicação Django. Vamos criar um aplicativo de blog a
partir do zero. A partir do diretório raiz do projeto, execute o seguinte comando:

python blogue startapp manage.py

Isto irá criar a estrutura básica da aplicação, que se parece com isso:

blogue /

__init__.py admin.py

apps.py migrações /

__init__.py

models.py tests.py views.py

Esses arquivos são os seguintes:

admin.py: Isto é onde você registra modelos para incluí-los na administração

Django-site usando o site de administração do Django é opcional.

apps.py: Isto inclui a configuração principal do blogue

aplicação.

migrações: Este diretório irá conter as migrações de banco de dados de sua aplicação.

Migrações permitem Django para rastrear suas mudanças de modelo e sincronizar o

banco de dados em conformidade.

models.py: modelos de dados de seu aplicativo de todas as aplicações Django precisa ter

um models.py arquivo, mas este arquivo pode ser deixado vazio.

tests.py: Isto é onde você pode adicionar testes para a sua aplicação.

views.py: A lógica de sua aplicação vai aqui; cada vista recebe um pedido de
HTTP, processa-o, e retorna uma resposta.
Projetando o esquema de dados do
blog
Vamos começar a desenhar o nosso esquema de dados do blog, definindo os modelos de dados para o
nosso blog. Um modelo é uma classe Python que subclasses
django.db.models.Model, em que cada atributo representa um campo de base de dados. Django
irá criar uma tabela para cada modelo definido no
models.py Arquivo. Quando você cria um modelo, Django fornece uma API prático para objetos de
consulta no banco de dados facilmente.

Primeiro, vamos definir uma Postar modelo. Adicione as seguintes linhas para o
models.py arquivo do blogue inscrição:

de django.db modelos de importação de django.utils importar fuso horário a

partir django.contrib.auth.models importação de Usuário

classe Post (models.Model):

STATUS_CHOICES = (

( 'Projecto', 'Projecto'), ( 'publicada', 'Publicado'),

título = models.CharField (max_length = 250) lesma = models.SlugField

(max_length = 250,

unique_for_date = 'publicar')

Author = models.ForeignKey (User,

on_delete = models.CASCADE, related_name =

'') blog_posts

corpo models.TextField = ()

publicar = models.DateTimeField (default = timezone.now) criado = models.DateTimeField

(auto_now_add = True) atualizado = models.DateTimeField (auto_now = True) status =

models.CharField (max_length = 10,

escolhas = STATUS_CHOICES, default =

'rascunho')

class Meta:

ordenação = ( '-publish',)
 def __str __ (self):

retorno self.title

Este é o nosso modelo de dados para postagens no blog. Vamos dar uma olhada nos campos nós apenas

definidos para este modelo:

título: Este é o campo para o título do post. Este campo é CharField,

que se traduz numa VARCHAR coluna no banco de dados SQL.

lesma: Este é um campo destinado a ser usado em URLs. Uma bala é um rótulo curto

que contenha apenas letras, números, sublinhados ou hífens. Nós vamos usar o lesma campo

para construir, URLs bonitas SEOfriendly para os nossos posts. Nós adicionamos o

unique_for_date parâmetro para esse campo para que possamos construir URLs para as

mensagens usando sua data de publicação e lesma. Django irá evitar que várias mensagens de

ter a mesma lesma para uma determinada data.

autor: Este campo é uma chave estrangeira. Ele define um relacionamento muitos-para-um.

Nós estamos dizendo Django que cada post é escrito por um usuário e um usuário pode

escrever qualquer número de mensagens. Para este campo, Django irá criar uma chave

estrangeira no banco de dados usando a chave primária do modelo relacionado. Neste

caso, estamos contando com a Do utilizador modelo do sistema de autenticação do Django. o on_delete

parâmetro especifica o comportamento a adoptar quando o objeto referenciado é excluído.

Esta não é específico para Django; é um padrão SQL. utilização CASCATA, que especificam

que quando o usuário referenciado é excluído, o banco de dados também excluirá seus

posts relacionados. Você pode dar uma olhada em todas as opções possíveis no https://docs.djangoproject.com/en/2.

0 / ref / models / campos / # django.db.models.ForeignKey.on_delete . especificamos

 o nome da relação inversa, a partir de Do utilizador para Postar, com o related_name atributo. Isso

nos permitirá acessar objetos relacionados facilmente. Vamos aprender mais

sobre isso mais tarde.

corpo: Este é o corpo do post. Este campo é um campo de texto, o que

traduz um TEXTO coluna no banco de dados SQL.

publicar: Este datetime indica quando o artigo foi publicado. Usamos fuso horário do

Django agora método como o valor padrão. Isso retorna a data e hora atual em um

formato de fuso horário-aware. Você pode pensar nisso como uma versão fuso

horário-aware do Python padrão datetime.now método.

criada: Este datetime indica quando o cargo foi criado. Como estamos
usando auto_now_add aqui, a data será salvo automaticamente ao criar um
objeto.

Atualizada: Este datetime indica a última vez que o post foi atualizado. Como
estamos usando auto_now aqui, a data será atualizado automaticamente ao
salvar um objeto.

status: Este campo mostra o status de um post. Nós usamos um escolhas

parâmetro, então o valor deste campo só pode ser definida como uma das opções

dadas.

Django vem com diferentes tipos de campos que você pode usar para definir seus
modelos. Você pode encontrar todos os tipos de campo em https://docs.djangoproject.com/en/2.0/ref/models/fields/
.

o meta classe dentro do modelo contém metadados. Nós dizemos Django para resultados da
classificação no publicar campo em ordem decrescente por padrão quando consulta o banco de dados.
Nós especificar ordem decrescente usando o prefixo negativo. Ao fazer isso, posts publicados
recentemente aparecerá primeiro.
O __ str __ () método é a representação legível padrão do objeto. Django vai usá-lo em
muitos lugares, como o site de administração.

Se você vem usando Python 2.x, nota que, em Python 3, todas as cordas são nativamente considerado
Unicode e, portanto, só usamos o __ str __ () método. O __ Unicode __ () método é obsoleto.
Ativando o aplicativo
Para que o Django se manter a par da nossa aplicação e ser capaz de criar tabelas de
banco de dados para os seus modelos, temos que ativá-lo. Para fazer isso, edite o settings.py arquivo
e add blog.apps.BlogConfig ao
INSTALLED_APPS configuração. Deve olhar como este:

INSTALLED_APPS = [

'Django.contrib.admin', 'django.contrib.auth',

'django.contrib.contenttypes', 'django.contrib.sessions',

'django.contrib.messages', 'django.contrib.staticfiles',

'Blog.apps.BlogConfig',

o BlogConfig classe é a sua configuração do aplicativo. Agora o Django sabe que o nosso
aplicativo está ativo para este projeto e será capaz de carregar seus modelos.
Criação e aplicação de
migrações
Agora que temos um modelo de dados para os nossos posts, vamos precisar de uma tabela de
banco de dados para ele. Django vem com um sistema de migração que rastreia as alterações
feitas aos modelos e permite propagar-los para o banco de dados. o migrar comando aplica
migrações para todos os aplicativos listados em INSTALLED_APPS; ele sincroniza o banco de dados com
os modelos atuais e migrações existentes.

Primeiro, você precisa criar uma migração inicial para o nosso Postar modelo. No diretório
raiz do seu projeto, execute o seguinte comando:

python manage.py makemigrations blogue

Você deve obter o seguinte resultado:

Migrações para 'blog':

blog / migrações / 0001_initial.py

- Criar modelo Post

Django acabou de criar o 0001_initial.py arquivo dentro do migrações

diretório do blogue aplicação. Você pode abrir esse arquivo para ver como uma migração
aparece. dependências de uma migração especifica sobre outros migrações e operações a
executar na base de dados para sincronizar com alterações do modelo.

Vamos dar uma olhada no código SQL que o Django irá executar no banco de dados
para criar a tabela para o nosso modelo. o sqlmigrate comando leva migração nomes e retorna
o seu SQL sem executá-lo. Execute o seguinte comando para inspecionar a saída SQL
da nossa primeira migração:
 python manage.py sqlmigrate blogue 0001

A saída deve ser a seguinte:

INÍCIO;

- -

- - Criar modelo Post

- -

CREATE TABLE "blog_post" ( "id" inteiro NOT NULL PRIMARY KEY AUTOINCREMENT, varchar "título" (250) NOT NULL, varchar

"bala" (250) NOT NULL, "corpo" texto não NULL, "publicar" datetime NOT NULL, "criou" datetime NOT NULL, "updated" datetime

NOT NULL, varchar "status" (10) NOT NULL, "author_id" inteiro não referências nulas "AUTH_USER" ( "id"));

CREATE INDEX "blog_post_slug_b95473f2" ON "blog_post" ( "lesma"); CREATE INDEX "blog_post_author_id_dd7a8485"

ON "blog_post" ( "author_id"); COMMIT;

A saída exata depende do banco de dados você está usando. A saída anterior é gerado
para SQLite. Como você pode ver na saída anterior, Django gera os nomes de tabela,
combinando o nome do aplicativo e o nome em minúsculas do modelo ( blog_post), mas você
também pode especificar um nome de banco de dados personalizado para o seu modelo na

meta classe do modelo usando o db_table atributo. Django cria uma chave primária automaticamente
para cada modelo, mas você também pode substituir esse especificando primary_key = True em um de
seus campos do modelo. A chave primária padrão é uma identidade coluna, que consiste de um
número inteiro que é incrementado automaticamente. Esta coluna corresponde ao identidade campo
que é automaticamente adicionado aos seus modelos.

Vamos sincronizar nosso banco de dados com o novo modelo. Execute o seguinte comando para
aplicar as migrações existentes:

python manage.py migrar

Você vai ter uma saída que termina com a seguinte linha:

Aplicando blog.0001_initial ... OK

Nós apenas aplicado migrações para as aplicações listadas na
INSTALLED_APPS, incluindo o nosso blogue aplicação. Depois de aplicar as migrações, o banco de
dados reflete o estado atual dos nossos modelos.

Se você editar o seu models.py arquivo, a fim de adicionar, remover ou modificar campos dos modelos
existentes, ou se você adicionar novos modelos, você terá que criar uma nova migração usando o makemigrations
comando. A migração permitirá Django para acompanhar as mudanças do modelo. Então, você vai
ter que aplicá-lo com o migrar comando para manter o banco de dados em sincronia com os seus
modelos.
Criando um site de administração para os
seus modelos
Agora que já definiu o Postar modelo, vamos criar um site de administração simples de gerenciar
seus posts. Django vem com uma interface built-in de administração que é muito útil para editar
o conteúdo. O site de administração do Django é construído dinamicamente, lendo seus
metadados modelo e fornecendo uma interface pronta para produção para edição de conteúdo.
Você pode usá-lo para fora da caixa, configurar como deseja que os seus modelos a serem
exibidos na mesma.

o django.contrib.admin aplicação já está incluída no

INSTALLED_APPS configuração, de modo que não é necessário adicioná-lo.
Criando um superusuário
Em primeiro lugar, será necessário criar um usuário para gerenciar o site de administração. Execute
o seguinte comando:

python manage.py createsuperuser

Você verá a seguinte saída; digite seu nome de usuário desejado, e-mail e
senha, como segue:

Nome de usuário (deixe em branco para 'admin'): E-mail admin:•

admin@admin.com Password: ******** senha (novamente): ********

superusuário criado com sucesso.

O site de administração do Django
Agora, iniciar o servidor de desenvolvimento com a python manage.py runserver comando e aberto http://127.0.0.1:8000/admin/
no seu browser. Você deve ver a página de login administração, como mostrado na
imagem seguinte:
Faça login usando as credenciais do usuário que você criou na etapa anterior. Você verá a
página de índice do site admin, como mostrado na imagem a seguir:

o Grupo e Do utilizador modelos que você vê na imagem anteriores fazem parte da estrutura
de autenticação Django localizado na
django.contrib.auth. Se você clicar em Users, você verá o usuário criado anteriormente. o Postar modelo
do seu blogue aplicação tem uma relação com esse Do utilizador modelo. Lembre-se que é uma
relação definida pela autor campo.
Adicionando seus modelos para o site de
administração
Vamos adicionar seus modelos de blog para o site de administração. Edite o
admin.py arquivo de sua blogue aplicação e torná-lo parecido com este:

de django.contrib administrador de importação de .models

importar Publicar

admin.site.register (Post)

Agora, recarregue o site de administração no seu browser. Você deverá ver o seu
Postar modelar no site admin, como segue:

Isso foi fácil, certo? Quando você registrar um modelo no site de administração do
Django, você tem uma interface amigável gerada pela
introspecção seus modelos que permite listar, editar, criar e objetos de exclusão em uma
maneira simples.

Clique no link Adicionar ao lado de Mensagens para adicionar um novo post. Você vai notar a
forma criar esse Django tem gerado dinamicamente para o seu modelo, como mostrado na
imagem seguinte:
Django utiliza diferentes elementos do formulário para cada tipo de campo. Mesmo campos
complexos, tais como DateTimeField, são exibidos com uma interface fácil, como um selecionador de
data JavaScript.

Preencha o formulário e clique no botão SAVE. Você deve ser redirecionado para a
página de postagem lista com uma mensagem bem-sucedida e o cargo recém-criado,
como mostra a imagem a seguir:
Personalizar a forma como os modelos são
exibidos
Agora, vamos dar uma olhada em como personalizar o site de administração. Edite o admin.py arquivo
do seu aplicativo de blog e alterá-lo, como segue:

de django.contrib administrador de importação de .models

importar Publicar

@ Admin.register (Post)

classe PostAdmin (admin.ModelAdmin):

list_display = ( 'title', 'bala', 'autor', 'publicar',

'Status')

Nós estamos dizendo o site de administração do Django que o nosso modelo é registado no
site administrador usando uma classe personalizada que herda de ModelAdmin. Nesta classe,
podemos incluir informações sobre como exibir o modelo no site de administração e como
interagir com ele. o list_display
atributo permite que você defina os campos de seu modelo que você deseja exibir na
página de administração lista de objetos. O @ admin.register () decorador executa a mesma
função que o admin.site.register () funcionar temos substituído, registrando o ModelAdmin classe que
decora.

Vamos personalizar o modelo de administração com mais algumas opções, usando o seguinte código:

@ Admin.register (Post)

classe PostAdmin (admin.ModelAdmin):

list_display = ( 'title', 'bala', 'autor', 'publicar',

'Status')

list_filter = ( 'status', 'criado', 'publicar', 'autor') search_fields = (, 'body' 'título')

prepopulated_fields = { 'bala': ( 'title',)} raw_id_fields = ( 'autor' ,) date_hierarchy = 'publicar'

 ordenação = ( 'status', 'publicar')

Retorno ao seu navegador e recarregue a página pós lista. Agora, ele será parecido com este:
Você pode ver que os campos exibidos na página de pós lista são aqueles especificados
no list_display atributo. A página da lista agora inclui uma barra lateral direita que lhe permite
filtrar os resultados por campos incluídos no list_filter atributo. A barra de pesquisa apareceu
na página. Isto é porque nós definimos uma lista de campos pesquisáveis ​utilizando o search_fields
atributo. Logo abaixo da barra de pesquisa, existem links de navegação para navegar
por uma hierarquia de data: este foi definido pela date_hierarchy atributo. Você também pode
ver que as mensagens são ordenados por Estado e publicar colunas por padrão. Nós
especificamos a ordem padrão usando o encomenda atributo.

Agora, clique em Adicionar link do post. Você também vai notar algumas mudanças aqui.
Conforme você digita o título de um novo post, o lesma campo é preenchido automaticamente.
Temos dito Django para preencher previamente o lesma campo com a entrada do título campo usando o prepopulated_fields
atributo. Além disso, agora, a autor campo é exibido com uma pesquisa widget que pode escalar
muito melhor do que um drop-down selecione entrada quando você tem milhares de usuários,
como mostrado na imagem seguinte:

Com algumas linhas de código, nós ter personalizado a forma como o nosso modelo é exibido
no site de administração. Há muitas maneiras de personalizar e estender site de administração
do Django. Você vai aprender mais sobre isso mais tarde neste livro.
Trabalhando com QuerySet e
gestores
Agora que você tem um site de administração totalmente funcional para gerenciar o conteúdo do
seu blog, que é hora de aprender a recuperar as informações do banco de dados e interagir com
ele. Django vem com uma abstração API poderoso banco de dados que permite criar, recuperar,
atualizar e objetos de exclusão facilmente. o Django mapeador objeto-relacional é compatível
com o MySQL, PostgreSQL, SQLite e Oracle. Lembre-se que você pode definir o banco de dados
de seu projeto no BANCOS DE DADOS definição de seus projeto settings.py Arquivo. Django pode trabalhar com
vários bancos de dados ao mesmo tempo, e você pode programar roteadores de banco de dados
para criar esquemas de roteamento personalizadas.

Depois de ter criado seus modelos de dados, o Django lhe dá uma API livre para interagir com
eles. Você pode encontrar a referência de modelo de dados da documentação oficial

https://docs.djangoproject.com/en/2.0/ref/models/ .
criação de objetos
Abra o terminal e execute o seguinte comando para abrir o shell Python:

python shell manage.py

Em seguida, escreva as seguintes linhas:

>>> de django.contrib.auth.models importação de Usuário

>>> de blog.models importar Publicar

>>> user = User.objects.get (username = 'admin')

>>> post = Post (title = 'Outro post',

lesma = 'outro post', body = 'Post

corpo.', autor = user)

>>> post.save ()

Vamos analisar o que este código faz. Primeiro, vamos recuperar o do utilizador
objeto com o nome de usuário admin:

user = User.objects.get (username = 'admin')

o obter() método permite recuperar um único objeto do banco de dados. Note que este método
espera um resultado que corresponda à consulta. Se nenhum resultado for retornado pelo
banco de dados, este método irá gerar um Não existe exceção, e se o banco de retornos mais
de um resultado, ele vai levantar uma MultipleObjectsReturned exceção. Ambas as exceções são
atributos da classe de modelo que a consulta está sendo realizada por diante.

Então, criamos um Postar exemplo, com um título personalizado, lesma, e corpo, e vamos definir o
usuário que anteriormente recuperado como o autor do
postar:

post = Post (title = 'Outro post', slug = 'outro post', body = 'Post corpo.', autor = user)

Este objeto está na memória e não é mantido no banco de dados.

Por fim, salvar o Postar objecto para a base de dados utilizando o Salve •()
método:

post.save ()

Os executa uma acção precedentes INSERIR instrução SQL nos bastidores. Vimos como criar um
objeto na memória em primeiro lugar e, em seguida, persistem-lo para o banco de dados, mas
também podemos criar o objeto e persistem-lo no banco de dados em uma única operação
usando o crio()
método, como se segue:

Post.objects.create (title = 'Mais um post', slug = 'one-more-post', body = 'Post corpo.', Autor = user)
objetos de atualização
Agora, mudar o título do post para algo diferente e salvar o objeto novamente:

>>> post.title = 'Novo título'

>>> post.save ()

Desta vez, o Salve •() método executa um ATUALIZAR instrução SQL.

As alterações feitas ao objeto não são persistentes no banco de dados até você chamar o Salve •() método.
recuperar objetos
o Django mapeamento objeto-relacional (ORM) é baseado em QuerySets. Um QuerySet é
uma coleção de objetos a partir de seu banco de dados que podem ter vários filtros para
limitar os resultados. Você já sabe como recuperar um único objeto do banco de dados
usando o obter()
método. Nós ter acessado este método usando Post.objects.get (). Cada modelo Django tem pelo
menos um gerente, eo gerente padrão é chamado objetos. Você ganha um QuerySet objeto
usando seu gerenciador de modelo. Para recuperar todos os objetos de uma tabela, basta
usar o todos() método no padrão objetos gerente, como este:

>>> all_posts = Post.objects.all ()

É assim que criar um QuerySet que retorna todos os objetos no banco de dados. Note que
este QuerySet ainda não foi executado. QuerySets Django são preguiçoso; eles só são
avaliadas quando eles são forçados a. Este comportamento faz com que QuerySets muito
eficiente. Se não definir a QuerySet a uma variável, mas, em vez escrevê-lo diretamente no
shell Python, a instrução SQL do QuerySet é executado porque forçá-lo a resultados de
saída:

>>> Post.objects.all ()
Utilizando o filtro () Método
Para filtrar um QuerySet, você pode usar o filtro() método do gestor. Por exemplo, podemos
recuperar todas as mensagens publicadas no ano de 2017 usando o seguinte QuerySet:

Post.objects.filter (publish__year = 2017)

Você também pode filtrar por vários campos. Por exemplo, podemos recuperar todos os posts
publicados em 2017 pelo autor com o nome de usuário admin:

Post.objects.filter (publish__year = 2017, author__username = 'admin')

Isso equivale a construir o mesmo QuerySet encadeamento vários filtros:

Post.objects.filter (publish__year = 2,017) \

. filtro (author__username = 'admin')

As consultas com métodos de campo de pesquisa são construídos usando dois sublinhados, por exemplo, publish__year, mas
a mesma notação também é usado para acessar os campos dos modelos relacionados, tais como author__username.
Usando excluir ()
Você pode excluir certos resultados do seu QuerySet usando o
excluir() método do gestor. Por exemplo, podemos recuperar todos os posts publicados em
2017 cujos títulos não começar com Por quê:

Post.objects.filter (publish__year = 2,017) \

. excluir (title__startswith = 'Why')

Usando order_by ()
Você pode ordenar os resultados por diferentes campos usando o ordenar por() método do gestor. Por exemplo,
você pode recuperar todos os objetos, ordenadas pela respectiva título, do seguinte modo:

Post.objects.order_by ( 'título')

ordem crescente está implícita. Você pode indicar ordem decrescente com um prefixo sinal
negativo, como este:

Post.objects.order_by ( '- título')

Excluindo objetos
Se você deseja excluir um objeto, você pode fazê-lo a partir da instância do objeto
usando o excluir() método:

pós = Post.objects.get (ID = 1) post.delete ()

Note-se que Excluindo objetos também irá excluir quaisquer relações de dependência para
ForeignKey objectos definidos com on_delete definido como CASCATA.
Quando QuerySets são avaliados
Você pode concatenar tantos filtros quanto você gosta de um QuerySet, e você não vai bater
o banco de dados até que o QuerySet é avaliado. QuerySets são avaliados somente nos
seguintes casos:

A primeira vez que você iterar sobre eles

Quando você cortá-los, por exemplo, Post.objects.all () [: 3]

Quando você conserva ou de cache-los

Quando Você ligar repr () ou len () neles

Quando você chamar explicitamente Lista() neles

Quando você testá-los em um comunicado, tais como booleano (), ou , E, ou

E se
Criando gerentes modelo
Como já mencionado anteriormente, objetos é o gerenciador padrão de cada modelo que recupera todos os
objetos no banco de dados. No entanto, também pode definir gerentes personalizados para os nossos
modelos. Vamos criar um gerenciador customizado para recuperar todas as mensagens com o Publicados status.

Há duas maneiras de adicionar gestores para seus modelos: você pode adicionar
métodos gerente extras ou modificar QuerySets gerente iniciais. O primeiro método
fornece uma API QuerySet, como Post.objects.my_manager (), e este último lhe oferece Post.my_manager.all
(). O gerente nos permitirá recuperar mensagens usando Post.published.all ().

Edite o models.py arquivo de sua blogue aplicativo para adicionar o gerente personalizado:

classe PublishedManager (models.Manager):

def get_queryset (self):

retornar super (PublishedManager,

self) .get_queryset () \

. filtro (status = 'publicado')

classe Post (models.Model):

# . . .

objetos = models.Manager () # O gerenciador padrão. publicada = PublishedManager () #

Nosso gerente de costume.

o get_queryset () Método de um gerente retorna o QuerySet que será executado. Nós substituir esse
método para incluir o nosso filtro personalizado na QuerySet final. Nós definimos nosso
gerente de costume e acrescentou que para o Postar modelo; agora podemos usá-lo para realizar
consultas. Vamos testá-lo.

Inicie o servidor de desenvolvimento novamente com o seguinte comando:

 python shell manage.py

Agora, você pode recuperar todos os posts publicados cujos começa título com Quem
usando o seguinte comando:

Post.published.filter (title__startswith = 'Quem')

O edifício da lista e detalhe visualizações
Agora que você tem o conhecimento de como usar o ORM, você está pronto para construir os
pontos de vista da aplicação blog. A opinião de um Django é apenas uma função Python que recebe
uma solicitação da web e retorna uma resposta web. Toda a lógica para retornar a resposta
desejada vai dentro da vista.

Primeiro, vamos criar nossos pontos de vista de aplicação, então vamos definir um padrão de
URL para cada vista, e, finalmente, vamos criar modelos HTML para renderizar os dados
gerados pelos pontos de vista. Cada vista tornará um modelo passando variáveis ​para ele e
retornará uma resposta HTTP com a saída renderizada.
Criação de lista e detalhe visualizações
Vamos começar criando uma visualização para exibir a lista de mensagens. Edite o
views.py arquivo de sua blogue aplicação e torná-lo parecido com este:

de django.shortcuts importar render, get_object_or_404 de .models importar Publicar

post_list def (request):

mensagens = Post.published.all () return render

(pedido,

'Blog / post / list.html', { 'posts':

Mensagens})

Você acabou de criar sua primeira vista Django. o post_list vista leva o
solicitação objeto como o único parâmetro. Lembre-se que este parâmetro é exigido por todos os pontos
de vista. Neste ponto de vista, estamos recuperando todas as mensagens com o Publicados status
usando o Publicados gerente que criou anteriormente.

Finalmente, estamos usando o render () atalho fornecido pelo Django para renderizar a lista de
mensagens com o modelo dado. Esta função recebe o solicitação objeto, o caminho do modelo, e
as variáveis ​de contexto para tornar o modelo dado. Ele retorna um HttpResponse objeto com o texto
processado (normalmente, o código HTML). o render () atalho leva o contexto pedido em
consideração, de modo que qualquer conjunto de variáveis ​por processadores de contexto
molde é acessível pelo modelo dado. processadores contexto do template são apenas
chamáveis ​que as variáveis ​set para o contexto. Você vai aprender como usá-los em Capítulo 3 , Estendendo
o aplicativo de blog.

Vamos criar uma segunda visão para exibir um único post. Adicione a seguinte função ao views.py
Arquivo:
 post_detail def (request, ano, mês, dia, post):

post = get_object_or_404 (Post, lesma = post,

status = 'publicada', publish__year =

ano, publish__month = mês,

publish__day = dia)

voltar render (pedido,

'Blog / post / detail.html', { 'post': pós})

Esta é a visão pós detalhes. Essa visão leva ano mês dia, e postar
parâmetros para recuperar um post publicado com a lesma dada e data. Note que
quando criamos o Postar modelo, nós adicionamos a
unique_for_date parâmetro para o lesma campo. Desta forma, podemos garantir que haverá apenas um post
com uma lesma para uma determinada data e, assim, podemos recuperar mensagens individuais
com data e lesma. Na vista de detalhes, usamos o get_object_or_404 () atalho para recuperar o posto
desejado. Esta função recupera o objeto que coincide com os parâmetros dados ou lançamentos
de um HTTP 404 (não encontrado) exceção se nenhum objeto foi encontrado. Finalmente,
usamos o render () atalho para tornar o pós recuperadas usando um modelo.
Adicionando padrões de URL para os seus pontos
de vista
padrões de URL permitem mapear URLs para vistas. Um padrão de URL é composto por um
padrão de corda, uma visão, e, opcionalmente, um nome que lhe permite nomear o URL em
todo o projeto. Django percorre cada padrão de URL e pára no primeiro aquele que
corresponde ao URL solicitado. Em seguida, o Django importa o ponto de vista do padrão de
URL correspondente e executa-lo, passando uma instância do HttpRequest

classe e argumentos de palavra-chave ou posicionais.

Criar um urls.py arquivo no diretório do blogue aplicação e adicione as seguintes linhas a

ele:

de django.urls importar caminho a partir.

visualizações de importação

app_name = 'blog'

urlpatterns = [

# visualizações pós

caminho ( '', views.post_list, name = 'post_list'), caminho ( '<int: ano> / <int: mês> / <int: Dia> /

<lesma: pós> /',

views.post_detail, name =

'post_detail'),

No código anterior, definimos um namespace aplicação com o nome do aplicativo variável. Isso
nos permite organizar URLs pela aplicação e usar o nome quando se refere a eles. Nós
definimos dois padrões diferentes usando o caminho() função. O primeiro padrão de URL
não leva quaisquer argumentos e é mapeado para o post_list Visão. O segundo padrão tem
as seguintes quatro argumentos e é mapeado para o

post_detail Visão:
 ano: Requer um número inteiro

mês: Requer um número inteiro

dia: Requer um número inteiro

postar: Pode ser composto de palavras e hífens

Usamos colchetes para capturar os valores da URL. Qualquer valor especificado no padrão
de URL como < parâmetro> é capturada como uma string. Usamos conversores caminho, como < int:
ano>, para especificamente corresponder e retornar um inteiro e < lesma: pós> para combinar
especificamente uma lesma (uma string consistindo de letras ASCII ou números, mais o hífen
e caracteres de sublinhado). Você pode ver todos os conversores caminho fornecido pelo
Django em https://docs.djangoproject.com/en/2.0/topics/http/urls/

# percursoras conversores .

Se estiver usando caminho() e conversores não é suficiente para você, você pode usar re_path () em
vez de definir padrões de URL complexos com Python expressões regulares. Você pode
aprender mais sobre a definição de padrões de URL com expressões regulares em https://docs.djangoproject.com/en/2.0/
ref / urls / # django.urls.re_path . Se você não tenha trabalhado com expressões regulares antes, você pode
querer dar uma olhada no HOWTO de Expressões Regulares localizado em https://docs.python.org/3/howto/regex.html
primeiro.

criando um urls.py arquivo para cada aplicativo é a melhor maneira de tornar seus aplicativos reutilizáveis ​por outros
projetos.

Agora, você tem que incluir os padrões de URL do blogue aplicação nos principais
padrões de URL do projeto. Edite o urls.py arquivo localizado na meu site diretório do seu
projeto e torná-lo parecido com o seguinte:

de caminho django.urls importação, incluir

de django.contrib administrador de importação

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

caminho ( 'blog /', incluem ( 'blog.urls', namespace = 'blogue')),

O padrão de URL nova definido com incluir refere-se aos padrões de URL definidos no
aplicativo de blog para que elas sejam incluídas no
blogue / caminho. Nós incluímos esses padrões sob o namespace blog.
Namespaces tem que ser único em todo o seu projeto. Mais tarde, vamos nos referir a
nossos URLs de blog facilmente, incluindo o namespace, construí-las, por exemplo, Blog:
post_list e Blog: post_detail. Você pode aprender mais sobre namespaces URL no https://docs.djangoproject.com/en/2.
0 / temas / http / urls / # url-namespaces .
URLs canônicas para modelos
Você pode usar o post_detail URL que você definiu na seção anterior para construir a
URL canônica para Postar objetos. A convenção em Django é adicionar um get_absolute_url () método
para o modelo que retorna a URL canônica do objeto. Para este método, vamos
utilizar o marcha ré() método que permite que você construa URLs pelo seu nome e
passando os parâmetros opcionais. Editar seu

models.py arquivo e adicione o seguinte:

de django.urls inversa importação

classe Post (models.Model):

# . . .

def get_absolute_url (self):

voltar inversa ( 'blog: post_detail',

args = [self.publish.year,

self.publish.month,

self.publish.day, self.slug])

Nós vamos usar o get_absolute_url () método em nossos modelos de vincular a lugares específicos.
A criação de modelos para os seus pontos de
vista
Criamos pontos de vista e padrões de URL para o blogue aplicação. Agora, é hora de adicionar
modelos para mensagens de exibição de uma maneira user-friendly.

Crie os seguintes diretórios e arquivos dentro do seu blogue diretório do aplicativo:

modelos/

blogue /

pós base.html /

list.html detail.html

A estrutura anterior será a estrutura do arquivo para os nossos modelos. o base.html arquivo
irá incluir a principal estrutura HTML do site e dividir o conteúdo para a área de
conteúdo principal e uma barra lateral. o list.html e detail.html ficheiros receber do base.html

arquivo para renderizar a lista de postagem no blog e detalhe vista, respectivamente.

Django tem um modelo de linguagem poderosa que permite que você especifique como os
dados são exibidos. Baseia-se template tags, variáveis ​de modelo, e filtros de templates:

template tags controlar a prestação do modelo e olhar como {% tag%}.

As variáveis ​do modelo são substituídos com valores quando o modelo

é renderizado e olhar como {{ variável }}.

 filtros de templates permitem que você modifique variáveis ​para exibição e olhar

como {{ variável | Filtro}}.

Você pode ver todos os built-in template tags e filtros em

https://docs.djangoproject.com/en/2.0/ref/templates/builtins/ .

Vamos editar o base.html arquivo e adicione o seguinte código:

{% Carga estática%} <!

DOCTYPE html> <html>

<head>

<Title> {% title bloco%} {% endblock%} </ title> <link href = "{% estática "css / blog.css" %}" rel =

"stylesheet"> </ head> <body>

<Div id = "content">

{% De conteúdo bloco%} {%

endblock%} </ div>

<Div id = "barra lateral">

<H2> Meu blog </ h2>

<P> Este é o meu blog. </ P> </ div> </

body> </ html>

{% Carga estática%} diz ao Django para carregar o estático tags de modelos que são fornecidos
pela django.contrib.staticfiles aplicação, que está contido no INSTALLED_APPS configuração. Depois de
carregá-lo, você é capaz de usar o {% % Static} filtro de template ao longo deste modelo.
Com este filtro modelo, você pode incluir arquivos estáticos, como o blog.css

arquivo, que você vai encontrar no código deste exemplo sob a estático/
diretório do blogue aplicação. copie o estático/ diretório do código que vem junto com este
capítulo na mesma localização do seu projeto para aplicar as folhas de estilo CSS.

Você pode ver que há dois {% quadra %} Tag. Estes dizem Django que queremos definir um
bloco nessa área. Modelos que herdam a partir desse modelo podem preencher os blocos
com conteúdo. Nós definimos um
bloco chamado título e um bloco chamado conteúdo.

Vamos editar o post / list.html arquivo e torná-lo parecido com o seguinte:

{% Extends "blog / base.html" %}

{% Title bloco%} Meu Blog {% endblock%}

{% De conteúdo bloco%}

<H1> Meu Blog </ h1> {% para pós em

mensagens%}

<H2>

<a href="{{ post.get_absolute_url }}">

{{Post.title}} </a> </ h2>

<P class = "date">

Publicado {{post.publish}} por {{post.author}} </ p>

{{post.body | truncatewords: 30 | quebras de linha}} {% endfor%} {%

endblock%}

Com o {% estende%} tag, dizemos Django para herdar a partir da

blog / base.html modelo. Então, estamos enchendo o título e conteúdo blocos de molde a base com o
conteúdo. Nós percorrer os mensagens e exibir seu título, data, autor, e corpo,
incluindo um link no título para o URL canônica do post. No corpo da mensagem,
estamos aplicando dois filtros de modelo: truncatewords trunca o valor para o número de
palavras especificado e quebras de linha converte a saída em quebras de linha HTML. Você
pode concatenar como muitos filtros de templates como você deseja; cada um irá ser
aplicado à saída gerado pelo precedente.

Abra o shell e executar o python manage.py runserver comando para iniciar o servidor de
desenvolvimento. Aberto http://127.0.0.1:8000/blog/ em seu navegador, e você vai ver tudo
funcionando. Note que você precisa ter alguns posts com o status Publicado
mostrar-lhes aqui. Você deve ver algo como isto:
Em seguida, editar Vamos a post / detail.html Arquivo:

{% Extends "blog / base.html" %}

{% Título bloco%} {{post.title}} {% endblock%}

 {% De conteúdo bloco%}

<H1> {{post.title}} </ h1> <p class = "date">

Publicado {{post.publish}} por {{post.author}} </ p>

{{Post.body | quebras de linha}} {% endblock%}

Agora, você pode retornar ao seu navegador e clique em um dos títulos pós para dar
uma olhada na vista de um posto detalhes. Você deve ver algo como isto:

Dê uma olhada na URL-lo deve ser / blog / 2017/12/14 / que-foi-djangoreinhardt /. Nós projetamos URLs
SEO-friendly para os nossos posts.
adicionando a paginação
Quando você começar a adicionar conteúdo ao seu blog, você vai logo perceber que você precisa para
dividir a lista de mensagens em várias páginas. Django tem uma classe de built-in de paginação que
permite gerenciar dados paginada facilmente.

Edite o views.py arquivo do blogue aplicação para importar as classes Paginator Django
e modificar o post_list ver, como segue:

de django.core.paginator importação Paginator, emptypage, \

PageNotAnInteger

post_list def (request):

object_list = Post.published.all ()

paginator = Paginator (object_list, 3) # 3 mensagens em cada página page = request.GET.get ( 'page')

tentar:

mensagens = paginator.page (página), exceto

PageNotAnInteger:

# Se a página não é um inteiro entregar os primeiros posts page = paginator.page

(1), exceto emptypage:

# Se a página está fora do intervalo entregar última página de resultados mensagens =

paginator.page (paginator.num_pages)

voltar render (pedido,

'Blog / post / list.html', {' página ':

página,

'posts': Mensagens})

Isto é como a paginação funciona:

1. Nós instanciar o Paginator classe com o número de objetos

queremos mostrar em cada página.

2. Temos a página GET parâmetro que indica a página atual

número.
 3. Obtemos os objetos para a página desejada chamando o página()
método de Paginator.
4. Se o página parâmetro não é um inteiro, nós recuperamos o primeiro

página de resultados. Se este parâmetro é um número maior do que a última página

de resultados, vamos recuperar a última página.

5. Nós passar o número da página e os objetos recuperados para o modelo.

Agora, temos que criar um modelo para exibir o paginador para que ele possa ser incluído
em qualquer modelo que usa a paginação. No
modelos/ pasta do blogue aplicação, criar um novo arquivo e nomeá-la pagination.html. Adicione o
seguinte código HTML para o arquivo:

<Div class = "paginação">

<Span class = "Step-links">

{% If% page.has_previous}

<a href="?page={{ page.previous_page_number }}"> </a> Anterior {% endif%}

<Span class = "atual">

Página {{page.number}} de {{page.paginator.num_pages}}. </ Span>

{% If page.has_next%}

<a href="?page={{ page.next_page_number }}"> Próxima </a> {% endif%} </ span> </ div>

A espera modelo de paginação um Página objeto a fim de tornar as ligações anteriores

e posteriores e para exibir a página atual e total de páginas de resultados.
Voltemos ao blog / post / list.html molde e incluem o pagination.html Molde a parte inferior do {% % De
conteúdo}

bloco, como se segue:

{% De conteúdo bloco%}

. . .

{% Incluem "pagination.html" com page = mensagens%}

{% Endblock%}
Desde o Página objeto estamos passando para o modelo é chamado Postagens, que incluem o modelo
de paginação no modelo de lista post, passando os parâmetros para torná-lo corretamente.
Você pode seguir este método para reutilizar o modelo de paginação em vista paginada de
diferentes modelos.

Agora, aberta http://127.0.0.1:8000/blog/ no seu browser. Você deverá ver a paginação na parte
inferior da lista de correios e deve ser capaz de navegar através de páginas:
Usando visualizações baseadas em classe
vista à base de classe são uma forma alternativa para implementar vistas como Python objectos,
em vez de funções. Desde um ponto de vista é uma função que recebe uma solicitação da web e
retorna uma resposta web, você também pode definir seus pontos de vista como métodos de
classe. Django fornece classes vista base para este. Todos eles herdam da Visão classe, que alças
HTTP despacho método e outras funcionalidades comuns.

vistas à base de classe oferecem vantagens sobre os pontos de vista baseados em função para alguns casos

de uso. Eles têm as seguintes características:

código de organização relacionada com métodos HTTP, tais como GET, POST,

ou COLOCAR, em métodos separados, em vez de usar ramificação condicional

Usando herança múltipla para criar classes vista reutilizáveis ​(também conhecido

como mixins)

Você pode dar uma olhada em uma introdução à vista com base na classe de https: /
/docs.djangoproject.com/en/2.0/topics/class-based-views/intro/ .

Vamos mudar a nossa post_list vista para uma visão baseada em classes de usar o genérico Exibição de lista oferecido
pelo Django. Esta visão de base permite-lhe objetos da lista de qualquer tipo.

Edite o views.py arquivo de sua blogue aplicação e adicione o seguinte código:

de ListView importação django.views.generic

 classe PostListView (ListView):

queryset = Post.published.all () context_object_name =

'postos' paginate_by = 3

template_name = 'blog / post / list.html'

Este ponto de vista com base em classes é análogo ao anterior post_list Visão. No código
anterior, estamos dizendo Exibição de lista fazer as seguintes coisas:

Use um QuerySet específico em vez de recuperar todos os objetos. Em vez de

definir um queryset atributo, poderíamos ter especificado model = Publicar e Django teria

construído o genérico

Post.objects.all () Queryset para nós.

Use a variável de contexto Postagens para os resultados da consulta. A variável

padrão é object_list se não especificar qualquer

context_object_name.

Paginar o resultado exibindo três objetos por página.

Use um modelo personalizado para processar a página. Se não definir um

modelo padrão, Exibição de lista usará blogue / post_list.html.

Agora, abra o urls.py arquivo de sua blogue aplicação, comentar o anterior post_list URL padrão,
e adicionar um novo padrão de URL usando o PostListView classe, como segue:

urlpatterns = [

# visualizações pós

# caminho ( '', views.post_list, nome = 'post_list'),

caminho ( '', views.PostListView.as_view (), nome = 'post_list'),

caminho ( '<int: ano> / <int: mês> / <int: Dia> / <lesma: pós> /',

views.post_detail, name =

'post_detail'),

A fim de manter a paginação de trabalho, temos que usar a página direita

objeto que é passado para o molde. Django Exibição de lista visão genérica passa a página
selecionada em uma variável chamada page_obj, então você tem que editar o seu post / list.html Molde
em conformidade para incluir o paginador usando a variável direita, como se segue:

{% Incluem "pagination.html" com page = page_obj%}

Aberto http://127.0.0.1:8000/blog/ no seu navegador e verificar se tudo funciona da mesma forma que com a
anterior post_list Visão. Este é um exemplo simples de uma visão baseada em classes que usa uma
classe genérica fornecida pelo Django. Você vai aprender mais sobre visualizações baseadas
em classe em Capítulo 10 , Construir uma plataforma de e-Learning, e capítulos sucessivos.
resumo
Neste capítulo, você aprendeu os fundamentos do framework web Django através da
criação de uma aplicação básica blog. Você desenhou os modelos de dados e aplicado
migrações ao seu projeto. Você criou os pontos de vista, modelos e URLs para o seu
blog, incluindo objeto paginação.

No próximo capítulo, você vai aprender como melhorar o seu aplicativo de blog com um sistema de
comentário e funcionalidade marcação e permitir que seus usuários para mensagens de compartilhamento
por e-mail.
Aprimorando seu Blog com
funcionalidades avançadas
No capítulo anterior, você criou um aplicativo básico blog. Agora, você vai transformar sua
aplicação em um blog totalmente funcional com recursos avançados, como a partilha de
mensagens por e-mail, adicionando comentários, marcar mensagens, e recuperar mensagens por
semelhança. Neste capítulo, você vai aprender os seguintes tópicos:

Enviar e-mails com Django

Criando formas e manuseá-los em visualizações

Criando formas de modelos

Integrando aplicativos de terceiros

Construir QuerySets complexos

Compartilhando mensagens de e-mail
Primeiro, vamos permitir que os usuários para mensagens de acções, enviando-lhes e-mails. Dê um
curto tempo para pensar como você usaria visualizações, URLs, e
modelos para criar essa funcionalidade usando o que você aprendeu no capítulo anterior.
Agora, verifique o que você precisa, a fim de permitir que seus usuários para enviar
mensagens por e-mail. Você terá que fazer o seguinte:

Crie um formulário para que os usuários preencher seu nome e e-mail, o destinatário

e-mail e comentários opcionais

Criar uma vista no views.py arquivo que lida com os dados postados e envia o
e-mail

Adicionar um padrão de URL para a nova vista na urls.py arquivo do aplicativo de

blog

Criar um modelo para exibir o formulário

Criando formas com Django
Vamos começar por construir o formulário para mensagens de acções. Django tem um quadro
built-in formas que lhe permite criar formulários de uma forma fácil. O quadro de formas permite
que você defina os campos do formulário, especificar como eles têm de ser exibido, e indicar
como eles têm para validar dados de entrada. O Django forma ofertas quadro uma maneira
flexível para tornar formas e manipular os dados.

Django vem com duas classes de base para formulários de compilação:

Formato: Lhe permite construir formulários

ModelForm: Permite-lhe formas de construção ligadas a instâncias do modelo

Primeiro, crie um forms.py arquivo dentro do diretório de sua blogue aplicação e torná-lo parecido
com este:

de django formas de importação

classe EmailPostForm (forms.Form):

name = forms.CharField (max_length = 25) e-mail =

forms.EmailField () para = forms.EmailField ()

comments = forms.CharField (required = False,

widget de forms.Textarea =)

Esta é a sua primeira forma Django. Dê uma olhada no código. Nós criamos uma forma
herdando a base Formato classe. Usamos diferentes tipos de campos para Django a campos
Validar conformidade.

Os formulários podem residir em qualquer lugar em seu projeto Django. A convenção é colocá-los dentro
de um forms.py arquivo para cada aplicação.
o nome campo é CharField. Este tipo de campo é processado como um < input type = "text"> elemento
HTML. Cada tipo de campo tem um padrão widget que determina como o campo é
processado em HTML. O Widget de padrão pode ser substituído com o ferramenta atributo. No comentários
campo, usamos um textarea Widget para exibi-lo como um < textarea> elemento HTML em vez do
padrão < input> elemento.

validação de campo também depende do tipo de campo. Por exemplo, a

o email e para campos são EmailField Campos. Ambos os campos requerem um endereço de e-mail válido, caso
contrário, a validação de campo irá aumentar a forms.ValidationError
exceção e o formulário não irá validar. Outros parâmetros também são levados em conta para a
validação de formulário: nós definimos um comprimento máximo de 25 caracteres para o nome campo e
fazer a comentários campo opcional com required = False. Tudo isso é também tida em conta para a validação de
campo. Os tipos de campo utilizados neste formulário são apenas uma parte dos campos de
formulário Django. Para obter uma lista de todos os campos de formulário disponível, você pode
visitar https://docs.djangoproject.com/en/2.0/ref/forms/fields/ .
Manipulação de formas nas vistas
Você tem que criar uma nova vista que manipula o formulário e envia um e-mail quando ele
é submetido com sucesso. Edite o views.py arquivo de sua
blogue aplicação e adicione o seguinte código a ele:

de .Os impressos EmailPostForm importação

def post_share (request, post_id):

# Recuperar mensagem por id

Post = get_object_or_404 (Post, id = post_id, status = 'publicado')

se request.method == 'POST':

# Formulário foi enviado

forma = EmailPostForm (request.POST) se form.is_valid ():

# campos do formulário passado cd validação =

form.cleaned_data

# . . . enviar email

outro:

formar = EmailPostForm ()

voltar render (pedido 'blog / post / share.html', { 'post': post,

'Forma': forma})

Este ponto de vista funciona da seguinte maneira:

Nós definimos a post_share ver que leva o solicitação e o objeto post_id variável como
parâmetros.

Nós usamos o get_object_or_404 () atalho para recuperar a mensagem por ID e

certifique-se de que o pós recuperada tem um Publicados

status.

Nós usamos a mesma visão tanto para exibir o formulário inicial e processamento

dos dados apresentados. Nós diferenciar se

 o formulário foi enviado ou não com base no solicitação método e apresentar a forma

usando POSTAR. Assumimos que se conseguirmos um

OBTER pedido, uma forma vazia tem de ser apresentado, e se conseguirmos um POSTAR
pedido, o formulário é enviado e precisa ser processado. Por isso, usamos request.method
== 'POST' para distinguir entre os dois cenários.

O que se segue é o processo para exibir e manusear a forma:

1. Quando o ponto de vista é carregado inicialmente com um OBTER pedido,

crie um novo Formato exemplo que irá ser utilizado para exibir a forma vazia
no modelo:

formar = EmailPostForm ()

2. Os preenchimentos de usuário no formulário e envia-lo via POSTAR. Então nós

criar uma forma exemplo usando os dados apresentados que está contido

em request.POST:

se request.method == 'POST':

# Formulário foi enviado

forma = EmailPostForm (request.POST)

3. Após isso, validar os dados apresentadas utilizando o formulário de

é válido() método. Este método valida os dados introduzidos na forma e retornos Verdade se

todos os campos contêm dados válidos. Se qualquer campo contém dados inválidos,

em seguida, é válido() retornos Falso.

Você pode ver uma lista de erros de validação, acessando form.errors.

4. Se o formulário não é válido, prestamos a forma no modelo

 novamente com os dados apresentados. Nós vamos mostrar erros de validação

no modelo.

5. Se o formulário for válido, nós recuperamos os dados validados acessando

form.cleaned_data. Este atributo é um dicionário de campos do formulário e seus

valores.

Se os seus dados formulário não validarem, cleaned_data conterá somente os campos válidos.

Agora, vamos aprender como enviar e-mails usando Django para colocar tudo junto.
Enviar e-mails com Django
Enviar e-mails com Django é bastante simples. Primeiro, você precisa ter um servidor
SMTP local ou definir a configuração de um servidor SMTP externo, adicionando as
seguintes definições no
settings.py arquivo do seu projeto:

EMAIL_HOST: O host do servidor SMTP; o padrão é localhost

EMAIL_PORT: A porta SMTP; o padrão é 25

EMAIL_HOST_USER: Nome de usuário para o servidor SMTP

EMAIL_HOST_PASSWORD: Senha para o servidor SMTP

EMAIL_USE_TLS: Se usar uma conexão segura TLS

EMAIL_USE_SSL: Se usar uma conexão segura TLS implícitas

Se você não pode usar um servidor SMTP, você pode dizer Django a e-mails de gravação para
o console, adicionando a seguinte configuração para o settings.py Arquivo:

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

Ao usar essa configuração, o Django saída de todos os e-mails para o shell. Isto é muito
útil para testar sua aplicação sem um servidor SMTP.

Se você quiser enviar e-mails, mas você não tem um servidor SMTP local, você provavelmente
pode usar o servidor SMTP do seu provedor de serviços de e-mail. A configuração de exemplo a
seguir é válido para o envio