Python do zero:crie um site dinâmico

Como você começa a criar sites com Python? Bem, você poderia fazer tudo sozinho e escrever um programa que rode em um servidor web, aceitando pedidos de página e servindo respostas na forma de HTML e outros recursos. No entanto, isso é muito trabalho, então por que se dar ao trabalho quando existem muitas ferramentas existentes para fazer o trabalho para você? Essas ferramentas são chamadas de frameworks e são o que usaremos hoje para criar nosso site.

Estruturas Python

Existem alguns frameworks web Python, mas aqui estão alguns dos melhores:

Django :Vamos usar isso hoje. Ele tem um enorme conjunto de recursos, mas continua sendo simples de usar. A documentação também é excelente, então se você ficar travado, você terá mais facilidade para resolver seu problema com o Django.
Flask:Flask é uma microestrutura leve de aplicativo da Web projetada para facilitar o início devido às muitas extensões que facilitam a adição de novas funcionalidades.
FastAPI:FastAPI é uma estrutura da Web moderna e de alto desempenho para criar APIs com Python 3.6+. Também é fácil de usar e oferece preenchimento automático e linting, tornando a escrita de código mais rápida do que com outros frameworks.
Falcon:Falcon é uma estrutura web minimalista para criar APIs web rápidas e back-ends de aplicativos. O Falcon oferece um design limpo que usa HTTP e o estilo de arquitetura REST para criar APIs rapidamente.

Uma lista mais abrangente pode ser encontrada no site do Python se você precisar de opções adicionais. Hoje vamos configurar o Django para desenvolvimento em uma máquina local e então construir um blog simples. Também vamos rever o processo de instalação em um servidor web remoto.

Instalando o Django

Vamos realizar a maior parte do nosso trabalho hoje no terminal. Tudo isso deve funcionar em Mac e Linux; no entanto, se você estiver executando o Windows, o processo será um pouco diferente. Uma familiaridade com a linha de comando não é necessária se você estiver apenas escrevendo Python, embora se você estiver planejando usar o Django ou executar um site dinâmico em geral, vale a pena aprender.

Tutoriais do Terminal

Considere revisar estes tutoriais para começar a usar o Terminal:

Uma introdução ao trabalho no terminal, que também abrange Git e GitHub
10 dicas para trabalhar mais rápido no terminal

Aqui estão os comandos que você precisa para instalar o Django. Você precisará instalar a versão Python 3 para executá-la. Primeiro, você precisa criar um ambiente virtual com o venv módulo. Dos documentos do Python:

O venv O módulo fornece suporte para a criação de “ambientes virtuais” leves com seus próprios diretórios de sites, opcionalmente isolados dos diretórios de sites do sistema. Cada ambiente virtual tem seu próprio binário Python (que corresponde à versão do binário que foi usado para criar esse ambiente) e pode ter seu próprio conjunto independente de pacotes Python instalados em seus diretórios de site.

Crie um diretório de projeto e um ambiente virtual dentro do diretório de projeto.

mkdir Django_projectscd Django_projectspython3.8 -m venv env

Ative o ambiente virtual e crie um novo projeto Django.

source env/bin/activatedjango-admin.py startproject FirstBlog

O diretório do projeto se parece com isso:

O que cada um desses arquivos faz?

__init__.py informa ao Python que esta pasta é um pacote do Python. Aprendemos sobre isso na terceira lição; ele permite que o Python importe todos os scripts na pasta como módulos.
gerenciar.py não faz parte do seu site; é um script utilitário que você executa na linha de comando. Ele contém uma variedade de funções para gerenciar seu site.
configurações.py contém as configurações do seu site. O Django não usa arquivos XML para configuração; tudo é Python. Este arquivo é simplesmente uma série de variáveis que definem a configuração do seu site.
urls.py é o arquivo que mapeia URLs para páginas. Por exemplo, pode mapear seusite.com/sobre para um Sobre nós página.

Aplicativos

No entanto, nenhum desses arquivos por si só faz um site funcional. Para isso, precisamos de aplicativos. Aplicativos são onde você escreve o código que faz seu site funcionar, mas antes de darmos uma olhada neles, precisamos entender um pouco sobre os princípios de design do Django.

Primeiro, o Django é um framework MVC, que significa Model View Controller. O Django se refere a si mesmo como um framework MTV, que significa Model Template View. É uma abordagem um pouco diferente do MVC, mas fundamentalmente, eles são bastante semelhantes. De qualquer forma, o MVC é um padrão de arquitetura que fornece um método para estruturar seus projetos. Ele separa o código usado para processar dados do código que gerencia a interface do usuário.

