“Este artigo foi revisado e atualizado com a última versão do Django - maio de 2016”
Em Parte 1 desta série, você aprendeu como instalar e configurar o Django em um ambiente virtual e criou o esqueleto de seu primeiro projeto.
Então em Parte 2 criamos um aplicativo e um modelo para Publicar objetos, que posteriormente migramos para o banco de dados. Finalmente, mostramos como integrar seu aplicativo recém-criado à interface de usuário de administração do Django.
Estes artigos fazem parte da série Django:
Instalando e configurando o Django Web Framework com ambientes virtuais - Parte 1
Revisando o básico do Python e criando seu primeiro aplicativo da Web com Django - Parte 2
Neste guia final, discutiremos como acessar o aplicativo usando a IU e como torná-lo compatível com dispositivos móveis para todos os tipos de dispositivos. Dito isso, vamos começar.
Para criar objetos do tipo
Publicar (lembre-se de que é o modelo que definimos em Parte 2 desta série), usaremos a interface de administração do Django.Certifique-se de que o servidor web embutido do Django esteja rodando na porta 8000 (ou outro de sua escolha) executando o seguinte comando a partir do meuprimeirojangoprojeto diretório:
# cd ~ / myfirstdjangoenv / myfirstdjangoproject. # python manage.py runserver 0.0.0.0:8000.
Agora abra seu navegador da web e aponte para http://ip-address: 8000 / admin
, faça logon usando as credenciais que você configurou no artigo anterior e comece a escrever uma postagem (que, novamente, criará um objeto do tipo Publicar e inserir os dados associados no banco de dados subjacente):
Repita o processo 2 ou 3 vezes:
Depois de criarmos algumas postagens, vamos ver o que precisamos fazer para exibi-las usando nosso navegador da web.
Nossa primeira visão (~ / myfirstdjangoenv / myfirstdjangoproject / myblog / views.py) será responsável por filtrar todos Publicar objetos e retornando aqueles em que o valor de quando publicado é menor ou igual à data e hora atuais (whenPublished__lte = timezone.now ()) ordenado por decrescente quando publicado, que é o mesmo que dizer “mais recente primeiro“.
Esses objetos são salvos em uma variável convenientemente nomeada posts, e são retornados (identificados como Todas as publicações) para ser incorporado ao HTML, como veremos na próxima seção:
da renderização de importação de django.shortcuts. de .models import Post. de django.utils importe fuso horário. def posts (request): posts = Post.objects.filter (whenPublished__lte = timezone.now ()). order_by ('- whenPublished') retornar render (request, 'myblog / posts.html', {'allposts': posts} )
Finalmente, o sublinhado duplo em whenPublished__lte
acima é usado para separar um campo de banco de dados (quando publicado) de um filtro ou operação (lte = menos maior ou igual).
Depois de definir nossa visão inicial, vamos trabalhar no modelo associado.
Seguindo as diretivas e caminhos fornecidos na seção anterior, vamos armazenar nosso modelo inicial dentro myblog / templates / myblog. Isso significa que você precisará criar um diretório chamado modelos e um subdiretório chamado meu blog:
# cd ~ / myfirstdjangoenv / myfirstdjangoproject / myblog. # mkdir -p templates / myblog.
Vamos chamar o modelo posts.html
e insira o seguinte código nele. Você notará que estamos adicionando referências online para jQuery, Bootstrap, FontAwesome e fontes do Google.
Além disso, colocamos o código Python entre chaves dentro do HTML. Observe que para cada objeto do tipo Post mostraremos seu título, sua data de publicação e autor e, finalmente, seu texto. Finalmente, em vermelho você verá que fazemos uma referência aos objetos retornados via myblog / views.py:
Ok, aqui está o posts.html Arquivo:
Meu blog
{% para postagem em todas as postagens%}{% endfor%}{{post.title}}Publicado em {{post.whenPublished}} por {{post.author}}.{{post.text | linebreaks}}
No acima modelo, a quebras de linha filtro é usado para substituir as quebras de linha em texto simples com o equivalente HTML correspondente (
ou
Em seguida, precisamos configurar um mapeamento entre URLs em nosso aplicativo e as visualizações correspondentes que retornam os dados. Para fazer isso, crie um arquivo chamado urls.py dentro meu blog com o seguinte conteúdo:
de django.conf.urls import url. a partir de. importar visualizações. urlpatterns = [url (r '^ $', views.posts, name = 'posts'),]
O r '^ $'
merece um pouco mais de explicação. A liderança r
instrui o Django a tratar a string dentro de aspas simples como uma expressão regular.
Em particular, r '^ $'
representa uma string vazia para que quando apontamos nosso navegador para http://ip-address: 8000
(e nada mais), os dados retornados pela variável Postagens dentro views.py
(consulte a seção anterior) serão apresentados em nossa página inicial:
Por último, mas não menos importante, incluiremos o urls.py arquivo do nosso aplicativo de blog (~ / myfirstdjangoenv / myfirstdjangoproject / myblog / urls.py) no urls.py do nosso projeto principal (~ / myfirstdjangoenv / myfirstdjangoproject / myfirstdjangoproject / urls.py):
de django.conf.urls importação inclui, url. from django.contrib import admin urlpatterns = [url (r '^ admin /', include (admin.site.urls)), url (r '', include ('myblog.urls')),]
Então vamos iniciar o servidor web:
# cd ~ / myfirstdjangoenv / myfirstdjangoproject. # python manage.py runserver 0.0.0.0:8000.
Agora devemos ser capazes de ver as listas de postagens que criamos anteriormente:
Graças a Bootstrap, você ainda pode ter uma excelente visualização em um dispositivo menor:
Vamos agora revisar os conceitos que cobrimos neste artigo e em toda esta série:
1. Cada modelo define um objeto e mapeia para uma tabela de banco de dados, cujos campos, por sua vez, mapeiam para as propriedades desse objeto. Por outro lado, um modelo define a interface do usuário onde os dados retornados pela visualização serão exibidos.
Digamos que queremos modificar nosso modelo adicionando um campo chamado resumo ao Publicar objeto, onde iremos armazenar uma breve descrição opcional de cada postagem. Vamos adicionar a seguinte linha em myblog / models.py:
resumo = modelos. CharField (max_length = 350, em branco = verdadeiro, nulo = verdadeiro)
Como aprendemos no artigo anterior, precisamos migrar as alterações para o banco de dados:
# python manage.py makemigrations myblog. # python manage.py migrate myblog.
Em seguida, use a interface de administração para editar as postagens e adicionar um breve resumo a cada postagem. Finalmente, substitua a seguinte linha no modelo (posts.html):
{{post.text | linebreaks}}
com
{{post.summary}}
Atualize a página inicial para ver as mudanças:
2. UMA Visão função recebe uma solicitação HTTP e retorna uma resposta HTTP. Neste artigo, postagens def (solicitação) em views.py faz uma chamada para o banco de dados subjacente para recuperar todas as postagens. Se quisermos recuperar todas as postagens com a palavra ansible no título, devemos substituir.
posts = Post.objects.filter (whenPublished__lte = timezone.now ()) .order_by ('- quando publicado')
com
posts = Post.objects.filter (title__icontains = "ansible") .order_by ('- quando publicado')
Ao separar a interface do usuário da lógica do aplicativo em aplicativos da web, o Django facilita as tarefas de manutenção e escalonamento de aplicativos.
3. Se você seguiu as instruções fornecidas nesta série, a estrutura do seu projeto deve ser a seguinte:
myfirstdjangoenv / myfirstdjangoproject. ├── db.sqlite3. ├── manage.py. ├── meublog. │ ├── admin.py. │ ├── admin.pyc. │ ├── __init__.py. │ ├── __init __. Pyc. │ ├── migrações. │ │ ├── 0001_initial.py. │ │ ├── 0001_initial.pyc. │ │ ├── __init__.py. │ │ └── __init __. Pyc. │ ├── models.py. │ ├── models.pyc. │ ├── modelos. │ │ └── myblog. │ │ └── posts.html. │ ├── tests.py. │ ├── urls.py. │ ├── urls.pyc. │ ├── views.py. │ └── views.pyc. └── myfirstdjangoproject ├── __init__.py ├── __init __. Pyc ├── settings.py ├── settings.pyc ├── urls.py ├── urls.pyc ├── wsgi.py └── wsgi .pyc.
Caso a lista acima não seja exibida corretamente em seu navegador, aqui está uma captura de tela da saída do seguinte comando:
# tree myfirstdjangoenv / myfirstdjangoproject.
Embora todos esses conceitos possam parecer um pouco intimidantes no início, posso garantir que Django vale todos os esforços necessários para se familiarizar com ele
Espero que o exemplo que usamos nesta série para apresentá-lo a essa excelente estrutura da web o motive a aprender mais. Se sim, o oficial Documentação Django (que é constantemente atualizado) é o melhor lugar para começar.
Posso garantir que existe muito mais no Django do que podemos cobrir adequadamente em uma série de artigos, então sinta-se à vontade para explorá-lo e aprender fazendo!
Sinta-se à vontade para deixar-nos uma nota com perguntas ou sugestões usando o formulário abaixo.