Python

Retornando páginas HTML em requisições Flask

Sabemos que a principal forma que os usuários possuem para interagir com nossas aplicações web, são utilizando páginas HTML. No Flask, isso não é diferente.

Vimos no artigo anterior como criar nossa primeira app, porém estávamos retornando uma string como resposta de uma requisição. Sendo assim, neste artigo veremos como retornar páginas HTML através dos métodos da nossa aplicação Flask.

Respondendo requisições com HTML

O primeiro passo para retornar uma página HTML como resposta de uma requisição no Flask, é criar o diretório que armazenará estes arquivos. Para isso, criamos um diretório chamado “templates” dentro do projeto. É lá que serão armazenados os arquivos HTML do projeto:



Agora, dentro do diretório “templates”, podemos criar os arquivos HTML do nosso projeto:

Por fim, para retornar a página index.htmlnos métodos do nosso projeto Flask, utilizamos o método render_template(), como podemos ver abaixo:


from flask import Flask, render_template app = Flask(__name__) @app.route("/teste") def index(): return render_template('index.html') if __name__ == "__main__": app.run()
Flask - Fundamentos
Curso de Flask - Fundamentos
CONHEÇA O CURSO

Com isso, ao acessar a rota 127.0.0.1:5000/teste, teremos o seguinte retorno:

Vale lembrar que, por padrão, o Flask irá procurar o arquivo index.htmlno diretório templates do projeto. Caso você queira criá-lo em um diretório com outro nome, você deve passá-lo como parâmetro do construtor do Flask:

from flask import Flask, render_template

app = Flask(__name__, template_folder='templates_folder')

@app.route("/teste")
def index():
  return render_template('index.html')

if __name__ == "__main__":
 app.run()

Isso fará com que todos os templates sejam buscados no diretório templates_folderdo seu projeto (ou qualquer nome que você preferir).

Concluindo…

Como dito acima, as páginas HTML são os principais meios de interação entre um usuário e uma aplicação web. Saber como retorná-las é de extrema importância para qualquer desenvolvedor.

Além disso, o Jinja2 possui diversos recursos para trabalhar com este tipo de arquivo, e é exatamente isso que veremos no próximo artigo desta trilha 🙂

Criando primeira app com Flask

O Flask é um dos principais microframeworks do ecossistema Python e principal concorrente do Django. Já vimos aqui no blog o que é o Flask e quando utilizá-lo ao invés do Django.

Sabendo disso, veremos neste artigo como criar nossa primeira app com Flask e do que vamos precisar para tal tarefa.

Configurando ambiente

Por ser um framework Python, o Flask possui os mesmos requisitos básicos que o Django (possuir o Python instalado e uma IDE para escrever o código). Aqui no blog, já temos um artigo sobre como configurar nosso ambiente de desenvolvimento para o Django, mas que pode ser utilizado para o Flask sem maiores problemas 🙂

Criando Projeto

Com o ambiente de desenvolvimento devidamente configurado, podemos iniciar e criar nossa primeira aplicação com Flask. Para isso, o primeiro passo é criar um projeto com o PyCharm que vai armazenar os arquivos de código da nossa aplicação Flask.

Sendo assim, ao abrir o PyCharm, veremos a seguinte tela:


Dentre as três opções disponíveis, selecionaremos a “Create New Project” para que possamos criar o primeiro projeto com PyCharm. Fazendo isso, seremos redirecionados para a seguinte tela:


Nesta tela, definimos a localização do projeto e onde será armazenada sua virtualenv. Caso você não saiba do que se trata uma virtualenv, falamos sobre ela neste artigo, recomendo fortemente sua leitura 🙂

Costumo armazenar a virtualenv de cada projeto em seu próprio diretório. Assim, cada projeto possuirá sua virtualenv isolada.

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

Por fim, após indicar o caminho e o nome do projeto, podemos clicar em “Create”. Isso fará com que uma nova janela do PyCharm seja aberta com o seguinte conteúdo:

Instalando o Flask

Com o projeto do PyCharm criado, já podemos criar nossa app Flask. Para isso, o primeiro passo é instalar o pacote em nossa virtualenv. Para isso, o PyCharm possui uma interface gráfica que auxilia todo este processo, localizada em File > Settings > Project Interpreter (se você está utilizando o Windows ou Linux) ou PyCharm > Preferences (se você está utilizando o macOS).



É nesta janela que poderemos adicionar os pacotes à nossa virtualenv. Para isso, clicamos no botão “+” localizado no canto inferior esquerdo da janela, que exibirá uma tela para buscarmos pelo pacote desejado.

Nesta janela, buscamos pelo pacote “Flask” e clicamos em “Install Package”. Após isso, o PyCharm (utilizando o PIP) vai baixar o pacote selecionado e instalar na virtualenv do projeto:


Ao finalizar este processo, podemos fechar a janela e notaremos que o pacote foi instalado com sucesso:


Em conjunto com o Flask, outros 4 pacotes serão instalados, são eles:

  • Click: CLI (Command Line Interface) do Flask. Provê diversos comandos para o desenvolvedor interagir com o Flask.

  • Jinja2: Template Engine utilizado pelo Flask para a criação de suas aplicações. O Jinja2 é uma poderosa ferramenta para criação de páginas HTML em conjunto com códigos Python.

  • MarkupSafe: Pacote responsável por criar escapes de caracteres para utilizá-los em HTML e XML, evitando ataques de injeção na aplicação.

  • Werkzeug: Werkzeug é um conjunto de ferramentas para WSGI, a interface padrão entre aplicações web Python e servidores HTTP para desenvolvimento.

Finalmente, podemos clicar em “OK” na aba “Project Interpreter” que todos os pacotes necessários já estão instalados em nosso projeto.

Criando primeira APP Flask

Com todo o ambiente configurado e os pacotes necessários instalados, podemos iniciar o desenvolvimento da nossa aplicação. Neste artigo, veremos uma aplicação que responde a uma requisição e devolve uma string como resposta. Nos próximos artigos veremos como trabalhar com rotas, templates, bancos de dados, etc…

Por ser um microframework, o Flask não possui uma arquitetura definida. Sendo assim, para criar uma app com o Flask, podemos utilizar um único arquivo (claro que isso não pode acontecer com aplicações maiores).

Portanto, dentro do projeto do PyCharm, criaremos um arquivo chamado app.py e colamos o seguinte conteúdo:

from flask import Flask
app = Flask(__name__)

@app.route("/teste")
def index():
    return 'Olá Mundo!'

if __name__ == "__main__":
    app.run()

Linha a linha, o código acima pode ser entendido da seguinte forma:

  1. Importamos o pacote Flask da nossa virtualenv;

  2. Criamos uma instância do Flask e salvamos na variável app. É essa variável que representa a aplicação Flask que estamos criando;

  3. Definimos que a rota “/” vai executar o método index() do nosso arquivo, que retornará a string “Olá Mundo!”;

  4. Verificamos se o arquivo app.pyestá sendo executado pelo terminal e, caso positivo, iniciamos o servidor do Flask.

Agora, para executar nosso script, clicamos no botão verde ao lado da linha 8 do nosso script e selecionamos a opção “Run ‘app'”:

Ao fazer isso, o servidor do Flask será executado no terminal do próprio PyCharm e uma URL para acessá-lo será exibida:

Clicando na rota disponibilizada, o navegador padrão do computador irá abrir e, ao executar a rota “/teste”, teremos o seguinte retorno:

Conclusão

Vimos neste artigo o quão simples é instalar o Flask e criar nossa primeira app. Nos próximos artigos veremos alguns conceitos mais avançados sobre este ótimo microframework, como seu sistema de templates, rotas, bancos de dados, etc. Te espero lá 🙂

Compartilhando rotas entre apps no Django

