Desmistificando a Magia do Django

De acordo com a documentação oficial,

O Django é um framework Web Python de alto nível que incentiva o desenvolvimento rápido e o design limpo e pragmático. Construído por desenvolvedores experientes, ele resolve grande parte do incômodo do desenvolvimento da Web, para que você possa se concentrar em escrever seu aplicativo sem precisar reinventar a roda. É gratuito e de código aberto.

— DjangoProject.com

É uma das estruturas populares do Python para a criação de aplicativos da Web e é mais preferida por sua escalabilidade na criação de um clichê com configurações e arquivos estabelecidos. Isso encerra todo o objetivo do Django para desenvolvedores;

“...construindo um ótimo aplicativo em pouco tempo e menos preocupações com configurações básicas.”

Existem configurações, arquivos e estilos básicos que abrangem todos os aplicativos da Web, não importa o que você esteja criando. Ao usar o Django, eles são gerados para você automaticamente quando você executa determinados comandos em diferentes pontos do ciclo de desenvolvimento de seu aplicativo. Com isso, você terá tempo suficiente para se concentrar no aspecto central do desenvolvimento de sua aplicação enquanto o Django trata dos outros para você.

Isso significa que há um monte de coisas acontecendo debaixo do capô. Para alguém que não tem uma compreensão completa das partes móveis, isso pode ser esmagador. Neste artigo vamos aprender sobre o seguinte:

• Instalação do Django
• Os comandos startproject e startapp
• Arquivos de configuração do Django que incluem;
• configurações.py
• urls.py
• manage.py
• Layout de modelos
• Roteamento

Vamos aprender como tudo isso se encaixa e o papel que desempenham. É importante saber que não será possível dar uma olhada em tudo que acontece dentro do Django. Para casos fora do escopo deste tutorial, haverá links para indicar recursos que ajudarão nisso.

Para fins de aprendizado, estaremos construindo uma plataforma de e-commerce. Este não é um site de comércio eletrônico completo, nosso aplicativo terá apenas dois recursos básicos; criando produtos e fazendo pedidos na visão do administrador.

Este artigo irá guiá-lo através da compreensão dos comandos pré-construídos, arquivos e conceitos básicos do Django. Ele é direcionado a desenvolvedores que usaram o Django ou pretendem usá-lo e querem saber o que acontece nos bastidores. Embora não seja obrigatório que você tenha usado o Django, ter experiência com o básico do Django antes de continuar com este artigo lhe dará uma vantagem. Você precisa ter um conhecimento prático de Python para entender completamente o que será abordado neste artigo.

Instalando o Django

Se você ainda não tem o Django instalado, aqui estão os passos para fazer isso.

Primeiro, crie um ambiente virtual, chamado djangodev . Você precisa disso para isolar seu espaço de trabalho Django e seus pacotes dependentes.

 python3 -m venv ~/.virtualenvs/djangodev

Agora, para entrar em seu ambiente virtual, você precisa ativá-lo;

 source ~/.virtualenvs/djangodev/bin/activate

Se você receber algum erro ao executar com a source , poderá usar este comando alternativo,

 . ~/.virtualenvs/djangodev/bin/activate

Para usuários do Windows, faça uso disso,

 ...\> %HOMEPATH%\.virtualenvs\djangodev\Scripts\activate.bat

Nota: Você precisa ativar o ambiente virtual sempre que quiser usar o Django.

Agora que você está em seu ambiente virtual, instale o Django:

 python -m pip install Django

Para verificar se o Django foi instalado corretamente, execute;

 python -m django --version

Shakaboom! Agora você está pronto para um pouco de mágica, prepare suas varinhas!

O método de criação de arquivos e pastas em movimento pode ser simples e direto. Porém, não é o ideal quando você tem que criar um projeto de médio ou grande porte e um prazo a cumprir. Sempre temos um prazo a cumprir, mesmo para projetos pessoais.

Seguindo este método ao criar um novo projeto grande, você terá que criar vários arquivos e pastas e fazer várias configurações, o que pode levar à criação de bugs evitáveis ​​e muito tempo perdido. Os comandos startproject e startapp disponíveis para nós através do Django visam resolver este problema. Esses dois comandos criam arquivos, pastas e realizam muitas configurações para você.

Vamos começar gerando um novo aplicativo usando o comando startproject .

Aplicação de andaimes

