Posts da Tag: Flask - Blog da TreinaWeb

Flask

Como herdar templates com Jinja2

É comum que tenhamos diversas páginas que, muitas vezes, possui muitas características semelhantes entre elas, seja uma barra de navegação, arquivos de css e js, etc. Para compartilhar essas informações entre diferentes páginas, utilizamos o conceito de herança em nossos templates. Sendo assim, neste artigo veremos como herdar templates com Jinja2.

Criando template base

O primeiro passo para reaproveitar a base de um template utilizando a herança no Jinja2 é criar o template base. É este template que vai definir toda a estrutura base que os outros templates irão herdar.

Para isso, vamos criar um template chamado base.html em nossa aplicação Flask com o seguinte conteúdo:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>Listagem</h1>
    {% block conteudo %}

    {% endblock conteudo %}
</body>
</html>

Dentro da tag body temos o que chamamos de blocos de conteúdo. São nestes blocos que adicionaremos os conteúdos das páginas que herdarão a página base.

Flask -  Templates com Jinja2
Curso de Flask - Templates com Jinja2
CONHEÇA O CURSO

Vale lembrar que podemos criar quantas tags forem necessárias, desde que possuam nomes diferentes para que possamos referenciá-las nos templates filhos.

Herdando o template base

Agora que já possuímos nosso template base, estamos prontos para herdá-lo e, assim, reaproveitar boa parte do código HTML nas páginas filhas do nosso projeto.

Para isso, é muito simples, basta definir qual o nome do template a ser herdado e qual conteúdo será inserido nos blocos definidos anteriormente.

Para exemplificar, teremos dois templates, um para listagem de funcionários e outro para listagem de clientes e seu código é bem similar, como podemos ver abaixo:

{% extends 'base.html' %}

{% block conteudo %}
    {% for cliente in clientes %}
        <h1>{{cliente}}</h1>
    {% endfor %}
{% endblock conteudo %}
{% extends 'base.html' %}

{% block conteudo %}
    {% for funcionario in funcionarios %}
        <h1>{{funcionario}}</h1>
    {% endfor %}
{% endblock conteudo %}

Basicamente, estamos definindo que estes arquivos herdarão do arquivo base.html criado anteriormente e, no bloco conteúdo, iremos adicionar as informações relativas às páginas em questão.

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

Isso faz com que não precisemos, por exemplo, escrever toda a estrutura padrão de uma página HTML, apenas o conteúdo das páginas.

Com isso, criamos duas rotas para acessar as páginas com seus dados em questão, como podemos ver abaixo:

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/clientes")
def clientes():
    clientes = ["Cliente João da Silva", "Cliente Maria da Silva", "Cliente Joana da Silva",
                "Cliente Pedro da Silva", "Cliente José da Silva"]
    return render_template('clientes.html', clientes=clientes)

@app.route("/funcionarios")
def funcionarios():
    funcionarios = ["Funcionario João da Silva", "Funcionario Maria da Silva", "Funcionario Joana da Silva",
                "Funcionario Pedro da Silva", "Funcionario José da Silva"]
    return render_template('funcionarios.html', funcionarios=funcionarios)

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

Agora, ao acessar as rotas /clientes e /funcionarios, teremos o seguinte resultado:

Listagem de clientes

Listagem de funcionários

Toda a estrutura da página HTML criada no template base foi herdado, inclusive a string “Listagem” e apenas o conteúdo das páginas em questão foram alterados.

Agora, para cada página que precisemos criar, basta herdá-la do arquivo base.html e, assim, aproveitar toda a estrutura já pronta.


Flask

Utilizando estruturas de condição e repetição no Jinja2

Vimos no último artigo dessa série como enviar e exibir variáveis Python em templates com o Jinja2. Continuando a série, agora veremos como utilizar estruturas de condição e repetição no Jinja2.

Estruturas de condição