Um projeto Django é composto por uma ou mais aplicações, que possui um arquivo de rotas. Agora imagine que tenhamos duas apps com rotas de mesmo nome ou que precisamos executar métodos de uma outra app … Como diferenciar cada rota dentro do projeto e como compartilhar as rotas entre as aplicações de um projeto? É o que veremos neste artigo.

Utilizando namespaces no Django

A compartilhação de rotas entre apps no Django é muito simples. A primeira coisa a se fazer é determinar o namespace daquele arquivo de rotas. Este namespace é o que define de onde a rota pertence (a qual app aquela rota foi criada).

Imagine que você tenha um projeto com duas (ou mais) aplicações e que há rotas nessas aplicações que são compartilhadas entre as apps. Para realizar este “compartilhamento”, precisamos definir o nome do namespace de cada arquivo de rotas. É este nome que identificará de onde a rota será chamada.

Para isso, no arquivo urls.py da app que queremos compartilhar as rotas, definimos a seguinte configuração no app_name:

from django.urls import path
from .views import *

app_name = 'admin_blog'

urlpatterns = [
    path('listar_posts/', listar_posts, name='listar_posts'),
    path('editar_post/<int:id>', editar_post, name='editar_post'),
    path('remover_post/<int:id>', remover_post, name='remover_post'),
    path('cadastrar_post/', cadastrar_post, name='cadastrar_post'),

]

É o conteúdo do app_name que determina como chamaremos as rotas externamente.

Django - Desenvolvimento de APIs REST
Curso de Django - Desenvolvimento de APIs REST
CONHEÇA O CURSO

Além disso, precisamos determinar que o conjunto de rotas da app possui o namespace ‘admin_blog’ no arquivo de rotas do projeto:

urlpatterns = [
    path('admin_blog/', include('admin_blog.urls', namespace='admin_blog')),
  #...
]

Invocando rotas em outras apps com Django

Agora que determinamos a configuração do app_name no arquivo de rotas da aplicação, podemos executá-las externamente. Para isso, a nomenclatura é a seguinte:

nome_definido_no_app_name:nome_da_rota

Sendo assim, se quisermos executar a rota ‘listar_posts’, por exemplo, a partir de um template localizado em outra app, definimos a tag url da seguinte forma:

<li class="nav-item">
    <a class="nav-link" href="{% url 'admin_blog:listar_posts' %}">Admin</a>
</li>

Com isso, a rota a ser executada será do método listar_posts que está definido na outra app do projeto.

O que é Flask?

Escrito em Python e disponível sobre a licença BSD (Licença de código aberto), o Flask é um micro-framework multiplataforma que provê um modelo simples para o desenvolvimento web.

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

Mas afinal, o que é um Micro-framework?

Já falamos aqui no blog o que é um micro-framework, mas para relembrar:

Um Micro-Framework são Frameworks modularizados que possuem uma estrutura inicial muito mais simples quando comparado a um Framework convencional.

Podemos dizer que o micro-framework é uma versão minimalista destes frameworks, sendo bastante utilizado para criação de microsserviços, como APIs RESTful.

No artigo anterior, fizemos uma comparação de objetos do mundo real para exemplificar o funcionamento de um micro-framework:

Pense em um Micro-Framework como uma peça de lego. Inicialmente, um projeto criado com o micro-framework possui apenas o básico para funcionar, (normalmente, sistema de rotas), porém, ao decorrer do projeto, podem haver necessidades para utilização de outros recursos como, conexão de banco de dados, sistemas de templates, envio de email, etc. A partir desta necessidade, novas bibliotecas são “encaixadas” no projeto, como uma estrutura de lego.

De volta ao Flask…

Lançado em 2010 e desenvolvido por Armin Ronacher, o Flask é um micro-framework destinado principalmente a pequenas aplicações com requisitos mais simples, como por exemplo, a criação de um site básico.

