Artigo no estilo: Curso
Por que eu devo ler este artigo:Este artigo é útil por explorar as principais facetas de um dos frameworks web mais usados na atualidade. Baseado em Python e estruturas web comuns (HTML5, CSS, JavaScript, etc.), o Django é flexível, rápido e extremamente fácil de usar.

Em poucos passos conseguiremos configurar seu ambiente, utilizar a interface de linha de comando para criar projetos, customizá-los e desenvolver suas primeiras aplicações usando o Django. Aqui trataremos de entender o framework e criar o esqueleto inicial do microblog com o nosso template, integrações, publicação, servidor, etc.

Um framework web nada mais é que um conjunto de componentes integrados, e até certo ponto independentes, que nos ajudam a desenvolver aplicações web de forma mais rápida e facilitada. Quando falamos no universo front-end, inúmeras são as opções: desde as baseadas no JavaScript em si, tais como jQuery, AngularJS, CoffeScript, etc.; passando pelo universo CSS/CSS3 como o Sass e o Less; até chegar no imprescindível HTML/HTML5, como o Bootstrap, Thymeleaf, dentre outros. Isso sem citar o universo web móvel que traria mais exemplos famosos como o jQuery Mobile, Ionic e Framework7.

Independente da solução escolhida, é certo que não conseguimos mais viver sem os benefícios dos frameworks. Alguns deles também precisam de uma pincelada back-end, na maioria das vezes baseada em Node.js, o que é uma ótima opção, considerando-se as vantagens de usá-lo em conjunto com suas soluções afins.

Quando falamos de comunicação com o servidor, recursos como autenticação, serviços, painel de gerenciamento, formulários, upload/download de arquivos, etc. que são funcionalidades amplamente presentes, precisam ser cuidados e solucionados.

O Django é um framework web de aplicações, totalmente gratuito e escrito em Python. Ele fornece uma stack pronta e completa para solucionar problemas de autenticação, controle de administração, site maps, feeds RSS, além de implementar recursos de segurança nativamente, sem que você tenha que se preocupar em configurá-los. É fácil de usar, de configurar e, sobretudo, de manter.

Para os objetivos deste artigo é necessário que você tenha conhecimento prévios, ao menos básicos, sobre a linguagem Python, uma vez que a usaremos como base para o restante da implementação.

Trataremos de criar uma aplicação de microblog, com administração, tela de posts, gerenciamento de comentários, dentre outras funcionalidades comuns a esse tipo de aplicação, de forma semelhante ao de blogs famosos como o Blogspot. Tentaremos explorar ao máximo os principais recursos do framework, expondo seus detalhes de configuração, boas práticas, e regras de codificação.

Configurando o ambiente

Antes de começar a instalação, é interessante que o leitor tire um tempinho para fazer um tour pelo site oficial do framework (seção Links), lá você encontrará alguns resumos rápidos sobre o que é o Django e suas principais features.

Basicamente, precisamos instalar duas coisas no nosso sistema operacional: o Python em si, que no Windows não vem com um binário adicionado por padrão e, portanto, precisa ser baixado e configurado; e o Django, que será instalado via interface de linha de comando.

Portanto, acesse a página de downloads do Python (seção Links) e baixe a versão correspondente ao seu sistema operacional (tem uma para cada tipo diferente, certifique-se também de selecionar o arquivo correto para a versão do seu SO: 32/64 bits).

No momento de escrita deste artigo estávamos na versão 3.5.0, mas pode ficar à vontade para baixar uma versão mais recente, caso já exista.

Execute o .exe e, na primeira tela que aparecer, clique em Install Now (certifique-se de manter checada a checkbox “Install launcher for all users (recommended)”). Essa ação também precisará de suas permissões de administrador do SO, aguarde até que o processo todo termine.

Por padrão, a instalação descompactará os arquivos do Python no diretório C:\Program Files\Python3.5, é aconselhável que não modifique isso (na primeira tela ele mostra o diretório, caso não seja de seu agrado, modifique-o via opção de customização).

Para testar se tudo ocorreu com sucesso, abra o prompt de comando do seu SO e digite o comando python --version. Caso o comando não seja reconhecido pelo sistema, então durante a instalação não foram adicionados os diretórios do Python à respectiva variável de ambiente.