Para utilizar estruturas de condição no Jinja2 é bem simples. Imagine que temos, em uma variável, a representação de um usuário com seu ID, nome e tipo do usuário (cliente ou funcionário) e queremos exibir em um template a frase “bem-vindo cliente” ou “bem-vindo funcionário” a depender do seu tipo.

Este é um exemplo claro do uso de estruturas condicionais e no Jinja2 este processo é muito simples, como poderemos ver abaixo:

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/teste")
def index():
    usuario = [1, "João da Silva", "funcionario"]
    return render_template('index.html', usuario=usuario)

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

Ao enviar a variável usuario para o template index.html, agora só é preciso verificar o valor na posição 2 da lista e, assim, verificar seu tipo no Jinja2:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {% if usuario[2] == "cliente" %}
        Bem-vindo cliente
    {% else %}
        Bem-vindo funcionário
    {% endif %}
</body>
</html>

Agora, ao acessar o template index.html no navegador, teremos o seguinte resultado:

Utilizando estruturas de condição no Jinja2

A sintaxe das estruturas de condição no Jinja2 é bem simples, basta declarar o comando entre {% %} e, ao finalizar a estrutura, declarar um {% endif %}.

Estrutura de repetição

O uso de estruturas de repetição também é algo muito simples no Jinja2. Imagine que temos uma lista de nomes de funcionários e queremos percorrê-la para exibir em nossa página.

Flask -  Templates com Jinja2
Curso de Flask - Templates com Jinja2
CONHEÇA O CURSO

Para isso, basta utilizar um for e percorrer toda a lista exibindo os nomes como podemos ver abaixo:

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/teste")
def index():
    usuarios = ["João da Silva", "Maria da Silva", "Joana da Silva",
                "Pedro da Silva", "José da Silva"]
    return render_template('index.html', usuarios=usuarios)

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

Agora, para exibir o conteúdo da variável usuarios no template, utilizamos a seguinte sintaxe:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {% for usuario in usuarios %}
        <h1>{{usuario}}</h1>
    {% endfor %}
</body>
</html>

Agora, ao acessar o template index.html no navegador, teremos o seguinte resultado:

Estruturas de repetição no Jinja2

As estruturas de repetição facilitam (e muito) quando precisamos exibir diversos dados e não queremos duplicidade de código, já que uma lista será percorrida e, para cada elemento, será impresso seu valor.

Conclusão

Como vimos neste artigo, o uso de estruturas de condição e repetição no Jinja2 é bem simples e facilita (e muito) a criação dos templates em uma aplicação Flask.


Flask

Como enviar e exibir dados em templates com Jinja2

No último artigo, vimos o que é e o quão fantástico é a template engine Jinja2. Vimos que ela facilita (e muito) nosso trabalho quando precisamos criar templates para aplicações Python. Dando continuidade à nossa série de artigos sobre o Jinja2, agora veremos como enviar e exibir dados com Jinja2 em aplicações Flask.

Aplicação base

Vamos utilizar como base a aplicação vista no artigo que explica como retornar páginas HTML em aplicações Flask. É uma aplicação simples que recebe uma requisição e devolve como resposta uma página HTML, todo o processo de criação pode ser visto no artigo citado.

Enviando dados

Agora que já sabemos como retornar arquivos HTML em aplicações Flask, vamos entender como enviar dados para serem exibidos nestes templates.

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

Para isso, basta enviar a variável que queremos como podemos ver no código abaixo:

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/teste")
def index():
    nome_da_variavel = "Treinaweb"
    return render_template('index.html', variavel=nome_da_variavel)

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

Como visto acima, para enviar uma variável para um template, basta adicioná-la como parâmetro do método render_template.

Exibindo dados no template

Agora que já sabemos como enviar variáveis para nossos templates, precisamos exibir as informações. Para isso, basta acessar a variável no template da seguinte forma:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>Olá {{variavel}}</h1>

</body>
</html>

Para exibir o valor de uma variável, basta adicioná-la entre chaves duplas {{}}. Com isso, ao acessar a rota /teste teremos o seguinte resultado:

Exibindo dados no template