Possui um núcleo simples e expansível que permite que um projeto possua apenas os recursos necessários para sua execução (conforme surja a necessidade, um novo pacote pode ser adicionado para incrementar as funcionalidades da aplicação).

Características do Flask

  • Simplicidade: Por possuir apenas o necessário para o desenvolvimento de uma aplicação, um projeto escrito com Flask é mais simples se comparado aos frameworks maiores, já que a quantidade de arquivos é muito menor e sua arquitetura é muito mais simples.

  • Rapidez no desenvolvimento: Com o Flask, o desenvolvedor se preocupa em apenas desenvolver o necessário para um projeto, sem a necessidade de realizar configurações que muitas vezes não são utilizadas.

  • Projetos menores: Por possuir uma arquitetura muito simples (um único arquivo inicial) os projetos escritos em Flask tendem a ser menores e mais leves se comparados a frameworks maiores.

  • Aplicações robustas: Apesar de ser um micro-framework, o Flask permite a criação de aplicações robustas, já que é totalmente personalizável, permitindo, caso necessário, a criação de uma arquitetura mais definida.

Exemplo de uma aplicação Flask

Abaixo podemos ver um exemplo de uma aplicação em Flask. Podemos notar o quão simples criar uma aplicação web pode ser:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def index():
    return 'Bem-vindo a TreinaWeb!'

if __name__ == "__main__":
    app.run()

Podemos concluir que…

O Flask é uma excelente alternativa para o desenvolvimento de aplicações utilizando o Python. Ele é o principal concorrente do Django, apesar de ser considerado um micro-framework.

Aqui no blog da TreinaWeb fizemos um comparativo entre o Django e o Flask, caso esteja em dúvida em qual framework utilizar, vale a pena a leitura.

Criando o primeiro projeto Django

No artigo anterior vimos como configurar nosso ambiente de desenvolvimento para a criação de projetos Python e Django. Agora, com o ambiente devidamente configurado, veremos como criar o primeiro projeto Django utilizando as ferramentas instaladas 🙂

Criando projeto

O primeiro passo para criarmos nosso projeto com Django é abrir o PyCharm. Ao fazer isso, veremos a seguinte tela:


Dentre as três opções disponíveis, selecionaremos a “Create New Project” para criar o primeiro projeto do PyCharm. Ao fazer isso, seremos redirecionados para a seguinte tela:


Aqui, definimos a localização do projeto e onde será armazenada a virtualenv do mesmo. Se você não sabe o que é uma virtualenv, recomendo a leitura deste artigo.

Costumo armazenar a virtualenv de cada projeto em seu próprio diretório. Assim, cada projeto possuirá sua virtualenv isolada 🙂

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

Depois de informar a localização do projeto e criar a virtualenv, podemos clicar em “Create” para que o PyCharm crie o diretório do projeto. No fim do processo, será exibida a seguinte tela:

Instalando o Django

Com o projeto do PyCharm criado, o primeiro passo é instalar o Django em nossa virtualenv. Para isso, o PyCharm possui uma interface gráfica que auxilia todo este processo, localizada em File > Settings > Project Interpreter (se você está utilizando o Windows ou Linux) ou PyCharm > Preferences (se você está utilizando o macOS).



É nesta janela que poderemos adicionar os pacotes à nossa virtualenv. Para isso, clicamos no botão “+” localizado no canto inferior esquerdo da janela, que exibirá uma tela para buscarmos pelo pacote desejado:


Nesta janela, buscamos pelo pacote “Django” e clicamos em “Install Package”. Após isso, o PyCharm (utilizando o PIP) vai baixar o pacote selecionado e instalar na virtualenv do projeto. Ao finalizar este processo, podemos fechar a janela e notaremos que o pacote foi instalado com sucesso:


Agora, voltando ao PyCharm, precisamos criar o projeto utilizando o Django. Para isso, no terminal integrado da IDE, digitamos o seguinte comando:

django-admin startproject primeiro_projeto