Em segundo lugar, o Django adota a filosofia DRY, ou Don't Repeat Yourself, o que significa que você nunca deve escrever código que execute uma determinada tarefa mais de uma vez. Por exemplo, em nosso blog, se escrevêssemos um recurso que selecionasse um artigo aleatório do arquivo e implementasse esse recurso em várias páginas, não o codificaríamos novamente toda vez que fosse necessário. Codificávamos uma vez e depois o usávamos em cada página.

Então, como isso se relaciona com aplicativos? Bem, os aplicativos permitem que você escreva seu site em um estilo DRY. Cada projeto, como o que temos aqui, pode conter vários aplicativos. Por outro lado, cada aplicativo pode fazer parte de vários projetos. Usando o exemplo anterior, isso significa que se fizermos outro site no futuro que também precisasse de um recurso de página aleatória, não precisaríamos escrever tudo de novo. Poderíamos simplesmente importar o aplicativo deste projeto.

Por isso, é importante que cada aplicativo sirva a um propósito distinto. Se você escrever todas as funcionalidades do seu site em um aplicativo e precisar usar parte dele novamente mais tarde, precisará importar tudo. Se você estivesse criando um site de comércio eletrônico, por exemplo, não gostaria de importar todos os recursos do blog. No entanto, se você criar um aplicativo para o recurso aleatório e um aplicativo para o sistema de publicação de blog, poderá escolher os bits necessários.

Isso também significa que dentro do site, o código está bem organizado. Se você deseja alterar um recurso, não precisa pesquisar em um arquivo enorme; você pode navegar até o aplicativo relevante e alterá-lo sem se preocupar em interferir em qualquer outra coisa.

blog python3.8 manage.py startapp

A estrutura de diretórios agora se parece com isso:

Novamente, temos um __init__.py file para torná-lo um pacote e três outros arquivos:models, tests e views. Não precisamos nos preocupar com testes por enquanto, mas os outros dois são importantes. Modelos e Visualizações são o M e V partes do MVC.

Nos modelos, definimos nossas estruturas de dados.

Se você já trabalhou com PHP antes, pode ter usado o PhpMyAdmin para criar suas tabelas MySQL e, em seguida, escrito suas consultas SQL manualmente em seus scripts PHP. No Django, é muito mais fácil. Definimos todas as estruturas de dados que precisamos neste arquivo de modelos, depois executamos um comando e todos os bancos de dados necessários são criados para nós.

Quando você deseja acessar esses dados, você passa por esses modelos chamando um método neles, em vez de executar consultas brutas. Isso é muito útil porque o Django pode usar vários programas de banco de dados. Vamos usar o MySQL hoje porque é o mais poderoso e é o que a maioria dos hosts oferece, mas se precisássemos mudar para um banco de dados diferente no futuro, todo o código ainda seria válido! Em outras linguagens, se você quisesse mudar para SQLite ou algo semelhante, precisaria reescrever o código que acessa seu banco de dados.

No arquivo de visualizações, escrevemos o código que realmente gera as páginas da web. Isso une todas as outras partes. Quando um usuário digita uma URL, ela é enviada pelo urls script que vimos anteriormente nas views script, que então obtém dados relevantes dos modelos, os processa e os passa para um modelo, que finalmente é exibido como a página que o usuário vê. Vamos dar uma olhada nesses modelos em breve. Eles são a parte mais fácil - principalmente HTML.

Adicione o aplicativo de blog à lista de INSTALLED_APPS em configurações.py Arquivo.