Vamos gerar nossa aplicação e dar uma olhada nos arquivos que são gerados, bem como alguns comandos que usaremos. Execute este comando em seu terminal para começar;

 django-admin startproject ecommerce_site

Ao instalar o Django, django-admin é adicionado ao seu caminho para dar acesso para realizar suas ações. É o utilitário de linha de comando do Django para responsabilidades administrativas. Aprenda mais usos django-admin aqui; está um pouco além do escopo deste artigo.

startproject é um comando do Django que ajuda a gerar o projeto . Aqui passamos para ele o nome do nosso projeto ecommerce_site . Em seguida, ele cria o projeto em um diretório chamado ecommerce_site . O diretório deve ficar assim,

Precisaremos navegar até o diretório recém-criado e executar o comando para gerar o arquivo .

 cd ecommerce_site python manage.py startapp trading

startapp é um comando executado pelo manage.py no diretório do projeto, ele cria vários arquivos, e uma pasta nomeada usando o nome especificado no comando, neste caso, o que está especificado é trading . A pasta do aplicativo consiste em arquivos simples que devem ser necessários para criar recursos de um aplicativo. Agora seu diretório deve estar assim:

Se você está se perguntando a diferença entre um projeto e um aplicativo. Um projeto é uma aplicação web do Django, pode consistir em um ou mais aplicativos. É a pasta que contém o manage.py e o outro módulo que inclui o settings.py e outros arquivos. Um aplicativo é um pacote python que faz um determinado recurso, inclui arquivos como models.py , o diretório de migração e muito mais. Você pode conferir esta resposta no Stack Overflow para saber mais.

O startproject criará o diretório principal do projeto, enquanto o startapp criará o diretório do aplicativo. Ambos também receberam um nome para ser usado na geração. O startproject é o primeiro comando executado ao criar um novo projeto, enquanto o startapp é executado dentro do novo diretório do projeto.

O layout atual é um ótimo mapeamento que você pode usar para qualquer aplicativo que esteja construindo. É escalável e consiste em arquivos que você precisará. Há uma chance de criar, renomear, editar e mover arquivos dentro do projeto.

Configuração do Django

O Django fornece configurações e configurações diferentes para você, depois de executar os dois comandos em arquivos diferentes, vamos percorrer os arquivos gerados para aprender o que cada um faz.

settings.py

A maioria dos aplicativos da web precisa de configurações como; autenticação para verificar usuários, permissões para permitir certos usuários com certas habilidades e definir padrões de segurança. Tudo isso é necessário para dar aos seus usuários a melhor experiência necessária. Levará muito tempo para você, como desenvolvedor, começar a lançar cada um deles por conta própria, para cada aplicativo em que trabalha.

O Django fornece essas configurações necessárias e muito mais — de forma que você pode optar por aquelas que deseja e conectá-las. Isso é feito em settings.py , já existem configurações definidas criadas para fornecer funcionalidades básicas para você.

Quando o Django tenta executar um projeto, existem certas variáveis ​​que ele procura. O settings.py é o arquivo que contém as variáveis ​​que levam a outros arquivos ou informações. O Django é direcionado para este arquivo a partir do arquivo manage.py e obtém informações ou carrega outros arquivos para os quais é levado a partir daqui.

Essas configurações incluem:

• DEBUG
  A funcionalidade DEBUG está definida como True para permitir a leitura de erros e depuração de código em desenvolvimento, ela deve ser definida como False durante a produção (ou seja, quando você está implantando). Essa configuração permite que você depure melhor seu código com a ajuda do Django quando ele tentar executar seu código.
• INSTALLED_APPS
  Esta é uma lista de todos os aplicativos que executam um determinado recurso no Django. Ele vem com alguns aplicativos padrão como o 'django.contrib.auth' que é usado para autenticação de usuário, django.contrib.admin' para funcionalidade de administração e 'django.contrib.messages' necessário para enviar notificações ou informações aos usuários. Qualquer outro aplicativo que você criar usando o comando startapp terá que estar aqui antes que possa ser executado pelo Django.