O comando acima irá criar um projeto Django chamado “primeiro_projeto” com a seguinte estrutura de pastas:


Basicamente, há quatro arquivos no projeto criado, onde a função de cada um deles pode ser vista abaixo:

  • settings.py: Arquivo para armazenar as configurações gerais do projeto, como os pacotes a serem utilizados, configurações de bancos de dados, localização de arquivos estáticos, etc.
  • urls.py: Arquivo para armazenar as rotas que serão utilizadas no projeto. Este arquivo armazenará as rotas do projeto em geral, é recomendável que cada aplicação do projeto possua um arquivo de rotas específico… Mas não se preocupe, falaremos sobre apps no próximo artigo 🙂
  • wsgi.py: Interface simples e universal para troca de informações entre servidores web e aplicações criadas com Python.
  • manage.py: Arquivo responsável por gerenciar o projeto como um todo. É, basicamente, um CLI para projetos Django.

Executando servidor Django

Com o projeto criado, podemos executar seu servidor de desenvolvimento para verificar se tudo está conforme planejado. Para isso, ainda no terminal do PyCharm, utilizamos o seguinte comando:

python manage.py runserver

Ao executar o comando acima, o servidor do Django será inicializado e poderemos acessá-lo através da rota http://127.0.0.1:8000, conforme é retornado no terminal:


Ao executar a rota citada acima em um navegador, teremos a seguinte página como resposta:


Esta (linda) página indica que a instalação foi feita corretamente e que estamos prontos para desenvolver nossa primeira aplicação com o Django o/

Ficou animado? Então fica ligado que no próximo artigo veremos como criar uma aplicação com o Django e iniciarmos seu desenvolvimento 😀

Até lá!!

Configurando ambiente de desenvolvimento para projetos Django

O Django é um ótimo framework para o desenvolvimento de aplicações com um grande reaproveitamento de código e facilidade de aprendizado. Segundo o Stack Overflow Trends, o Django é, atualmente, um dos principais frameworks full stack do mercado, sendo mais pesquisado que o Laravel e Spring. Pensando nisso, veremos neste artigo como dar nossos primeiros passos com o Django e criar nosso primeiro projeto.

O que é o Django?

Já falamos em outro artigo o que é e como funciona o Django. Basicamente, ele é um framework escrito em Python para desenvolvimento de aplicações web muito popular e com uma comunidade incrível. Não vamos entrar em detalhes mais específicos sobre o funcionamento básico do Django, já que isto pode ser visto em um artigo que já escrevemos, caso você tenha alguma dúvida, é extremamente recomendado que o leia antes de iniciar seus estudos com o framework 🙂

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

Ambiente de desenvolvimento

Basicamente, o Django precisa apenas do Python instalado na máquina para que consigamos criar e executar um projeto. Porém, há três outras ferramentas que você deve considerar em seu ambiente de desenvolvimento, como veremos a seguir.

Sendo assim, o primeiro passo é instalar o Python em nossa máquina. Por ser multi-plataforma, o Python funcionará em qualquer sistema operacional que você utilizar (Windows, Linux ou macOS). Seu download pode ser feito na página oficial da ferramenta. Caso você utilize o Linux ou macOS, você já deve possuir o Python instalado em seu computador. Para verificar esta existência, podemos abrir o terminal e ditarmos o seguinte comando:

python --version

Ao executarmos o comando acima, teremos o seguinte retorno:


Lembrando que podem haver duas versões do Python instalados em sua máquina, então você pode especificar a versão que você deseja verificar a instalação (Python 2 ou Python 3).

No Windows, a instalação é simples (next > next > next > finish), tendo apenas que se atentar em marcar a opção de adicionar o Python ao PATH do sistema:

Feito isso, o Python será instalado e configurado automaticamente no Windows.

PIP, PyCharm e Virtualenv

Com o Python instalado, podemos falar das outras três ferramentas que considero essenciais para o desenvolvimento de aplicações Django: o PIP, PyCharm e Virtualenv.