Flask -  Templates com Jinja2
Curso de Flask - Templates com Jinja2
CONHEÇA O CURSO

Vale lembrar que podemos enviar qualquer tipo de variável, seja uma lista, tupla, etc, como podemos ver abaixo:

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/teste")
def index():
    nome_da_variavel = [1, "Treinaweb"]
    return render_template('index.html', variavel=nome_da_variavel)

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

Para exibir as informações, basta acessar pela posição, como podemos ver abaixo:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>Olá {{variavel[0]}} {{variavel[1]}}</h1>

</body>
</html>

Conclusão

Neste artigo, vimo como enviar e exibir dados com Jinja2, recurso que facilita (e muito) o desenvolvimento dos nossos templates. No próximo artigo dessa série, veremos como utilizar estruturas de repetição e condição.


Python

O que é o Jinja2?

O Jinja2 é um template engine escrito em Python que facilita a criação de páginas HTML em aplicações Python. Basicamente, ele serve para permitir que as informações trocadas entre uma aplicação escrita em Python e suas páginas HTML seja feita de forma mais simples e intuitiva, garantindo que o desenvolvedor consiga criar templates de forma mais fácil para suas aplicações.

Características

A principal funcionalidade de um template engine é permitir que linguagens de programação possam ser incorporadas em páginas HTML.
Com isso, uma template engine permite que os programadores possam utilizar estruturas de condição, estruturas de repetição, herança e diversos outros recursos presentes apenas nas linguagens de programação em páginas HTML.

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

Com o Jinja2 isso não é diferente, essa template engine permite incorporar código Python em páginas HTML e, mais do que isso, utilizar as principais características da linguagem em seus templates.
Dentre diversas características, podemos citar as principais:

  • Permite o uso de estruturas de condição e repetição em páginas HTML;
  • Com o Jinja2 é possível utilizar herança de layouts, garantindo uma estrutura com o maior reaproveitamento de código possível;
  • Permite exibir o conteúdo de variáveis Python em páginas HTML;
  • Sistema de blocos de templates, dentre outros.

Como funciona o Jinja2

Basicamente, quando criamos um template com Jinja2 e incorporamos código Python nas páginas HTML, a própria ferramenta traduz o código Python e incorpora à página HTML, já que o Browser não consegue exibir código diferente do HTML.

Sendo assim, um código utilizando o Jinja2 como podemos ver abaixo é convertido em um HTML:

<ul>
{% for user in users %}
  <li><a href="{{ user.url }}">{{ user.username }}</a></li>
{% endfor %}
</ul>
<ul>
    <li><a href="http://url_da_pagina/1"> João </a></li>
    <li><a href="http://url_da_pagina/2"> Maria </a></li>
    <li><a href="http://url_da_pagina/3"> José </a></li>
    <li><a href="http://url_da_pagina/4"> Neuza </a></li>
    <li><a href="http://url_da_pagina/5"> Geraldo </a></li>
</ul>

Com isso, podemos notar o quão poderosa é essa ferramenta. Com ela podemos utilizar os principais recursos das linguagens de programação para a criação de páginas HTML.

Quem utiliza?

O Jinja2 é muito utilizada em todo ecossistema Python, tendo seu principal “cliente” o Flask, um dos maiores frameworks do mundo.
Ele é incorporado ao Flask por padrão, o que o torna seu principal sistema de templates, permitindo a criação de páginas HTML em conjunto com os recursos do Python.

Flask -  Templates com Jinja2
Curso de Flask - Templates com Jinja2
CONHEÇA O CURSO

Sendo assim, sempre que você criar uma nova aplicação com Flask, por padrão, está utilizando o Jinja2.

Conclusão

Como vimos neste artigo, o Jinja2 é um ótimo template engine e que permite a criação de páginas HTML utilizando os principais recursos do Python.
Agora que vimos o que é e os principais recursos do Jinja2, no próximo artigo exploraremos alguns destes recursos para incrementar o front-end da aplicação.


Python