• MIDDLEWARE é um framework leve para processar entradas e saídas passando por solicitações e respostas do Django. Cada middleware faz uma função específica com um aplicativo, como o 'django.contrib.auth.middleware.AuthenticationMiddleware' funciona com o 'django.contrib.sessions' para associar usuários a solicitações. Você deve verificar mais recursos de cada middleware nos documentos.
• ROOT_URLCONF é uma variável para um caminho onde o Django procura seus urlpatterns quando uma solicitação é passada para seu aplicativo Django. Sempre que uma solicitação é feita em um aplicativo Django, o Django pesquisa essa variável e carrega o arquivo principal e faz um loop pela lista urlpatterns em busca do caminho correspondente.
• TEMPLATES é uma configuração para permitir a renderização de arquivos HTML para representar uma visualização. Ele se comunica com os aplicativos de solicitação, autenticação e mensagens. O valor 'BACKEND' e o 'APP_DIRS' definido como True permitem que o Django procure por arquivos HTML dentro da pasta /templates . Os 'context_processors' nas OPTIONS são callables , que recebem a solicitação como um argumento e a mesclam com o contexto quando um modelo é renderizado, esses callables funcionam para ajudar na depuração, autenticação e tratamento de solicitações em geral.
• WSGI_APPLICATION é um caminho que leva à variável do application no arquivo wsgi.py
• DATABASE é um dicionário que tem acesso a um banco de dados externo (ou interno como no caso do sqlite padrão) como PostgresSQL, MySQL e MongoDB. Aqui está um exemplo de um banco de dados Postgres que usarei para nosso exemplo:

 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'db_name', 'USER': 'db_user', 'PASSWORD': 'db_password', 'HOST': 'localhost', 'PORT': '', } }

Você pode decidir usar o banco de dados sqlite padrão, isso não funciona muito bem para produção. Você pode configurar um banco de dados Postgres como acima, você terá que criar o banco de dados primeiro e passar o usuário, senha com permissão de gravação para o banco de dados.

Nota : Para os propósitos deste tutorial, você já pode usar o banco de dados sqlite padrão definido. O acima é uma demonstração de como você pode definir a conexão de banco de dados SQL e NO-SQL no Django.

• AUTH_PASSWORD_VALIDATORS são funções que são chamadas para validações de senha. Eles são chamados ao criar registros de usuários (e administradores também), redefinir e alterar senhas. Você pode aprender mais sobre eles na documentação oficial.

Mais documentação sobre configurações pode ser encontrada aqui.

manage.py

A maioria dos projetos da Web precisa de um ponto de entrada de onde os comandos começam. Um ponto de entrada que atua como um gateway para o aplicativo. Em todo projeto Django, geralmente é o arquivo manage.py .

Este arquivo é necessário como ponto de partida em seu aplicativo. A partir daqui, todos os comandos são executados e tudo é iniciado aqui.

manage.py faz a mesma função que django-admin. Ele também informa ao Django a localização das configurações que você tem em sua aplicação. Isso é definido por padrão e não precisa ser alterado.

Ele usa a função def main() para manipular o módulo de configurações padrão para nosso arquivo settings.py . Ele tenta importar a função de execução e, se ocorrer um erro, lança o ImportError . Caso contrário, ele recebe qualquer argumento passado pelo sys.argv da linha de comando e executa.

sys.argv é uma lista que recebe o comando passado pelo terminal. Quando executamos python manage.py runserver na linha de comando, sys.argv é definido como ["manage.py", "runserver"] e isso é passado para a função execute() .

Argumentos como python manage.py startapp trading ou python manage.py makemigrations são definidos como [ "manage.py", "startapp", "trading"] e ["manage.py", "makemigrations"] respectivamente para execução.

A instrução if está configurada para ser executada se o comando fornecido estiver configurado para manage.py .

Além de executar as funções do django-admin , você o usará na execução do servidor, manipulará migrações e outros comandos que seu projeto usará. Você também precisará dele ao implantar, testar e depurar seus projetos.

Layout do modelo

O Django fornece um layout de modelagem simples para você. Você configura seus modelos no arquivo models.py no diretório de trading . Suas classes (ou modelos) são layouts que suas tabelas de banco de dados seguirão.

Você define suas classes com base nos tipos de dados que deseja obter do usuário (ou do administrador) para cada tabela. Nossos modelos criam um arquivo de migração que funciona com a variável DATABASE no settings.py .

Vamos criar dois modelos que precisaremos, para produtos e pedidos:

 from django.db import models class Product(models.Model): name = models.CharField(max_length=50) image = models.ImageField(upload_to='products', default='python.png') price = models.IntegerField() description = models.TextField() def __str__(self): return self.name class Order(models.Model): product = models.ForeignKey(Product, on_delete=models.CASCADE) quantity = models.IntegerField() date = models.DateField(auto_now_add=True) user = models.CharField(max_length=50) def __str__(self): return self.user