O PIP é, basicamente, um gerenciador de pacotes para projetos Python. Muito utilizado quando precisamos instalar pacotes externos em nossos projetos. Já temos um ótimo artigo sobre como funciona e como instalar o PIP em nosso ambiente. Recomendo, fortemente, a leitura 🙂

Já o PyCharm é a principal IDE para desenvolvimento de aplicações Python do mercado. Desenvolvido pela Jetbrains, o PyCharm é multi-plataforma e possui as versões Professional e Community.


A instalação do PyCharm segue o velho padrão (next > next > finish) e, com certeza, você vai se encantar com todos os recursos dessa IDE no desenvolvimento de suas aplicações.

A última ferramenta é a virtualenv. 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.

Para criar estes ambientes virtuais, podemos utilizar uma virtualenv. Também possuímos aqui no blog um artigo sobre como funciona uma virtualenv no Python e como instalá-la em nossa máquina.

Ambiente configurado, e agora?

Com todas as ferramentas instaladas no computador, já estamos aptos a desenvolver primeiros projetos com o Django. Para isso, veremos no próximo artigo como criar o primeiro projeto com Django e qual a funcionalidade de cada arquivo existente em sua arquitetura 🙂

Até lá!!

Utilizando Choices no Django ORM

Na construção de um formulário, há casos em que precisamos de um campo para armazenar determinadas opções para um atributo. Um exemplo claro deste caso é o armazenamento do sexo de um usuário, que só deve permitir uma determinada lista de opções (masculino, feminino, outro).
Para estes casos, o Django ORM permite que criemos uma lista com as possíveis opções que deverão ser selecionadas, evitando que o usuário possa digitar qualquer valor naquele campo.
Sendo assim, neste artigo veremos como trabalhar com choices no Django ORM.

Criando choices no models.py

Para criar uma lista de possíveis opções no Django ORM, precisamos definir quais serão estas opções e a qual chave ela pertence. Por exemplo, se quisermos criar uma lista de opções para o campo sexo, determinamos o seguinte conteúdo no arquivo models.py do nosso projeto:

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)
    sexo = models.CharField(max_length=1, choices=SEXO_CHOICES, blank=False, null=False)
    data_nascimento = models.DateField(null=False, blank=False)
    email = models.EmailField(null=False, blank=False)


    def __str__(self):
        return self.nome
Django - Banco de dados com Django ORM - Parte 1
Curso de Django - Banco de dados com Django ORM - Parte 1
CONHEÇA O CURSO

Note que precisamos criar a variável SEXO_CHOICES e determinar quais as opções que um sexo poderá exercer. Depois disso, criamos o campo sexo em nosso model e determinamos que as opções disponíveis para este campo estão definidas na variável SEXO_CHOICES. Com isso, sempre que o formulário para cadastro (ou edição) de um cliente for submetido, o Django irá verificar se uma das opções foi selecionada. Caso positivo, libera a requisição, caso negativo, alerta ao usuário que apenas estas opções são permitidas a serem selecionadas.

Um outro ponto positivo para o uso do choices é que só precisamos armazenar a chave que irá identificar cada sexo, assim, economizamos um certo espaço no banco de dados, já que só será necessário armazenar um caractere (F, M ou N), não o nome do sexo (Feminino, Masculino ou Nenhuma das opções).

O que é o SQLAlchemy?

Desenvolvido para a linguagem de programação Python, o SQLAlchemy é um framework de mapeamento objeto-relacional SQL (ORM) de código aberto sobre a licença MIT.

Mas afinal, o que é o ORM?

Mapeamento objeto-relacional ou simplesmente ORM é uma técnica de programação que auxilia na conversão de dados entre banco de dados relacionais e linguagens de programação que são orientadas à objetos.

A utilização deste Framework faz com que o programador reduza a programação de acesso ao banco de dados, desta forma, obtendo uma produtividade significativa no desenvolvimento de suas aplicações.

