Python

Mapeando banco de dados existente com Django

O Django é um ótimo framework para iniciar um projeto completamente do zero, mas nem sempre este é nosso caso. Imagine que uma empresa pretende migrar uma aplicação legada (antiga) com 100 tabelas em seu banco de dados e escolhe o Django como sua nova tecnologia… Como faríamos para mapear todo o banco de dados (tabelas e relações) para nosso projeto? Parece algo cansativo e complicado, certo!? Bom, com o Django, isso pode ser mais fácil do que parece…

Banco de Dados

Para nosso exemplo, iremos utilizar um banco de dados com uma estrutura que armazena a lista de empregados de uma empresa e suas relações. Não vamos nos preocupar com a estrutura do banco de dados em si, o importante aqui é entender que teremos 6 tabelas com os seguintes campos:

Para criar o banco de dados acima em seu MySQL, precisamos baixar toda a sua estrutura no repositório encontrado no seguinte link:

Depois disso, vamos baixar seu código-fonte e salvar no Desktop do nosso computador. Depois de descompactado, utilizamos o terminal para incorporar o banco de dados teste para o MySQL presente em nossa máquina. Para isso, no terminal (ou CMD), utilizamos o seguinte comando:

mysql -u root -p < employees.sql

Lembrando que o “root” é o nome do usuário do banco de dados. Caso o seu seja diferente, informe-o na instrução acima 🙂

Depois disso, o banco employees será criado no MySQL:

Lembrando que o BD que utilizamos já virá populado, contendo mais de 300,000 empregados registrados. Situação parecida ao que descrevemos anteriormente:

Configurando aplicação

Após criar o banco de dados, estamos prontos para mapeá-lo em nosso projeto Django. Para isso, partiremos de uma aplicação “zerada”, apenas com o projeto e uma app criada. Além disso, precisamos instalar, obviamente, o Django e o mysqlclient em nossa virtualenv:


Além disso, precisamos configurar o projeto para se comunicar com o banco de dados que acabamos de importar. Para isso, no arquivo settings.py do nosso projeto, determinamos seus parâmetros de conexão:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'employees',
        'USER': 'root',
        'PASSWORD': 'root',
        'HOST': 'localhost',
        'PORT': '3306'
    }
}

Com isso, temos nossa aplicação criada e se comunicando com o banco de dados \o

Mapeando o banco de dados no Django

Depois de configurar a aplicação, chegou a hora tão esperada: mapear o banco de dados para nosso arquivo models.py 😀

Para isso, é muito simples (e você vai se impressionar com isso). Tudo que temos que fazer é abrir o terminal integrado do PyCharm e digitar o seguinte comando:

python manage.py inspectdb > nome_da_app.models.py

Lembrando que “nome_da_app” deve ser alterada pelo nome da sua app no projeto, hein!? 🙂

Após isso, no arquivo models.py da nossa aplicação, teremos o seguinte resultado:

from django.db import models


class Departments(models.Model):
    dept_no = models.CharField(primary_key=True, max_length=4)
    dept_name = models.CharField(unique=True, max_length=40)

    class Meta:
        managed = False
        db_table = 'departments'


class DeptEmp(models.Model):
    emp_no = models.ForeignKey('Employees', models.DO_NOTHING, db_column='emp_no', primary_key=True)
    dept_no = models.ForeignKey(Departments, models.DO_NOTHING, db_column='dept_no')
    from_date = models.DateField()
    to_date = models.DateField()

    class Meta:
        managed = False
        db_table = 'dept_emp'
        unique_together = (('emp_no', 'dept_no'),)


class DeptManager(models.Model):
    emp_no = models.ForeignKey('Employees', models.DO_NOTHING, db_column='emp_no', primary_key=True)
    dept_no = models.ForeignKey(Departments, models.DO_NOTHING, db_column='dept_no')
    from_date = models.DateField()
    to_date = models.DateField()

    class Meta:
        managed = False
        db_table = 'dept_manager'
        unique_together = (('emp_no', 'dept_no'),)


class Employees(models.Model):
    emp_no = models.IntegerField(primary_key=True)
    birth_date = models.DateField()
    first_name = models.CharField(max_length=14)
    last_name = models.CharField(max_length=16)
    gender = models.CharField(max_length=1)
    hire_date = models.DateField()

    class Meta:
        managed = False
        db_table = 'employees'


class Salaries(models.Model):
    emp_no = models.ForeignKey(Employees, models.DO_NOTHING, db_column='emp_no', primary_key=True)
    salary = models.IntegerField()
    from_date = models.DateField()
    to_date = models.DateField()

    class Meta:
        managed = False
        db_table = 'salaries'
        unique_together = (('emp_no', 'from_date'),)


class Titles(models.Model):
    emp_no = models.ForeignKey(Employees, models.DO_NOTHING, db_column='emp_no', primary_key=True)
    title = models.CharField(max_length=50)
    from_date = models.DateField()
    to_date = models.DateField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'titles'
        unique_together = (('emp_no', 'title', 'from_date'),)

Exatamente a mesma estrutura (com seus atributos e relacionamentos) presentes no banco de dados que incorporamos ao MySQL da nossa máquina. Bem legal, né!?

Imagine ter que mapear todas essas entidades, avaliando seus tipos de dados e relações… Seria um trabalho bem cansativo, concorda? Com o Django, um simples comando consegue resolver este problema 🙂

Agora, já estamos prontos para utilizar todo o poder do ORM do Django para manipular o banco de dados e, consequentemente, criar nossa nova aplicação \o

Relacionamento 1-1, 1-N e N-N com Django

No modelo relacional, existem três tipos de associação entre entidades (tabelas) distintas. Estas relações são utilizadas para mapear como as tabelas interagem entre si e podem ser classificadas de três formas: 1-1 (um para um), 1-N (um para muitos) e N-N (muitos para muitos).

Sendo assim, veremos neste artigo como funciona e como implementar os três tipos de relacionamento no Django.

Django - Fundamentos
Curso de Django - Fundamentos
CONHEÇA O CURSO