Conheça o Pyramid, Framework Python para desenvolvimento web

A linguagem de programação Python possui os Frameworks Django e Flask para desenvolvimento web, mas eles não são os únicos, sendo assim, neste artigo falaremos sobre o Pyramid Framework.

Criado por Guido Van Rossum em meados dos anos 90, o Python é uma linguagem de programação de alto nível, multiplataforma e open source. É uma linguagem que ganhou destaque nos últimos anos por possuir uma ótima curva de aprendizagem, ser uma linguagem leve e ter se tornado uma das principais linguagem para o desenvolvimento de IA, Machine Learning e Big Data, áreas em grande crescimento nos últimos anos.

O Pyramid é um Framework multiplataforma, escrito em Python, que foi lançado em novembro de 2010 para o desenvolvimento web, priorizando a flexibilidade e permitindo ao desenvolvedor a utilização de ferramentas certas para o seu projeto.

Relembrando Framework

Aqui no blog já possuímos um artigo que aborda “Para que serve um Framework”, mas em palavras mais simples, 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.

Possui 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.

De volta ao Pyramid

O Pyramid Framework funciona em todas as versões suportadas do Python, tornando mais fácil desenvolver aplicações web. Ao decorrer do desenvolvimento da aplicação, é normal que a complexidade aumente, por isso o Pyramid oferece diversos recursos para que esta complexidade se torne cada vez menor.

O Pyramid é um Framework projetado para usar qualquer camada de persistência, como, por exemplo o ORM SQLAlchemy ou Storm e possui uma excelente documentação.

Características do Pyramid

Diversas são as características do Pyramid Framework, dentre elas podemos citar:

  • Multiplataforma;
  • Independente de camada de acesso a dados;
  • Possui uma excelente documentação;
  • Possui sistema de rotas;
  • Open source;
  • Suporte a integração de pacotes de terceiros;
  • Suporte a testes unitários;
  • Configurações do projeto com arquivos .ini, entre outros.

Exemplo de uma aplicação Pyramid

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

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response


def hello_world(request):
    return Response('Hello World!') #Retorna um HTML com a mensagem "Hello Wold"


if __name__ == '__main__':
    with Configurator() as config:
        config.add_route('hello', '/') #Adiciona a rota "/" e atrela à view `hello`.
        config.add_view(hello_world, route_name='hello') #Executa a view `hello_wold` quando a rota `hello` é adicionada
        app = config.make_wsgi_app() #Define que a app é do tipo wsgi
    server = make_server('0.0.0.0', 6543, app) # Criando o servidor na porta 6543
    server.serve_forever() #Determina que o server vai rodar até ser interrompido

O código acima criará uma aplicação que retorna um simples “Hello World” quando a rota “/” for executada no navegador.

Podemos perceber que em poucas linhas uma aplicação Pyramid é criada, demonstrando o poder e a flexibilidade do framework.

Podemos então concluir:

Como vimos neste artigo, o Pyramid é um ótimo Framework Python. Poderoso e altamente personalizável, possui uma ótima documentação e, apesar de não ser tão conhecido quanto seus “irmãos mais velhos”, é uma ótima alternativa para utilizar em seus projetos.

No site do Pyramid Framework podemos encontrar toda a sua documentação, comunidade e as principais bibliotecas de terceiros para integrar ao Framework.


Flask Python

Utilizando arquivos estáticos no Flask

No último artigo dessa trilha, vimos como retornar páginas HTML em requisições Flask e, assim, melhorar a interação da nossa aplicação com seu usuário. Porém, normalmente, há o uso de arquivos estáticos (JS, CSS e IMG) para melhorar a aparência das nossas páginas e, consequentemente, a experiência do usuário. Sendo assim, veremos neste artigo como incorporar estes arquivos ao nosso projeto Flask.

Criando diretório dos arquivos estáticos

É uma boa prática adotada pela comunidade que todos os arquivos estáticos de uma aplicação Flask sejam armazenados em um diretório “static” na raiz do projeto e, dentro deste diretório, uma nova pasta contendo os tipos de arquivos estáticos (CSS, JS e IMG), como podemos ver abaixo:


Para este projeto, iremos usar o Bootstrap como CSS. Para isso, realizamos o download do arquivo .min.css do framework (https://getbootstrap.com/docs/4.3/getting-started/download/) e armazenamos no diretório “static/css”, como vimos na imagem acima.

Ao realizar este procedimento, o Flask já estará apto a utilizar este arquivo CSS no projeto, bastando apenas importá-lo em nosso template.

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

Utilizando arquivos estáticos no template

Agora que já configuramos nosso projeto para armazenar arquivos estáticos, precisamos importá-lo em nosso template. Para isso, é muito simples. O primeiro passo é criar uma tag link no head do arquivo HTML e referenciar nosso arquivo bootstrap.min.css:

Agora, no href do link, indicamos onde se encontra o arquivo estático que queremos utilizar. No nosso caso, ele se encontra em static/css/bootstrap.min.css. Sendo assim, temos que passar, como primeiro parâmetro do método url_for, o diretório raiz dos arquivos estáticos. Após isso, informamos o restante do caminho até o arquivo no atributo filename, como vemos acima.

Agora, já estamos aptos a usar o arquivo do bootstrap em nossos templates e, com isso, personalizar nossas páginas HTML. Utilizando como base o tema Jumbotron do bootstrap, conseguimos criar uma página com todo o poder do framework:

Concluindo

A utilização de arquivos estáticos em projetos Flask é, realmente, muito simples. Apenas precisamos criar um diretório para comportar estes arquivos e importá-los em nossos templates utilizando o método url_for do Jinja2.

Porém, sabemos que o conteúdo de uma página HTML nem sempre é estático. Muitas vezes este conteúdo é enviado pela requisição e exibido no HTML… Bom, como fazer isso? É exatamente o que veremos no próximo artigo desta série 🙂


Flask 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 🙂


Flask Python

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á 🙂


Flask Python

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.

Imagem com analogia do micro-framewor ao lego

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

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.

Desenvolvedor Flask Full-Stack
Formação: Desenvolvedor Flask Full-Stack
Aprenda nesta formação como desenvolver aplicações complexas utilizando o Flask, um dos principais framework para desenvolvimento de todo o ecossistema Python. Para isso, você verá desde os conceitos mais básicos, até conceitos mais avançados, como validação de formulários e como integrar o SQLAlchemy com o Flask.
CONHEÇA A FORMAÇÃO

Desenvolvimento Flask PHP

O que é um Micro-Framework?

Os Frameworks são ótimas alternativas para nos auxiliar no desenvolvimento das nossas aplicações. Porém, muitas vezes os Frameworks possuem uma quantidade muito grande de recursos que, no fim, podem não ser utilizados em determinados projetos, causando um gasto desnecessário de recursos nos servidores.

Para estes casos, o uso de um Micro-Framework pode ser mais adequado. Mas você sabe o que é um Micro-Framework?

Definição

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

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 um LEGO.

Exemplos de Micro-Frameworks

Slim

Logo Slim

O Slim é um Micro-Framework PHP que permite criar com facilidade aplicações e APIs de pequeno e médio porte, de forma simples e rápida, mantendo a organização e as melhores práticas do mercado.

Slim - Microframework PHP
Curso de Slim - Microframework PHP
CONHEÇA O CURSO

Flask

logo Flask

O Flask é um micro-framework escrito em Python para criação de aplicações web e APIs RESTful. Possui um núcleo simples e entendível que permite que um projeto possua apenas os recursos necessários para sua execução.

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

Comparativo

Para entendermos de vez a diferença entre Framework e Micro-Framework na prática, possuímos aqui no blog um artigo bem legal a respeito: Django ou Flask, eis a questão.
Desta forma, este comparativo pode te ajudar a esclarecer de vez a diferença entre os dois conceitos e te auxiliar na escolha do melhor para o seu projeto.


Django Flask Python

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.