INSTALLED_APPS =[ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib .staticfiles', 'blog',]

Para um blog, precisaremos de uma tabela de posts, com vários campos para título, corpo do texto, autor, hora em que foi escrito e assim por diante. Um blog real teria comentários, mas isso está além do escopo da demonstração de hoje.

de django.db import modelsclass posts(models.Model):author =models.CharField(max_length =30) title =models.CharField(max_length =100) bodytext =models.TextField() timestamp =models.DateTimeField()

MySQL

Esses modelos são apenas uma descrição. Precisamos fazer um banco de dados real a partir deles. Primeiro, porém, precisamos do MySQL rodando em nosso sistema. Em um servidor web real, isso não seria um problema, porque eles geralmente o têm pré-instalado.

Para instalar o MySQL, digite:

sudo apt install mysql-server

Para verificar se a instalação foi bem sucedida, use:

mysql --versão

Isso deve retornar algo assim:

mysql Ver 14.14 Distrib 5.7.33, para Linux (x86_64) usando o wrapper EditLine

Agora, crie um banco de dados MySQL para o projeto Django. Execute o MySQL com sudo mysql , e no prompt, digite:

CREATE DATABASE django_blog;CREATE USER 'django'@'localhost' IDENTIFICADO COM mysql_native_password POR 'password';GRANT ALL ON django_blog.* TO 'django'@'localhost';FLUSH PRIVILEGES;

Iniciar o servidor de desenvolvimento

Agora você pode executar python3.8 manange.py runserver em uma nova guia para iniciar o servidor de desenvolvimento.

Mas primeiro, precisamos definir as configurações do banco de dados. Vamos dar uma olhada em settings.py .

Você precisa alterar as configurações do banco de dados primeiro.

DATABASES ={ 'default':{ 'ENGINE':'django.db.backends.mysql', # Adiciona 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' ou 'oracle'. 'NAME':'django_blog', # Ou caminho para o arquivo de banco de dados se estiver usando sqlite3. 'USER':'django_user', # Não usado com sqlite3. 'PASSWORD':'password', # Não usado com sqlite3. 'HOST':'', # Definido como string vazia para localhost. Não usado com sqlite3. 'PORT':'', # Definido como string vazia por padrão. Não usado com sqlite3. }}

Agora execute o servidor e vá para 127.0.0.1:8000 em seu navegador. Você deve ver a página padrão do Django.

Configurar o Blog no Django

Agora, vamos transformar nosso site Django em um blog. Primeiro, precisamos usar nossos modelos para criar tabelas no banco de dados criando a seguinte migração para efetuar as alterações feitas nos modelos.

python3.8 manage.py makemigrationsMigrations for 'blog':blog/migrations/0003_post.py - Criar modelo de postagem

Agora, execute a migração para criar tabelas no banco de dados.

python3.8 manage.py migrar

Criar um superusuário

Agora, você pode criar um superusuário para administrar seu aplicativo Django.

python3.8 manage.py createsuperuser

Configurar os URLs do aplicativo

Vamos configurar os URLs do aplicativo no urls.py Arquivo. Incluiremos os URLs do blog de um arquivo separado.

de django.contrib import adminfrom django.urls import path,includeurlpatterns =[ path('admin/', admin.site.urls), path("", include('blog.urls')),] Criar a primeira visualização
 
 Vamos criar nossa primeira visualização, que renderizará uma página HTML simples. Abra blog/views.py e adicione o seguinte código. 
 de django.shortcuts import renderfrom .models import Postdef home(request):return render('index.html')
 Criar o modelo de visualização
 
 Este index.html arquivo ainda não existe. O Django carregará automaticamente os templates do diretório de templates. Crie uma pasta chamada modelos no aplicativo do blog e, dentro dele, crie um arquivo chamado index.html . O diretório da pasta deve ficar assim:
 blog -templates -blog -index.html 
 
 Adicione o seguinte código em index.html . 
     Primeiro blog Primeiro blog
 Título
 Publicado na data pelo autor
 
Corpo do texto

 
 
 Agora, vamos criar os URLs do nosso blog. Crie o arquivo urls.py no diretório do blog e escreva o caminho da URL para servir a página de índice. 
 de django.urls import pathfrom . import viewsurlpatterns =[ path('', views.home), ]
 
 Agora, se você navegar até http://127.0.0.1:8000/home , você deverá ver a página a seguir atualizada com este novo conteúdo. 
    Incorporar dados do banco de dados
 
 A próxima etapa é adicionar conteúdo dinâmico do banco de dados. Para fazer isso, o Django tem uma linguagem de modelagem que permite incorporar variáveis com chaves. Altere a seção do meio da sua página para ficar assim:
  Primeiro blog
 {{ title }}
 Postado em {{ date }} por {{ author }}
 
{{ corpo }}

 
 Podemos então passar valores para esses marcadores de variáveis do views.py arquivo criando um dicionário de valores. 
 def home(request):content ={ 'title' :'My First Post', 'author' :'Giles', 'date' :'18 de setembro de 2011', 'body' :'Lorem ipsum dolor sit amet , consectetur adipiscing elit. Etiam cursus tempus dui, ut vulputate nisl eleifend eget. Aenean justo felis, dapibus quis vulputate at, porta et dolor. Praesent enim libero, maleuada nec vestibulum vitae, fermentum nec ligula. Etiam eget convallis turpis. Donec non sem justo.', } return render(request,'blog/index.html', content)
 
 Salve e atualize, e você verá que agora está passando o conteúdo para um modelo do seu arquivo de visualizações. A etapa final é obter dados do nosso banco de dados e transmiti-los. Felizmente, podemos fazer isso sem consultas SQL usando os modelos do Django. Acesse blog/views.py e atualize o código para buscar dados do banco de dados. 
 def home(request):posts =Post.objects.all()[:10] return render(request,'blog/index.html', {"posts":posts})
 
 Em seguida, atualize o modelo para acessar esses dados. 
   Primeiro blog
 
 {% para postagem em postagens %}  {{ postagem. title }}
 Postado em {{ post.timestamp }} por {{ post.author }}
 
{{ post.bodytext }}
 
 
 {% endfor %} 
 
 
 Aqui, podemos acessar todos os dados em nossa tabela no views.py arquivo e, em seguida, selecione apenas as dez primeiras entradas. Passamos esses dados para o modelo, percorremos as entradas e exibimos os dados com o HTML do nosso site. 
 Sistema de administração do Django
 
 A última coisa que precisamos fazer hoje é revisar o sistema de administração do Django. Este é um recurso realmente poderoso do Django que permite gerenciar seu site sem escrever mais nenhum código, como você teria que fazer se estivesse criando um site do zero. Para permitir que o administrador controle suas posts tabela, vamos registrar nosso Post model no admin do Django e adicione alguns dados no banco de dados. Abra blog/admin.py e adicione o seguinte código. 
 de django.contrib import adminfrom .models import Post# Registre seus modelos aqui.admin.site.register(Post)
 
 Agora você poderá adicionar novas entradas de blog visitando http://127.0.0.1:8000/admin/blog/post/. 
 
 Isso é tudo que há para fazer. Você acabou de criar um blog totalmente funcional, embora simples. Para terminar esta lição, veremos como instalar o Django em um servidor web. 
 Instalando em um servidor Web
 
 Existem dois tipos de hospedagem na web, e qual você tem afetará se você pode usar o Django. Se você tem hospedagem compartilhada, está inteiramente à mercê do seu host. 
 
 Muitos hosts da web baratos não suportam Python. Embora o PHP seja quase garantido, o suporte para outras linguagens geralmente não é. Você terá que verificar o painel de controle para determinar se Python (e Django) estão disponíveis. Obviamente, o processo é um pouco diferente com cada host. Quase todas as hospedagens rodam no Apache, e podemos usá-lo para hospedar o Django, usando o mod_wsgi ou mod_python Módulos Apache. 
 
 A maioria dos hosts da Web executa scripts em vários idiomas usando CGI. O Django pode ser executado em FastCGI e também, teoricamente, em CGI, mas isso não é oficialmente suportado e seria muito lento para um site de produção real. Você precisará verificar se eles estão instalados. Eles geralmente são encontrados em um título, como “CGI and Scripting Language Support”. 
 
 Se você tem hospedagem VPS, ou tem a sorte de ter um servidor dedicado, sua vida é muito mais fácil. Normalmente, eles vêm com o Python pré-instalado e, a partir daí, você só precisa seguir as mesmas etapas que passamos para obter uma cópia local do Django em execução. Se você não tiver o Python, poderá instalá-lo com um gerenciador de pacotes. Seu sistema pode até vir com Django. 
 
 Depois de instalar o Django em seu servidor, faça o upload do site que você acabou de criar usando qualquer cliente de transferência de arquivos. Você pode colocar os arquivos em qualquer lugar, mas mantenha-os fora do public pasta, ou qualquer pessoa poderá ver o código-fonte do seu site. Eu uso /home para todos os meus projetos. 
 
 Em seguida, crie um banco de dados MySQL chamado django_blog em seu servidor. Você terá que criar sua conta para o painel de controle do administrador novamente, mas isso é uma coisa única. 
 
 Se você tentar executar isso, poderá receber um erro, e isso ocorre porque as configurações do servidor são diferentes daquelas em seu computador local. Pode ser necessário alterar a senha do banco de dados em settings.py , mas dependendo da configuração do seu servidor, você também pode encontrar outros problemas. O Google é seu amigo nessas situações! 
 
 Para executar o servidor desta vez, o comando é um pouco diferente. Você precisa especificar um endereço IP e uma porta para poder acessar o site pela Internet. 
 python.8 manage.py runserver your-server-ip:8000
 
 Se você visitar seu site em um navegador da Web, na porta 8000, deverá ver seu site!