Relacionamento 1-1

Assim como o próprio nome supõe, o relacionamento 1-1 define que um item de uma entidade só poderá se relacionar com um item de outra entidade. Por exemplo, supondo que temos as entidades Cliente e Endereço que se relacionam de forma 1-1, um cliente só poderá possuir um endereço, que também só pode estar relacionado a um cliente.

Para criar este tipo de relacionamento no Django, no arquivo models.py, precisamos criar um campo que armazene o ID do endereço na entidade cliente do tipo OneToOneField:

class Endereco(models.Model):
        # Definimos seus atributos

class Cliente(models.Model):
        # Definimos seus atributos
      endereco = models.OneToOneField(Endereco, on_delete=models.SET_NULL, null=True)

Desta forma, a classe Cliente irá armazenar o ID do Endereço que cada cliente possuirá. O código completo das classes Endereço e Cliente podem ser vistas abaixo:

class Endereco(models.Model):
    rua = models.CharField(max_length=200, null=False, blank=False)
    numero = models.IntegerField(null=False, blank=False)
    complemento = models.CharField(max_length=200, null=False, blank=False)
    bairro = models.CharField(max_length=50, null=False, blank=False)
    cidade = models.CharField(max_length=100, null=False, blank=False)
    pais = models.CharField(max_length=50, null=False, blank=False)

    def __str__(self):
        return self.rua

class Cliente(models.Model):
    SEXO_CHOICES = (
        ("F", "Feminino"),
        ("M", "Masculino"),
        ("N", "Nenhuma das opções")
    )

    nome = models.CharField(max_length=100, null=False, blank=False)
    data_nascimento = models.DateField(null=False, blank=False)
    email = models.EmailField(null=False, blank=False)
    profissao = models.CharField(max_length=50, null=False, blank=False)
    sexo = models.CharField(max_length=1, choices=SEXO_CHOICES, blank=False, null=False)
    endereco = models.OneToOneField(Endereco, on_delete=models.SET_NULL, null=True)

Após definir as classes acima, precisamos criar a migração para efetivar as alterações no banco de dados e, assim, criar as tabelas no banco de dados. Para isso, utilizamos os comandos abaixo:

python manage.py makemigrations

python manage.py migrate

Isso fará com que as tabelas sejam criadas no banco de dados com a seguinte estrutura:

Relacionamento 1N

O relacionamento 1N determina que um item de uma tabela pode se relacionar com vários itens de uma outra tabela. Continuando o exemplo acima, podemos determinar que um cliente pode realizar diversos pedidos em um restaurante, porém cada pedido só pode possuir um cliente atrelado a ele.

Para criar este relacionamento no Django, utilizamos um campo do tipo ForeignKey, como podemos ver abaixo:

class Pedido(models.Model):
    cliente = models.ForeignKey("Cliente", on_delete=models.CASCADE, related_name='pedidos')

Isso fará com que a tabela Pedidoarmazene o ID do cliente de cada relação. O código completo das classes Pedido e Cliente pode ser visto abaixo:

class Pedido(models.Model):
    STATUS_CHOICES = (
        ("P", "Pedido realizado"),
        ("F", "Fazendo"),
        ("E", "Saiu para entrega"),
    )
    cliente = models.ForeignKey("Cliente", on_delete=models.CASCADE, related_name='pedidos')
    observacoes = models.CharField(max_length=300, null=False, blank=False)
    data_pedido = models.DateTimeField(default=timezone.now)
    valor = models.FloatField(blank=False, null=False)
    status = models.CharField(max_length=1, choices=STATUS_CHOICES, blank=False, null=False)

    def __str__(self):
        return self.cliente.nome

class Cliente(models.Model):
    SEXO_CHOICES = (
        ("F", "Feminino"),
        ("M", "Masculino"),
        ("N", "Nenhuma das opções")
    )

    nome = models.CharField(max_length=100, null=False, blank=False)
    data_nascimento = models.DateField(null=False, blank=False)
    email = models.EmailField(null=False, blank=False)
    profissao = models.CharField(max_length=50, null=False, blank=False)
    sexo = models.CharField(max_length=1, choices=SEXO_CHOICES, blank=False, null=False)
    endereco = models.OneToOneField(Endereco, on_delete=models.SET_NULL, null=True)

Após definir as classes acima, precisamos criar a migração para efetivar as alterações no banco de dados e, assim, criar as tabelas no banco de dados. Para isso, utilizamos os comandos abaixo:

python manage.py makemigrations

python manage.py migrate

Isso fará com que as tabelas sejam criadas no banco de dados com a seguinte estrutura:

Agora, a tabela Pedido armazenará, além de todos os seus atributos, o ID do cliente. Assim, um cliente poderá estar relacionado a vários pedidos, porém um pedido só pode se relacionar com um único cliente.

Django - Fundamentos
Curso de Django - Fundamentos
CONHEÇA O CURSO

Relacionamento NN

O relacionamento NN define que um item de uma tabela pode se relacionar com vários itens de uma outra tabela e vice-versa. Por exemplo, podemos determinar que um pedido pode possuir diversos produtos relacionados a ele, assim como um mesmo produto pode estar relacionado a diversos pedidos diferentes.

Para criar este tipo de relacionamento, utilizamos um campo do tipo ManyToManyField, como podemos ver abaixo:

class Produto(models.Model):
    nome = models.CharField(max_length=50, null=False, blank=False)
    descricao = models.CharField(max_length=200, null=False, blank=False)
    valor = models.FloatField(null=False, blank=False)

    def __str__(self):
        return self.nome

class Pedido(models.Model):
    STATUS_CHOICES = (
        ("P", "Pedido realizado"),
        ("F", "Fazendo"),
        ("E", "Saiu para entrega"),
    )
    cliente = models.ForeignKey("Cliente", on_delete=models.CASCADE, related_name='pedidos')
    observacoes = models.CharField(max_length=300, null=False, blank=False)
    data_pedido = models.DateTimeField(default=timezone.now)
    valor = models.FloatField(blank=False, null=False)
    status = models.CharField(max_length=1, choices=STATUS_CHOICES, blank=False, null=False)
    produtos = models.ManyToManyField(Produto)

    def __str__(self):
        return self.cliente.nome