Ou seja, ORM trata-se de um Framework que visa auxiliar na redução da impedância, realizando todas as conversões necessárias entre o modelo relacional e o modelo orientado a objetos de maneira automática, geralmente da seguinte forma:

  • Cada classe é interpretada com uma tabela;
  • Cada linha de uma determinada tabela, junto com seu relacionamento é tratada como instância do objeto relacionado à tabela em questão.

Sua utilização também visa retirar a necessidade do desenvolvedor de software em se preocupar com a linguagem SQL (geração dos comandos SQL) e com as conversões necessárias entre os diferentes tipos de dados, já que tudo isto fica a cargo do Framework ORM.

Conseguimos utilizar banco de dados relacionais por meio de objetos escritos em Python, não se preocupando em como este BD está funcionando (relações, campos, etc), apenas mapeando sua estrutura.

Python - SQLAlchemy ORM
Curso de Python - SQLAlchemy ORM
CONHEÇA O CURSO

Voltando ao SQLAlchemy…

Lançado em fevereiro de 2006 tendo como autor Michael Bayer, o SQLAlchemy encontra-se na versão 1.3.6 liberada em 21 de julho de 2019. É um Framework multiplataforma que rapidamente se tornou umas das ferramentas de mapeamento objeto-relacional mais utilizada na comunidade Python, linguagem para qual foi desenvolvida.

O SQLAlchemy é um ORM completo, criado com Python para desenvolvedores de aplicativos, que fornece flexibilidade total do SQL, obtendo um conjunto completo de padrões de persistência de nível corporativo bem conhecidos, que são projetados para acesso a banco de dados eficientes e de alto desempenho.

Com ele, o desenvolvedor não necessita se preocupar com a utilização de códigos SQL no desenvolvimento de aplicações, já que todo acesso ao banco de dados é feito utilizando código Python.

Além disso, o SQLAlchemy possui todas as garantias de segurança necessárias para proteger as aplicações de ataques ao seus bancos de dados, garantindo, assim, a criação de aplicativos simples e seguros.

Aqui no blog possuímos um artigo sobre “Principais tipos de ataques a aplicações web”.

Exemplos de consultas com SQLAlchemy

Como dito anteriormente, com o SQLAlchemy não precisamos nos preocupar com a criação de códigos SQL, já que tudo é feito inteiramente utilizando Python tornando, assim, a aplicação mais simples, como podemos ver nos exemplos abaixo:

Consulta de dados:

alldata = session.query(Filme).all()

O código acima pode ser convertido na seguinte instrução SQL:

SELECT * FROM Filme

Inserção de dados:

f1 = Filme("Star Trek", 2009)
session.add(f1)

O código acima pode ser convertido na seguinte instrução SQL:

INSERT INTO Filme (nome, ano) VALUES ("Star Trek", 2009)

Com isso, podemos ver o quão simples e legível se torna nosso código, não misturando comandos SQL com código Python e mantendo a leitura muito mais eficiente.

Para maiores informações sobre sua documentação, download e notícias sobre o SQLAlchemy, basta acessar seu site.

Personalizando a chave primária no Django ORM

Por padrão, o ORM do Django cria, para cada tabela, um campo chamado id e é ele quem identifica, unicamente, os registros no banco de dados. Porém, muitas vezes, precisamos que este campo possua outro nome (ou até outro tipo)… E é isso que veremos neste artigo.

Django - Banco de dados com Django ORM - Parte 1
Curso de Django - Banco de dados com Django ORM - Parte 1
CONHEÇA O CURSO

Alterando nome e tipo da chave primária no Django ORM

Como exemplo para este artigo, vamos utilizar um model simples, com apenas alguns campos, conforme podemos ver abaixo:

class Pessoa(models.Model):
    nome = models.CharField(max_length=40, null=False, blank=False)
    email = models.EmailField(null=False, blank=False)

    def __str__(self):
        return self.nome