O modelo do produto tem um nome, preço, descrição e uma imagem (que ao ser salva será carregada em uma pasta de products . Esta é criada caso a pasta não exista). O order possui um product (vinculado à tabela de products ), as colunas quantidade, data e usuário.

Com essas informações, o Django cria um esquema de banco de dados para o aplicativo. Além disso, cria uma API de acesso ao banco de dados Python para acessar objetos Product e Order. O Django tem uma ferramenta de migração construída para que você não precise usar pacotes externos para migrações.

A próxima etapa é executar o comando de migração e migrar para o banco de dados. Mas antes de fazermos isso, temos que registrar a trading como um aplicativo em nosso diretório de projetos.

Primeiro, temos que configurar o diretório de negociação como um aplicativo no Django. O Django fez isso para você no arquivo app.py Este arquivo registra a trading como um aplicativo e será usado posteriormente no arquivo settings.py .

Agora, em settings.py , adicione trading em INSTALLED_APP . Deve ficar assim:

 INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'trading.apps.TradingConf', ]

No terminal, execute:

 $ python manage.py makemigrations trading $ python manage.py migrate

Nota: Seu ambiente virtual deve estar ativado e você deve estar dentro do diretório do projeto.

python manage.py makemigrations trading anota as alterações feitas no módulo de negociação e cria um arquivo na pasta de migration de alterações em models.py e python manage.py migrate e atualiza as alterações.

Você pode encontrar o arquivo de migração gerado a partir do comando python manage.py makemigrations trading no diretório de migration chamado 0001_initial.py . Você pode ver as classes e colunas como comandos para criação dentro do arquivo. À medida que mais alterações no models.py forem feitas, mais arquivos serão gerados aqui.

Recursos de administrador

Em nosso aplicativo atual, precisaremos de recursos administrativos para gerenciar os produtos e pedidos que serão criados no aplicativo. O Django nos fornece uma funcionalidade de administração embutida já à nossa disposição. O aplicativo de administração (recurso) também foi registrado em nossa lista INSTALLED_APP ; 'django.contrib.admin' .

Além disso, a URL para o administrador também foi registrada na lista urlpatterns do nosso arquivo de configuração de URL urls.py ; path('admin/', admin.site.urls), . O arquivo admin.py possibilita que você registre modelos e as ações CRUD que devem ser executadas nos modelos.

Para configurar o administrador, execute isto no terminal:

 $ python manage.py createsuperuser

Você será solicitado a inserir um nome de usuário, e-mail e senha. Depois disso, você criou com sucesso um administrador. Para começar com a funcionalidade de administração, execute o servidor:

 $ python manage.py runserver

Visitar https://127.0.0.1:8000/admin/ levará a uma sessão de login, quando você fizer login (com nome de usuário e senha que você criou), você será direcionado ao painel de administração:

Os grupos e usuários são configurações padrão que permitem que o administrador acesse o gerenciamento e a permissão de usuários. Agora vamos registrar nossos modelos.

No admin.py , adicione as seguintes linhas:

 from django.contrib import admin # Register your models here. from .models import Product, Order admin.site.register(Product) admin.site.register(Order)

from django.contrib import admin importa a funcionalidade admin do Django, e então importamos as duas classes de nosso models.py e as registramos para que um admin possa executar ações CRUD em produtos e fazer pedidos no painel.

Após registrar os modelos, seu painel deve ficar assim:

Adicionando produtos:

Fazendo pedidos no painel de administração:

Roteamento fácil

Todo site precisa de rotas ou URLs que levem a páginas específicas com determinadas informações para o usuário final. Coleções de informações ou aplicativos semelhantes são acessados ​​em uma rota específica. Há uma necessidade de agrupar as rotas para acessibilidade e comunicação dentro dos arquivos. O Django fez isso para você no arquivo urls.py

O urls.py é um arquivo que parte da variável ROOT_CONF no settings.py . É aqui que nossa configuração principal de URL é feita. Quando criamos views em diferentes arquivos ou pastas, ou mesmo no arquivo urls.py , elas devem ser configuradas na lista urlpatterns .