Para corrigir isso, acesse o menu Windows do seu computador e digite “variáveis de ambiente” e clique na opção que aparecer. Na seção “Variáveis do sistema” clique em Novo... e configure os valores tal como mostrado na Figura 1. O conteúdo da caixa de texto “Valor da variável” é ;D:\Program files\Python3.5;D:\Program files\Python3.5\Scripts e corresponde ao diretório dos binários onde você instalou o Python.

Figura 1. Configurando variável de ambiente do PYTHON.

Clique em OK, e, em seguida, procure pela variável Path e clique em Editar.... Adicione ao final do campo o valor %PYTHON% e clique novamente em OK três vezes. Agora, abra novamente o prompt cmd e redigite o comando. Você deve ver a versão da linguagem sendo exibida.

Virtual Environments

Antes de fazermos a instalação do Django, precisamos nos assegurar de que teremos como gerenciar as diferentes versões do Python em nosso sistema operacional sem confundir ou danificar nenhuma outra. Esse tipo de prática se chama virtualenvs (virtual environments, ou ambientes virtuais), e permite que diferentes versões do Python e seus pacotes associados possam existir em harmonia no mesmo lugar, ao mesmo tempo em que isola os setups de projetos Python/Django uns dos outros. O conceito é semelhante aos workspace que vemos em outras linguagens como o Java, por exemplo.

Tudo que precisamos fazer é selecionar o diretório onde desejamos criar o nosso virtualenv, portanto navegue até o mesmo via cmd e execute o seguinte comando na pasta:

python -m venv microblog 

Após o término, este comando irá criar a estrutura inicial do projeto com algumas pastas de bibliotecas e scripts necessários para trabalhar com o Python no seu virtualenv. Porém, para iniciar os trabalhos no mesmo é preciso ativá-lo, portanto execute o seguinte o comando:

microblog\Scripts\activate 

Isso ativará uma espécie de subconsole, que você poderá usar para efetuar quaisquer comandos como se estivesse no cmd padrão. O nome do seu virtualenv também vem por padrão pré-adicionado ao endereço de máquina acessado.

Agora sim podemos instalar o Django. Para isso, faremos uso do pip que é uma ferramenta gerenciadora de pacotes e extensões do Python, dos quais o Django faz parte.

Para verificar se o pip foi corretamente instalado junto com o Python, digite o comando pip --version e verá o resultado (versão 7.1.2 no momento de escrita deste artigo). Para finalizar, execute o seguinte comando (com dois ==):

pip install Django==1.8.5 

Essa é a versão mais recente do Django até o momento. Consulte o site oficial para verificar isso. Aguarde até que o utilitário faça o download de todas as dependências e pronto, você está com o Django instalado. Se tudo correr bem, você terá uma tela semelhante à da Figura 2.

Nota: Se, durante a instalação, você receber alguma mensagem de erro, verifique se o caminho de diretório onde criou o seu projeto contém algum espaço em branco ou caracteres especiais. Caso sim, mova o mesmo para um que atenda a essas exigências.

Figura 2. Tela de instalação bem-sucedida do Django.

Também é interessante que o leitor opte pelo editor de código fonte de sua preferência, de acordo com sua experiência em Python. Para os fins deste tutorial, faremos uso do Notepad++ que provê suporte completo ao Python, mas pode usar quaisquer outros, como o Sublime, Gedit, Atom ou inclusive as IDEs mais robustas como e Eclipse (e seu plugin pyDev) ou JetBrains PyCharm.

Ou ainda, se preferir escapar de toda essa configuração desktop, o leitor pode configurar seus projetos via projeto pythonanywhere.com que fornece todos os recursos para trabalhar com Python totalmente online.

Primeiro projeto Django

Criar um projeto no Django, basicamente, significa dizer que vamos executar alguns scripts fornecidos pelo mesmo que irão nos darão a estrutura inicial para o projeto. Trata-se apenas de um monte de diretórios e arquivos que precisaremos usar mais tarde.

Em relação aos nomes de arquivos/diretórios, é interessante que não renomeie os arquivos que estamos prestes a criar. Também é importante que você não os mova de local. O Django por si só já mantém uma certa estrutura e organização para ser capaz de encontrar coisas importantes mais à frente. Portanto, execute o seguinte comando no cmd:

django-admin startproject django_project . 

Não esqueça de pôr o ponto no fim do comando, pois ele serve para indicar que o comando encerrou e que o projeto deve ser criado na raiz do diretório atual. Note também que o comando django-admin trata-se de um script presente nos binários de instalação que se encarregará de criar as estruturas de diretórios e arquivos necessárias para o projeto base do Django. Ao final, sua pasta microblog deve estar estruturada de forma semelhante à exibida na Listagem 1.