Ao realizar a migração, a seguinte estrutura será criada no banco de dados:

Podemos notar que, apesar de não definir nenhum campo com o nome id, o Django o criou automaticamente. Por padrão, este campo é do tipo int(11), não permite dados nulos e é utilizado para armazenar a chave primária da tabela. Porém, caso necessário, podemos alterar a estrutura deste campo facilmente utilizando o Django.

Para isso, a única coisa que precisamos fazer é criar um campo que será utilizado como primary_key no model do nosso projeto, como podemos ver abaixo:

class Pessoa(models.Model):
    id_personalizado = models.CharField(max_length=20, primary_key=True)
    nome = models.CharField(max_length=40, null=False, blank=False)
    email = models.EmailField(null=False, blank=False)

    def __str__(self):
        return self.nome

Sendo assim, podemos notar que a única coisa necessária para alterar a chave primária de uma tabela é determinar o atributo primary_key=True e, com isso, este campo será utilizado como chave primária no banco de dados:

Concluindo

Apesar de possuir diversas configurações padrões, o ORM do Django permite a personalização de várias delas. Neste artigo vimos o quão simples é alterar o nome da chave primária de um determinado model.

Enviando email com Python e SMTP

O envio de emails é a melhor forma para se comunicar com os usuários de uma aplicação. Além de ser gratuito (na maioria das vezes), é seguro e muito utilizado em todo o mundo.

Pensando nisso, veremos neste artigo como enviar e-mails em aplicações Python utilizando SMTP.

Configurando servidor gmail

Em nosso exemplo, veremos como enviar um email utilizando o serviço do gmail (pois ele é o mais utilizado no mundo). Porém, antes de iniciar o desenvolvimento do nosso projeto, precisamos criar um token para ser utilizado como password, caso você utilize o recurso de autenticação em duas etapas (recurso que só permite que seu usuário seja autenticado caso você o libere em seu smartphone) ou não quer que sua senha seja utilizada em aplicações não seguras.

Criando token

Para criar um token que será utilizado como senha em nossa aplicação, precisamos ir até o seguinte link: https://security.google.com/settings/security/apppasswords.

Na página, vamos selecionar a opção “Outro” para definir um nome para nosso projeto. Em seguida, determinamos o nome da aplicação e geramos o token:

Ao clicar em “GERAR”, seremos redirecionados para a tela de login da nossa conta. Ao inserir o email e senha, clicamos em “Próxima” e nosso token será gerado com sucesso:

É essa “senha de app” que vamos utilizar para autenticar com nosso gmail na aplicação (lembre-se de copiá-la).

Criando script para envio de email

Nosso script será bem simples. Basicamente, vamos informar o email e senha (conforme gerada no tópico anterior) da conta que será usada para enviar o email, o destinatário e o conteúdo do email. Sendo assim, o código final será o seguinte:

import smtplib

server = smtplib.SMTP_SSL('smtp.gmail.com', 465)
server.login("seu_email@gmail.com", "senha_gerada_topico_anterior")
server.sendmail(
  "remetente@gmail.com",
  "destinatario@gmail.com",
  "Conteúdo da mensagem")
server.quit()

Basicamente, o código acima irá criar uma conexão com o serviço de SMTP do gmail por meio da porta 456, realizar o login com as credenciais do usuário e enviar o email conforme os parâmetros enviados pelo método sendmail(). Ao concluir o processo, finalizamos o servidor e o email deve chegar no destinatário.

Sendo assim, ao executar o código acima (você pode utilizar qualquer editor de texto, IDE ou terminal), o email será enviado com sucesso, chegando até o destinatário:

Conclusão

Neste artigo vimos o quão simples é enviar um email utilizando Python. Claro que há várias melhorias que podemos fazer (adicionar o assunto do email, enviar um código HTML como conteúdo do email), mas isso nós veremos em um outro artigo 🙂