Após definir as classes acima, precisamos criar a migração para efetivar as alterações no banco de dados e, assim, criar as tabelas no banco de dados. Para isso, utilizamos os comandos abaixo:

python manage.py makemigrations

python manage.py migrate

Isso fará com que as tabelas sejam criadas no banco de dados com a seguinte estrutura:

Para este tipo de relacionamento, uma tabela “auxiliar” será criada para armazenar os IDs do pedido e do produto que se relaciona.

A tabela clientes_pedido_produtosirá armazenar o id do pedido e o id do produto que fazem relação. Desta forma, um pedido pode se relacionar com diferentes produtos e um produto pode estar relacionado a diferentes pedidos.

Conclusão

Vimos neste artigo o quão simples é criar os três tipos de relacionamento em bancos de dados relacionais utilizando o ORM do Django. Com isso, agora podemos criar nossas aplicações e estruturar nosso banco de dados da melhor forma possível.

O que é Django?

O Django é um framework gratuito e de código aberto escrito em Python para desenvolvimento web. Sua utilização permite a construção de aplicações web de alto desempenho.

Django - Fundamentos
Curso de Django - Fundamentos
CONHEÇA O CURSO

O que é um Framework?

O framework é um facilitador no desenvolvimento de diversas aplicações, e sem dúvida, sua utilização poupa tempo e custos para quem utiliza, pois de forma mais básica, é um conjunto de bibliotecas utilizadas para criar uma base onde as aplicações são construídas, um otimizador de recursos. Tem como principal objetivo resolver problemas recorrentes com uma abordagem mais genérica. Ele permite ao desenvolvedor focar nos “problemas” da aplicação, não na arquitetura e configurações.

História do Django

Lançado em 2005 sob a licença BSD (de código aberto), o Django foi desenvolvido inicialmente como um sistema de gerenciamento de um site jornalístico. Tem como seus co-criadores os desenvolvedores Adrian Holovaty e Simon Willison. A escolha do nome “Django” foi inspirado no músico de jazz Django Reinhardt, considerado um dos melhores e mais influentes guitarristas de todos os tempos. \o/

Padrão MTV

O Django utiliza o padrão de projeto MTV (Model, Template e View), que é basicamente:

Model: Onde acontece toda interação com o banco de dados;

Template: Onde acontece a renderização dos dados para uma visualização mais intuitiva, em outras palavras, a interação do usuário com o site em Django;

E a View: Lógica sobre os dados. A camada responsável pelas regras de negócio do sistema Django.

Por ser popular, o Django possui uma grande comunidade de desenvolvedores. Com isso, fica muito mais fácil encontrar materiais de estudo e programadores dispostos a se ajudarem.

Utiliza o princípio Don´t Repeat Yourself ou simplesmente DRY, permitindo que as aplicações sejam desenvolvidas com a maior quantidade de aproveitamento de código possível.

Concluindo:

Com isso, vimos algumas das principais características do Django, o que o torna um framework muito utilizado e que, com certeza, você deve levar em consideração quando iniciar um projeto. =)

Utilizando arquivos estáticos em um projeto Django

A utilização de arquivos estáticos no Django necessita de algumas configurações para ser feita, como veremos neste artigo 🙂

Django - Fundamentos
Curso de Django - Fundamentos
CONHEÇA O CURSO

Configurando aplicação

Com a aplicação aberta no PyCharm, precisamos configurar o diretório em que os arquivos estáticos (JS, CSS e IMG) serão armazenados. Para isso, vamos até o final do arquivo settings.py do nosso projeto até encontrar a configuração STATIC_URL, é ela quem define o diretório que os arquivos estáticos serão armazenados.

Por padrão, o Django armazena os arquivos estáticos em um diretório chamado static, localizado na aplicação. Sendo assim, é lá que vamos armazenar os arquivos CSS, JS e IMG da aplicação.

Para isso, o primeiro passo é criar um diretório chamado static na aplicação e, dentro do diretório static, criar uma outra pasta com o nome da aplicação. Por exemplo, se a aplicação possuir o nome “minha_aplicacao”, precisamos criar um diretório static/minha_aplicacao dentro da app que estamos desenvolvendo:

Note que na imagem acima, estamos criando um diretório com o mesmo nome da aplicação “app” dentro do diretório “static” e, dentro do diretório “app”, criamos as pastas para armazenar os arquivos css, js e img.

Com isso, só precisamos armazenar os arquivos estáticos do projeto em seu respectivo diretório. Como exemplo, vamos criar um arquivo css simples e armazená-lo no diretório static/app/css com o nome style.css e com o seguinte conteúdo:

body {
  background-color: lightblue;
}

h1 {
  color: navy;
  margin-left: 30px;
}
Django - Templates
Curso de Django - Templates
CONHEÇA O CURSO

Utilizando arquivos nos templates

Agora que já configuramos a localização dos arquivos estáticos e criamos o css de exemplo, precisamos importá-lo em nossos templates. Para isso, o processo é bem simples:

1 – Carregamos a tag static do Django em nosso template (linha 2);

2 – Carregamos o arquivo css utilizando a tag (linha 7). Note que precisamos determinar o caminho, a partir do diretório static, do arquivo css que criamos anteriormente.

<!DOCTYPE html>
{% load static %}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Página de testes</title>
    <link rel="stylesheet" href="{% static 'app/css/style.css' %}">
</head>
<body>

<h1>Olá, mundo</h1>

</body>
</html>

Testando aplicação

Agora, ao executar a aplicação e renderizar o template com o css importado, teremos o seguinte resultado:

Deploy de uma aplicação Django no Heroku

Hoje, a principal forma de entrega e uso de uma aplicação é por meio da nuvem. É por lá que as aplicações são armazenadas e acessadas. Sendo assim, é imprescindível que uma aplicação seja armazenada em algum servidor e disponível pela internet.