Listagem 1. Estrutura de arquivos/diretórios gerada pelo Django.

  microblog_django
  ├───manage.py
  ├───microblog
  └───django_project
          settings.py
          urls.py
          wsgi.py
          __init__.py

Dos arquivos de extensão .py do Python, temos:

· manage.py: se encarrega de ajudar com o gerenciamento do site. Através dele estaremos aptos a iniciar um servidor web no computador sem ter de instalar nada mais;

· settings.py: contém a configuração do website;

· urls.py: contém uma lista de patterns que serão usados pelo urlresolver;

Os demais não são importantes para os nossos objetivos, logo não precisamos nos preocupar com eles.

Mudando Time Zone

Agora que já temos o projeto criado precisamos fazer algumas configurações específicas do time zone (fuso horário) do Brasil. Para isso, abra o arquivo blog_site/settings.py com o seu editor de código e procure a linha que contém a chave TIME_ZONE. Altere seu conteúdo para “America/Sao_Paulo” e salve o arquivo. Esse valor é correspondente à constante que representa a maioria dos estados brasileiros.

Além disso, também precisamos criar um caminho de diretório para os arquivos estáticos (CSS, JS, imagens, etc.) que precisarmos usar no projeto. Para tanto, vá até o fim do arquivo e adicione a seguinte linha de código:

STATIC_ROOT = os.path.join(BASE_DIR, 'static')

Isso será responsável por rotear as requisições a esses tipos de arquivos diretamente para essa pasta.

Configurando o banco de dados

Ao se trabalhar com Python você pode usar as configurações do banco de dados que desejar, porém, para abstrair os passos de configuração e instalação de bancos proprietários, optaremos por usar o que já vem por padrão com a plataforma: o sqlite3. Esse banco é extremamente leve e fácil de usar e está presente em vários ambientes como os browsers, Android, iOS, etc.

Ainda dentro do settings.py é possível observar o trecho de código que configura o acesso à engine de banco de dados do sqlite3, tal como vemos na Listagem 2.

Listagem 2. Código que configura o acesso ao banco de dados.

  # Database
  # https://docs.djangoproject.com/en/1.8/ref/settings/#databases
   
  DATABASES = {
      'default': {
          'ENGINE': 'django.db.backends.sqlite3',
          'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
      }
  }

Entretanto, para que o banco propriamente dito seja criado, precisamos executar o seguinte comando no prompt, diretamente no diretório microblog_django (onde está contido o arquivo manage.py):

python manage.py migrate

Se tudo ocorrer bem, veremos um log no console semelhante ao que temos na Listagem 3. É preciso que todas as configurações recebam um OK no final, assim teremos certeza que tudo deu certo.

Listagem 3. Log de saída para migração do banco de dados.

  (microblog) D:\tests\microblog_django>python manage.py migrate
  Operations to perform:
    Synchronize unmigrated apps: messages, staticfiles
    Apply all migrations: auth, admin, sessions, contenttypes
  Synchronizing apps without migrations:
    Creating tables...
      Running deferred SQL...
    Installing custom SQL...
  Running migrations:
    Rendering model states... DONE
    Applying contenttypes.0001_initial... OK
    Applying auth.0001_initial... OK
    Applying admin.0001_initial... OK
    Applying contenttypes.0002_remove_content_type_name... OK
    Applying auth.0002_alter_permission_name_max_length... OK
    Applying auth.0003_alter_user_email_max_length... OK
    Applying auth.0004_alter_user_username_opts... OK
    Applying auth.0005_alter_user_last_login_null... OK
    Applying auth.0006_require_contenttypes_0002... OK
    Applying sessions.0001_initial... OK

Pronto, isso é tudo que precisamos para criar o nosso banco. Agora só precisamos iniciar o servidor para verificar se a nossa aplicação está funcional. Ainda no mesmo diretório raiz (que contém o manage.py), vamos iniciar o servidor através do seguinte comando:

python manage.py runserver

Se uma mensagem como “Starting development server at http://127.0.0.1:8000/” aparecer no console, então significa que o servidor iniciou com sucesso. Após fazer isso, a sua janela do prompt ...

Quer ler esse conteúdo completo? Seja um assinante e descubra as vantagens.
  • 473 Cursos
  • 10K Artigos
  • 100 DevCasts
  • 30 Projetos
  • 80 Guias
Tenha acesso completo