O Django espera uma lista chamada urlpatterns no arquivo. Você pode alterar o arquivo na variável ROOT_CONF para qualquer outro arquivo que você colocou na lista urlpatterns .

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

A lista consiste em objetos que são instâncias de path ou re-path . Cada instância tem dois parâmetros obrigatórios, o padrão 'admin/' e um arquivo de visualização ou URL, admin.site.urls .

As instâncias também podem estar levando a outro arquivo com mais configurações de URL. Isso é feito para facilitar a leitura.

views.py

Uma necessidade importante para um aplicativo de back-end são as visualizações para as quais cada rota é mapeada. No Django, você escreve suas visualizações baseadas em função ou classe para um aplicativo no arquivo views.py . Uma visualização é uma classe ou função que processa uma solicitação e envia uma resposta ao usuário.

Edite seu arquivo views.py para este:

 from django.http import HttpResponse def home(request): return HttpResponse("This is a shopping site for products") def order(request): return HttpResponse("Hello, welcome to our store, browse to our products and order!")

Aqui importamos HTTPResponse para usá-lo na definição de duas visualizações (visualizações de função) para retornar a sentença quando chamado. def home deve ser chamado quando você visita o endereço principal e def order quando você acessa o URL do pedido.

Depois de criar nossas visualizações, precisamos atribuí-las a diferentes rotas (ou urlpatterns ). Isso pode ser feito de várias maneiras, podemos criar uma lista de urlpatterns no mesmo arquivo, ou podemos importar trading.views para o arquivo ecommerce_site.urls e criar o caminho.

A maneira preferida de fazer isso é criar um arquivo de configuração de sub URL (inside trading ) e incluí-lo em ecommerce_site.urls . Crie um arquivo urls.py no diretório de trading . Seu diretório deve se parecer com:

 trading/ __init__.py admin.py apps.py migrations/ __init__.py 0001_initial.py models.py tests.py urls.py views.py

Adicione o seguinte código ao seu novo arquivo ( urls.py )

 from django.urls import path from . import views urlpatterns = [ path('', views.home, name='home'), path('order/', views.order, name='order'), ]

Vamos registrar o arquivo de configuração de URL de trading ( urls.py ) no arquivo de configuração de URLs do projeto,

 from django.contrib import admin from django.urls import include, path urlpatterns = [ path('admin/', admin.site.urls), path('', include('trading.urls')) ]

Para poder acessar os urlpatterns , usaremos a classe include do django.urls na linha 2. Em seguida, escolha um padrão e anexe o arquivo urls.py no diretório de negociação.

O que fizemos aqui foi importar a classe de path do django e o arquivo views.py . Em seguida, nossa lista consiste em duas instâncias de caminho para cada visualização. Então def home é chamado em https://127.0.0.1:8000/.

E a def order é chamada em https://127.0.0.1:8000/order/.

Nota: O processo de execução de startproject e startapp não é obrigatório, mas altamente encorajado pelo Django. E você pode criar/mover arquivos e pastas depois de executar cada comando para sua conveniência de trabalho.

Árvore de dependência

Aqui está o processo no qual o Django processa solicitações de URLs que chegam:

1. O Django procura a localização raiz (caminho) para suas URLs na variável ROOT_CONF .
2. O Django carrega o arquivo python fornecido no caminho fornecido. E localiza a variável urlpatterns , esta é uma lista contendo todas as instâncias de django.urls.path() e/ou django.urls.re_path() .
3. Na lista, o Django vai em ordem e procura uma URL correspondente.
4. Python, importa e chama a visão (seja visão baseada em função ou baseada em classe). Que é passado com a solicitação HTTP.
5. A visualização processa a solicitação e as informações passadas e retorna uma mensagem/modelo ou redireciona para outra visualização.
6. Se nenhum padrão de URL corresponder, ou se uma exceção for levantada durante qualquer ponto deste processo, o Django invoca uma visão de tratamento de erros apropriada.

Conclusão

Aprendemos sobre a possibilidade de criar arquivos para o Django sem a linha de comando. Também aprendemos as vantagens e o bloco de construção de um projeto Django. Django é uma ferramenta incrível na construção de projetos de backend com o objetivo de criar simplicidade.

Você pode conferir o código para este tutorial no GitHub.

Recursos

• Gerenciamento de senhas no Django
• Django: Começando
• Django: Configurações
• Django leve por O'Reilly