Pensando nisso, veremos neste artigo como realizar o Deploy de uma aplicação Django e disponibilizá-la no Heroku, serviço de armazenamento em nuvem de aplicações.

Clonando o repositório da aplicação

Como exemplo, iremos utilizar a aplicação feita no curso “Django – Fundamentos” aqui da TreinaWeb. Apesar de ser uma aplicação simples, será um ótimo exemplo para testes.

Django - Fundamentos
Curso de Django - Fundamentos
CONHEÇA O CURSO

Para realizar o clone do projeto, vamos até o CMD (se você usa o Windows) ou Terminal (caso você use o macOS ou Linux) e utilizamos o seguinte comando:

git clone https://github.com/treinaweb/treinaweb-django-fundamentos.git

Feito isso, o projeto será baixado em seu computador e você terá todo o seu código-fonte.

Criar conta no Heroku

Após baixar o código-fonte do projeto, precisamos criar uma conta (ou realizar o login) no Heroku. O processo é bem simples, basta preencher o formulário na página de cadastro do site (https://signup.heroku.com/):

Caso você já possua uma conta no Heroku, só será necessário realizar o login (https://id.heroku.com/login).

Depois disso, você será redirecionado para a página inicial do Heroku:

Criar app no Heroku

Depois de criar uma conta no Heroku, precisamos criar uma app para armazenar a aplicação Django. Para isso, na página inicial, clicamos no botão “Create New App”. Depois, na próxima página, definimos o nome da aplicação que estamos criando e clicamos no botão “Create App”:

Com isso, seremos redirecionados para a página de configuração da aplicação. É nela que configuramos o servidor em que a aplicação será armazenado.

Instalar o Heroku CLI

Para que seja possível enviar o código-fonte do projeto para o servidor que acabamos de criar, precisamos instalar o CLI (Command Line Interface) do Heroku. É com ele que conseguimos executar determinados comandos utilizando nosso computador para gerenciar o servidor da aplicação.

Para isso, há uma página que contém todas as informações necessárias para esse processo. Lembrando que o Heroku CLI é multi-plataforma, ou seja, poderá ser utilizado em qualquer SO (Windows, macOS ou Linux).

Todo o processo de instalação está descrito na documentação do Heroku (https://devcenter.heroku.com/articles/heroku-cli) e é bastante simples.

Se você utiliza o macOS, você precisa digitar o seguinte comando em seu terminal:

brew tap heroku/brew && brew install heroku

Caso você utilize o Linux, o comando é o seguinte:

sudo snap install --classic heroku

Agora, caso você utilize o Windows, você precisará baixar e executar o instalador do Heroku CLI, também disponível na página citada acima:

Lembrando que, para qualquer SO, é necessário possuir o Git instalado. Mas, já que você fez o clone do repositório do projeto, isso já deve estar funcionando 🙂

Logar no Heroku CLI

Depois de baixar e instalar o Heroku CLI, precisamos logar com nossa conta na ferramenta. Para isso, vamos até o CMD (ou Terminal) e digitamos o seguinte comando:

heroku login

Uma mensagem no terminal será exibida e podemos clicar em qualquer tecla do teclado. Neste momento, o navegador irá abrir uma página para realizarmos o login no Heroku. Após digitarmos nossos dados de acesso, clicamos no botão “Login” e o processo será encerrado com sucesso:

Configurar Projeto

Com todas as configurações do Heroku prontas, chegou a hora de configurarmos a aplicação que será armazenada no servidor. Para isso, o primeiro passo é instalar a biblioteca django-heroku, responsável por automatizar as configurações do nosso projeto com o Heroku.

Instalar o django-heroku

Para instalar o django-heroku, vamos até a janela de configuração da nossa virtualenv do PyCharm (Arquivo > Settings > Project Interpreter, caso você utilize o Windows ou Linux ou PyCharm Community Edition > Preferences > Project Interpreter, caso você utilize o macOS), clicamos no botão “+” no canto inferior esquerdo e buscamos a biblioteca pelo seu nome, como podemos ver abaixo:

Depois disso, a biblioteca será instalada em nossa virtualenv e estaremos prontos para configurá-la em nosso projeto. Sendo assim, vamos até o arquivo settings.py e ativamos o django-heroku adicionando o seguinte conteúdo no final do arquivo :

# Configure Django App for Heroku.
import django_heroku
django_heroku.settings(locals())

Feito isso, as configurações do Heroku em nossa aplicação estão prontas.

Criar Procfile

Depois de instalar o django-heroku, precisamos criar o arquivo Procfile na raiz do nosso projeto. É ele quem vai definir qual arquivo será usado para processar as requisições da nossa aplicação. No Django, esse arquivo é o wsgi.py, localizado na pasta da nossa aplicação.

Sendo assim, criamos um arquivo de texto simples com o nome Procfilee salvamos na raiz do nosso projeto. Dentro dele, colamos o seguinte conteúdo:

web: gunicorn tw_clientes.wsgi

Lembrando que o nome da sua aplicação pode variar, caso você não esteja utilizando o mesmo projeto citado anteriormente. Se este for o seu caso, altere o “tw_cliente.wsgi” para o nome da sua aplicação.

Depois disso, precisamos instalar a biblioteca gunicorn, servidor HTTP para aplicações Python. O processo é o mesmo que o django-heroku, porém devemos pesquisar por gunicornna janela de instalação de bibliotecas:

Criar requirements.py

Depois disso, precisamos criar o arquivo requirements.py para armazenar as bibliotecas utilizadas no projeto. Lembrando que você precisa estar com a virtualenv ativa no PyCharm.

Sendo assim, o comando para gerar o arquivo requirements.pycom base nas bibliotecas instaladas na virtualenv do projeto é o seguinte:

pip freeze > requirements.txt

Com isso, o arquivo requirements.txtserá criado na raiz do projeto com o seguinte conteúdo:

dj-database-url==0.5.0
Django==2.1.7
django-heroku==0.3.1
gunicorn==19.9.0
mysqlclient==1.4.2
psycopg2==2.7.7
pytz==2018.9
whitenoise==4.1.2

São essas as bibliotecas utilizadas em nosso projeto. Lembrando que o conteúdo deste arquivo pode variar caso você tenha mais bibliotecas em sua virtualenv.

Lembrando que a lista de bibliotecas utilizadas pode ser vista na janela de configurações do PyCharm (Arquivo > Settings > Project Interpreter, caso você utilize o Windows ou Linux ou PyCharm Community Edition > Preferences > Project Interpreter, caso você utilize o macOS):

Realizar o Deploy

Finalmente, após todas as configurações, estamos prontos para subir nosso projeto no Heroku o/.

Subindo aplicação

Para isso, vamos até o terminal e digitamos o seguinte comando:

heroku git:remote -a django-treinaweb
git add .
git commit -m "Deploy da aplicação"
git push -u heroku master

Depois disso, uma mensagem será exibida no terminal indicando que o deploy foi feito com sucesso:

Clicando no link indicado, somos redirecionados para a página da aplicação que acabou de ser armazenada. Neste momento, a página que será exibida terá o seguinte visual:

Como sabemos, essa é a página de erro do Django. Sendo assim, ao que tudo indica, o Deploy foi feito com sucesso. Sendo assim, se navegarmos até a página https://django-treinaweb.herokuapp.com/clientes/listar teremos o seguinte:

O erro acima indica que o Django não conseguiu encontrar as tabelas que estamos utilizando no banco de dados. E isso faz sentido, já que, até o momento, não migramos o conteúdo dos arquivos de migração para o Heroku. Sendo assim, este é o último passo a ser realizado.

Criando banco de dados

Para executar o comando responsável por criar o banco de dados no heroku, vamos até o terminal e digitamos o seguinte comando:

heroku run python manage.py migrate

O comando acima irá executar as migrações no banco de dados do Heroku e criar toda a sua estrutura:

Agora, ao retornar para a página anterior, podemos ver que a aplicação está sendo executada sem qualquer erro:

Inclusive, podemos utilizar qualquer recurso da nossa aplicação, como o cadastro de novos clientes:


Agora, toda a nossa aplicação já está disponível e funcional diretamente da nuvem através do Heroku 🙂

Django ou Flask, eis a questão.

O ecossistema do Python é repleto de ótimos frameworks, dentre eles se destacam o Django e o Flask, dois frameworks para desenvolvimento web e que possuem diversos adeptos pelo mundo. Mas você já se perguntou quando usar um deles e quais são suas principais diferenças? Bom, é isso que veremos neste artigo. 🙂

Django


O Django é um framework de desenvolvimento rápido para web. Escrito em Python, o Django foi lançado em 2005 e, atualmente, está na versão 2.2. Criado originalmente para gerenciar um site jornalístico na cidade de Lawrence, Kansas, tornou-se um projeto Open Source e logo caiu no gosto dos desenvolvedores intusiastas em Python.

Utiliza o padrão de projeto próprio denominado MTV (model-template-view), bem similar ao já conhecido MVC (model-view-controller), que separa as responsabilidades da aplicação em camadas, aumentando a legibilidade do código e organização da aplicação.
A principal premissa do Django é seu princípio DRY (Don’t Repeat Yourself), fazendo com que o desenvolvedor aproveite o máximo de código já criado em outros módulos da aplicação, evitando ao máximo a repetição e reescrita de código.

Django - Fundamentos
Curso de Django - Fundamentos
CONHEÇA O CURSO

Tá, mas onde eu vou usar o Django?

O Django é mais recomendado quando estamos desenvolvendo um projeto mais profissional e complexo (apesar de ser amplamente utilizado em pequenos projetos também). Possui um amplo conjunto de ferramentas que facilita a criação destas aplicações, como:

  • Django ORM: Permite que você conecte seu projeto com vários bancos de dados relacionais (PostgreSQL, Oracle, MySQL, SQLite, etc) e gerencie seus dados de forma simplificada, sem a necessidade de escrever código SQL.
  • Django Admin: Possui uma área administrativa integrada ao projeto para gerenciamento de todos os dados da aplicação, facilitando a criação de um projeto CMS (sistema de gerenciamento de conteúdo).
  • Django Templates: Com o Django, a criação das páginas HTML para exibição de conteúdo é feita de forma simples e rápida, permitindo a herança de templates e concatenação de código Python com HTML.
  • Comunidade: A comunidade por trás do Django é incrível. Diversos projetos são desenvolvidos diariamente, tornando seu ecossistema cada vez maior.

Flask


O Flask é, assim como o Django, um framework (ou microframework) web de código aberto. Lançado em 2010, o Flask também é amplatamente utilizado em projetos ao redor do mundo.

Diferente do Django, que já possui um conjunto de ferramentas integradas ao Framework, o Flask pode ser comparado a um conjunto de Lego. Ao instalarmos o Flask, apenas duas bibliotecas são instaladas em conjunto, permitindo que o desenvolvedor instale apenas o que o projeto irá necessitar, isso torna a aplicação muito mais leve e rápida de ser executada já que, por exemplo, não precisamos de uma biblioteca para envio de e-mail se a aplicação não irá utilizar deste recurso.

É chamado de microframework justamente por manter um núcleo simples, porém estendível. Não possui camada de acesso ao banco de dados, validação de formulários ou qualquer outro componente. Para isso, é necessário instalar bibliotecas de terceiros e, assim, prover determinada funcionalidade. Isso torna a construção de aplicações com Flask mais simples e sua curva de apendizado mais leve.

Flask - Fundamentos
Curso de Flask - Fundamentos
CONHEÇA O CURSO

Tá, mas onde eu vou usar o Flask?

Como dito anteriormente, o Flask é amplamente utilizado em pequenas aplicações ou microsserviços, embora possamos criar grandes projetos com o Flask.
De todas as características do Flask, é possível ressaltar as seguintes:

  • Simplicidade: Por ser um framework minimalista, o Flask fornece os recursos necessários para a criação da base de uma aplicação, como seu sistema de templates, rotas e servidor web embutido para testes. A partir daí, qualquer que seja a necessidade, o desenvolvedor poderá utilizar de bibliotecas externas para incrementar sua aplicação. Isso faz com que o projeto seja o mais simples possível, sem tantos arquivos desnecessários;
  • Velocidade: Alinhado à simplicidade do projeto, o Flask possui um desempenho superior quando comparado ao Django.
  • Comunidade: Assim como o Django, o Flask possui uma ampla comunidade com vários desenvolvedores espalhados ao redor do mundo. Por isso, diversas novas bibliotecas estão sendo diariamente disponibilizadas para uso.

E ai? Deciciu?

Bom, apesar do Flask e do Django possuírem características similares, seu uso é um pouco distinto. Podemos considerar que o Django é mais recomendado para aplicações maiores e que exigem uma complexidade superior, já que possui diversas facilidades embutidas em seu core, além de uma comunidade gigantesca.
Já o Flask é mais utilizado em pequenas aplicações e microsserviços, como APIs. Ou seja, aplicações que devem ser executadas de forma mais rápida.
A partir daí, a escolha entre as duas ferramentas deve ser feita pelo desenvolvedor, que irá analisar o projeto e determinar qual framework se encaixa melhor em seu escopo.

Criando ambientes virtuais para projetos Python com o Virtualenv

Quando estamos desenvolvendo diversos projetos em Python, é comum utilizarmos diferentes versões de uma mesma biblioteca entre este projetos. Por exemplo, imagine que estamos desenvolvendo o projeto x com a biblioteca mysqlclient em sua versão 1.0 e o projeto y com a mesma biblioteca, porém na versão 2.0. Como faríamos para gerenciar estas dependências e o sistema operacional saber qual versão correta executar quando estivermos em cada projeto?

Esta é uma tarefa um tanto quanto complexa para o SO gerenciar, podendo acarretar em conflitos entre as versões e causar muita dor de cabeça. Sendo assim, o mais comum é utilizarmos diferentes ambentes virtuais, chamados de virtualenvs, um para cada projeto. E é isso que veremos neste artigo 😀

Python - Fundamentos
Curso de Python - Fundamentos
CONHEÇA O CURSO

O que é uma virtualenv?

Como dito acima, um problema muito comum é quando precisamos utilizar diversas versões de uma mesma biblioteca em diferentes projetos Python. Isso pode acarretar em conflitos entre as versões e muita dor de cabeça para o desenvolvedor. Para resolver este problema, o mais correto é a criação de um ambiente virtual para cada projeto.

Basicamente, um ambiente virtual empacota todas as dependências que um projeto precisa e armazena em um diretório, fazendo com que nenhum pacote seja instalado diretamente no sistema operacional. Sendo assim, cada projeto pode possuir seu próprio ambiente e, consequentemente, suas bibliotecas em versões específicas.

Como funciona uma virtualenv?

O funcionamento de uma virtualenv é bem simples. Basicamente, uma cópia dos diretórios necessários para que um programa Python seja executado é criada, incluindo:

  • PIP (Gerenciador de pacotes);
  • A versão do Python utilizada (2.x ou 3.x);
  • Dependências instaladas com o pip (armazenadas no diretório site-packages);
  • Seu código fonte;
  • Bibliotecas comuns do Python.

Isso faz com que as dependências sejam sempre instaladas em uma virtualenv específica, não mais no sistema operacional. A partir daí, cada projeto executa seu código-fonte utilizando sua virtualenv própria 🙂

Instalando a virtualenv

A instalação de uma virtualenv é feita utilizando o pip, gerenciador de pacotes do Python. Já falamos sobre o PIP em um outro artigo aqui do blog. Caso você não saiba do que se trata ou como instalá-lo, sugiro você dar uma passada por lá 🙂
Após instalar o pip, utilizamos o comando abaixo para instalar o pacote virtualenv em nosso computador:

pip install virtualenv

Feito isso, o pacote estará instalado e pronto para ser utilizado. Agora já podemos criar e gerenciar nossos ambientes virtuais.

Criando uma nova virtualenv

O processo de criação de uma virtualenv é bastante simples e pode ser feito utilizando um único comando, como podemos ver abaixo:

virtualenv nome_da_virtualenv

O mais comum é criar a virtualenv na raiz do projeto que ela irá pertencer. Isso permite uma organização maior das virtualenvs que possuímos em nosso computador:

Com isso, criamos a virtualenv do projeto chamada “venv”. É ela quem vai comportar todos os pacotes necessários para a execução do projeto.

Ativando uma virtualenv

Após criar uma virtualenv, precisamos ativá-la para que possamos instalar os pacotes necessários do projeto. Para isso, utilizamos o seguinte comando:

  • souce nome_da_virtualenv/bin/activate (Linux ou macOS)
  • nome_da_virtualenvScriptsactivate (Windows)

O comando acima irá ativar a virutalenv e teremos um retorno similar ao ilustrado abaixo:

Note que o nome da virtualenv, agora, é exibido antes do caminho do diretório em que estamos. Isso indica que a virtualenv foi ativada com sucesso.

Desativando uma virtualenv

Para desativar uma virtualenv utilizamos o comando deactivate, como podemos ver abaixo:

Instalando pacotes

Com a virtualenv ativada, podemos instalar os pacotes necessários do projeto utilizando o próprio PIP:

Com isso, instalamos o pacote Django, em sua versão mais atual, na virtualenv do projeto “projeto_python”.

Agora, se precisarmos instalar uma outra versão do Django em outro projeto, bastaria criar uma nova virtualenv e realizar o mesmo processo:

Com isso, teremos diferentes versões do Django instaladas no mesmo sistema operacional, porém isoladas em cada ambiente. Sendo assim, o projeto “projeto_python” utiliza a versão mais recente (2.1.3) e o “projeto_python_2” utiliza a versão 2.11, tudo de forma isolada entre os projetos:


Concluindo

Com isso, vimos o quão importante e simples é utilizar uma virtualenv para cada projeto. Com isso, garantimos que as versões de cada pacote sejam isoladas, permitindo que não haja conflito entre elas.

Python - Orientação a objetos
Curso de Python - Orientação a objetos
CONHEÇA O CURSO

Criando um Chatbot com Python

Os chatbots são aplicações que trocam e gerenciam mensagens. Atualmente, várias empresas estão investindo neste segmento para a criação de assistentes virtuais (robôs que interagem com o usuário e realizam determinadas tarefas cotidianas).

Neste artigo veremos como criar um chatbot com Python que interage com o usuário e aprende enquanto conversa em um jogo de perguntas e respostas.

Python - Fundamentos
Curso de Python - Fundamentos
CONHEÇA O CURSO

Instalando as ferramentas

O primeiro passo para o desenvolvimento do nosso chatbot é instalar as ferramentas necessárias. Para isso, vamos precisar do Python, PIP e da biblioteca Chatterbot. Também vamos utilizar o PyCharm em sua versão Community para ajudar no desenvolvimento, mas seu uso é opicional.

O download do Python pode ser feita por meio do seu site oficial e o processo é bem simples (next > next > finish).

Já o PIP, gerenciador de pacotes do Python, pode ser baixado também por meio de seu site oficial. Todo o processo de instalação do PIP pode ser visto neste post do blog da TreinaWeb.

Por fim, com o Python e o PIP instalados, precisamos instalar a biblioteca Chatterbot. Para isso, após criar o projeto no PyCharm, vamos até a aba “Project Interpreter”, localizado em “Preferences” dentro do PyCharm. Lá, vamos buscar pela biblioteca Chatterbot e realizar sua instalação, como podemos ver abaixo:

Feito isso, todas as ferramentas necessárias já estão instaladas e prontas para serem utilizadas.

Criando o Chatbot

O processo de criação do Chatbot é bem simples. Basicamente, vamos criar uma lista de perguntas e respostas que serão usadas como aprendizado inicial do nosso Bot. A partir daí, utilizaremos alguns métodos para que todas as perguntas e respostas que vamos informando para ele, sejam analisadas, processadas e aprendidas conforme o tempo. Veremos abaixo todo o código detalhado:

from chatterbot.trainers import ListTrainer
from chatterbot import ChatBot

O primeiro passo para a criação do nosso chatbot é importar o método ListTrainer responsável por permitir que uma lista de strings seja utilizada no processo de aprendizagem do Bot. Após isso, importamos o construtor Chatbot para que possamos criá-lo em nosso programa.

Feito isso, precisamos inicializar nosso Chatbot e determinar a lista inicial de mensagens que serão utilizadas como base para o aprendizado do Bot:

bot = ChatBot('TW Chat Bot')

conversa = ['Oi', 'Olá', 'Tudo bem?', 'Tudo ótimo', 
            'Você gosta de programar?', 'Sim, eu programo em Python']

bot.set_trainer(ListTrainer)
bot.train(conversa)

Com isso, nós registramos três perguntas. Por padrão, cada resposta se refere ao item anterior da lista. Por exemplo, a string ‘Olá’ se refere como resposta da pergunta ‘Oi’. Já a string ‘Tudo ótimo’ é resposta da pergunta ‘Tudo bem?’ e assim por diante.

Após isso, definimos, através do método train(), que utilizaremos a lista conversa como ponto de partida para o aprendizado do Bot.

Finalmente, criamos um loop infinito que vai capturar a pergunta do usuário, buscar uma possível resposta e retornar ao usuário. Definimos, também, que se o grau de confiança da resposta for menor que 0.5, o Bot vai informar que ainda não sabe responder tal pergunta:

while True:
    pergunta = input("Usuário: ")
    resposta = bot.get_response(pergunta)
    if float(resposta.confidence) > 0.5:
        print('TW Bot: ', resposta)
    else:
        print('TW Bot: Ainda não sei responder esta pergunta')

Sendo assim, o código final do nosso Chatbot pode ser visto abaixo:

from chatterbot.trainers import ListTrainer
from chatterbot import ChatBot

bot = ChatBot('TW Chat Bot')

conversa = ['Oi', 'Olá', 'Tudo bem?', 'Tudo ótimo', 'Você gosta de programar?', 'Sim, eu programo em Python']

bot.set_trainer(ListTrainer)
bot.train(conversa)

while True:
    pergunta = input("Usuário: ")
    resposta = bot.get_response(pergunta)
    if float(resposta.confidence) > 0.5:
        print('TW Bot: ', resposta)
    else:
        print('TW Bot: Ainda não sei responder esta pergunta')

Vale ressaltar que as perguntas e respostas do nosso ChatBot vão sendo armazenadas em um banco de dados SQLite criado automaticamente. Um outro ponto importante é que o processo de aprendizado é um pouco lento, então você terá que conversar alguns minutos com seu ChatBot até que ele aprenda novas perguntas e suas respectivas respostas.

Após isso, podemos executar nosso ChatBot e conversar com nosso novo amigo. Para isso, clicamos com o botão direito no arquivo e selecionamos a opção “Run”:

Nosso ChatBot será inicializado e nós podemos trocar mensagens com ele. Após alguns minutos de conversa, você perceberá que o ChatBot fará perguntas que não estão cadastradas em nossa lista conversa. Estas perguntas são aprendidas com o tempo e armazenadas no banco de dados:

Nem sempre as respostas possuem exatidão, mas este processo vai melhorando com o tempo. Basta você indicar o caminho correto para o Bot que ele aprenderá mais rápido.

Concluindo

Neste artigo vimos como é simples criar um ChatBot com Python. O processo de aprendizado, no início, é demorado, mas vai melhorando com o tempo. Após alguns minutos de conversa, você terá um amigo pra dialogar nas horas vagas sobre os assuntos que você mais gosta. 😀

Python - Orientação a objetos
Curso de Python - Orientação a objetos
CONHEÇA O CURSO

Protegendo suas aplicações Python de SQL Injection

Um dos maiores problemas que assombram os desenvolvedores de software é o SQL Injection. Essa técnica pode permitir que um código SQL seja executado através da aplicação cliente sem qualquer tipo de restrição e, assim, alterar os dados sem qualquer conhecimento dos administradores do sistema. Parece grave, certo? E, realmente, é. Sendo assim, neste artigo falaremos um pouco sobre o SQL Injection e como proteger aplicações Python deste tipo de ataque.

Python - Fundamentos
Curso de Python - Fundamentos
CONHEÇA O CURSO

O problema

Como dito anteriormente, o SQL Injection permite que código SQL seja executado através da aplicação cliente diretamente no banco de dados. Isso permite que hackers consigam alterar dados de forma irrestrita e sem consentimento dos administradores do sistema, o que é um problema muito grave em relação a segurança de um sistema. Para entender melhor este problema, vamos a um exemplo prático.

Imagine uma aplicação simples em que seja possível atualizar clientes passando seu nome e idade. Focando apenas no back-end da aplicação e sem qualquer tipo de verificação de SQL Injection, o código responsável por atualizar clientes seria basicamente da seguinte forma:

nome = 'João'
cursor.execute(f"UPDATE cliente SET nome={nome} WHERE idcliente=13")

O código acima irá atualizar o nome do cliente com id 13 para “João”. Até aí, tudo bem. Estamos apenas atualizando o nome de um cliente em nosso banco de dados. Porém, imagine que, ao invés de passar apenas ‘João’ para a variável nome, passarmos um código SQL:

nome = "'Carlos' , idade = 80"
cursor.execute(f"UPDATE cliente SET nome={nome} WHERE idcliente=13")

O código acima permitirá que o nome e idade do cliente com id 13 sejam alterados simultaneamente, sem permissão ou consentimento do administrador do sistema. Até pode paracer bobagem não permitir a edição da idade de um cliente, porém, imagine um sistema bancário com este mesmo problema e que permita que o valor do saldo seja alterado pelo usuário… Complicou, né?

A solução

Para solucionar o problema do SQL Injection, precisamos parametrizar as querys utilizadas em nosso programa e, assim, não permitir que um código SQL seja executado pelo lado cliente da aplicação. Para isso, alteramos a query da seguinte forma:

nome = "'Carlos' , idade = 80"
cursor.execute("UPDATE cliente SET nome=%(nome)s WHERE idcliente=13", ({'nome': nome, }))

Com o código acima, não vamos mais executar o código presente na variável "nome" no UPDATE. Ao invés disso, todo o conteúdo desta variável será armazenado como nome do cliente com id 13. Fazendo com que, o nome do cliente com id 13 seja "Carlos, idade = 80" e a sua idade permaneça inalterada.

Concluindo

Desta forma, não vamos mais permitir que os campos de uma determinada tabela sejam alterados sem permissão do sistema e, assim, garantimos muito mais segurança para a nossa aplicação.

Python - Banco de dados com DB API
Curso de Python - Banco de dados com DB API
CONHEÇA O CURSO

3 linguagens de programação que continuam em alta

Você provavelmente já se pegou pensando em qual linguagem você deve focar seus estudos. Seja se você está iniciando ou não, é sempre bom ver o que o mercado está pedindo. Claro que não devemos avaliar apenas o mercado, mas também suas preferências. A ideia é fazer uma junção dessas duas coisas: escolher uma linguagem em alta, mas que dentre elas, você escolha a que mais se identificar.

No começo deste ano fizemos um post sobre as linguagens promissoras para se estudar neste ano. Mas como na área de TI tudo muda muito rápido, será que agora, perto do final do ano, essas linguagens ainda estão no topo? Vamos focar hoje nas 3 principais do momento.

1) JavaScript

Assim como no começo do ano, o JavaScript aparece em primeiro lugar. Como é uma linguagem dinâmica pode ser utilizada para várias coisas. Temos um post que aborda justamente isso: O que se pode fazer com JavaScript hoje em dia?

O site Stack Overflow sempre realiza uma pesquisa para obter estatísticas da comunidade de desenvolvedores. E nas tecnologias mais populares, está ela, em primeiro lugar, com uma porcentagem de 69,8%.

O GitHub (site de compartilhamento de código) também diz que o JavaScript é o mais utilizado.

Como podemos ver acima, em segundo aparece a linguagem Python, que veremos a seguir.

JavaScript Básico
Curso de JavaScript Básico
CONHEÇA O CURSO

2) Python

Desde o começo do ano ela era uma das linguagens mais promissoras, e ela ainda está no pódio. O Python é uma linguagem poderosa e que cada vez mais ganha popularidade em meio aos desenvolvedores.

Podendo ser utilizada por uma variedade de tarefas, desde desenvolvimento web, aprendizado de máquina, análise de dados e muitas outras.

Ainda na pesquisa do Stack Overflow, quase 40% dos usuários utilizam Python em seus projetos. E ainda tem mais: segundo o site TIOBE, podemos ver como o Python tem crescido.

Python - Fundamentos
Curso de Python - Fundamentos
CONHEÇA O CURSO

3) Java

Muitas pessoas quando pensam em estudar uma linguagem, já pensam logo no Java. Se você gostar, porque não? Apesar de não ter aparecido como uma das linguagens mais promissoras para este ano, o Java voltou a ser um dos centros a partir de julho/2018.

Como é uma linguagem de programação bem versátil, você pode utilizá-la para diversas finalidades como desktop, web e até mobile. Para tudo isso, o Java atenderá suas necessidades.

Java - Fundamentos
Curso de Java - Fundamentos
CONHEÇA O CURSO

Concluindo

Agora você pode estar se perguntando… “Ok, então eu tenho que escolher uma dessas três linguagens?” e a resposta é: não exatamente…

Por que não aprender as três? Essas são as linguagens mais bem classificadas pelos sites como pudemos ver acima.

Quanto maior o seu conhecimento, tanto na linguagem em si quanto na quantidade, pode abrir um leque de oportunidades. Você pode estudar uma por vez, para poder levar sua carreira a um próximo nível.

Até a próxima! 😊