Flask Python é uma alternativa gratuita e versátil na criação de aplicações WEB que pretendam rodar em servidores com poucos recursos. Por ser bastante simples, acaba se tornando a melhor escolha mesmo para programadores que não têm tanto conhecimento nessa linguagem específica.
A variedade de criação é bastante ampla, por isso, fornece liberdade ao programador para trabalhar com o design da sua aplicação fora do Flask, sem comprometer seu funcionamento.
Nesse artigo você irá lidar com exemplos práticos e formas de usar o Flask nas suas criações.
Conteúdo
O que é o Flask Python?
A sua definição é de um framework leve para desenvolvimento web em Python. Ele é projetado para ser simples e fácil de usar, enquanto fornece flexibilidade e extensibilidade para criar aplicativos web.
Também considerado um microframework, o que significa que ele não possui um conjunto de ferramentas ou bibliotecas específicas para tarefas como autenticação de usuário ou manipulação de formulários.
Ainda assim, o Flask é altamente modular e permite que você escolha as extensões adequadas para adicionar funcionalidades específicas ao seu aplicativo.
É possível criar aplicativos web de forma rápida e eficiente, desde pequenas aplicações até sistemas mais complexos.
Ele segue o padrão MVC (Model-View-Controller), que seria um padrão de arquitetura de software que separa uma aplicação web em três partes principais:
- Model: o modelo é responsável por gerenciar os dados da aplicação.
- View: a visualização é responsável por renderizar a interface do usuário da aplicação.
- Controller: o controlador é responsável por receber as entradas do usuário e atualizar o modelo e a visualização de acordo.
Padrão MVC
O padrão MVC é uma abordagem popular para o desenvolvimento porque é fácil de entender e usar, tal qual o Flesk em si.
Observe esse padrão numa aplicação que exibe lista de produtos, para compreender o código na prática:
# Modelo
class Produto(object):
def __init__(self, id, nome, preco):
self.id = id
self.nome = nome
self.preco = preco
# Lista de modelo
class ProdutoModelo(object):
def obter_produto(self, id):
# Implementação simulada para retornar o produto com base no ID
produtos = {
1: Produto(1, 'Produto 1', 100.0),
2: Produto(2, 'Produto 2', 150.0),
3: Produto(3, 'Produto 3', 200.0)
}
return produtos.get(id)
# View
class VisualizacaoProduto(object):
def __init__(self, produto):
self.produto = produto
def renderizar(self):
return """
<html>
<head>
<title>Produto</title>
</head>
<body>
<h1>Produto</h1>
<p>Nome: {nome}</p>
<p>Preço: {preco}</p>
</body>
</html>
""".format(nome=self.produto.nome, preco=self.produto.preco)
# Controlador
class ControladorProduto(object):
def __init__(self, modelo, visao):
self.modelo = modelo
self.visao = visao
def obter_produto(self, id):
produto = self.modelo.obter_produto(id)
self.visao.produto = produto
print(self.visao.renderizar())
# Função principal
if __name__ == "__main__":
modelo = ProdutoModelo()
# Criando um objeto Produto com ID 1 para visualização
for produto_id in range(1, 4): # Assuming there are products with IDs 1, 2, and 3
produto = modelo.obter_produto(produto_id)
visao = VisualizacaoProduto(produto) # Passando o objeto Produto como argumento
controlador = ControladorProduto(modelo, visao)
controlador.obter_produto(produto_id)Saída:
Rotas e templates
O Flask oferece um mecanismo de roteamento para direcionar as solicitações do usuário para funções específicas, chamadas de “rotas”. Essas rotas são definidas de forma simples usando decoradores para mapear URLs a funções no código.
Além disso, o Flask possui suporte embutido para renderizar templates HTML, permitindo a criação de páginas web dinâmicas. Isso facilita a separação da lógica de negócios do design da interface do usuário.
Por esses e outros motivos, muitos desenvolvedores apreciam a sua abordagem minimalista, que permite construir aplicativos web de forma mais direta e personalizada.
É comum compará-lo a outros frameworks, como Django, por exemplo, que tem mais recursos integrados e uma abordagem mais ampla.
Ainda assim, o Flask é especialmente adequado para projetos menores, como aplicativos web mais simples e APIs RESTful.
Dessa forma, é apreciado por desenvolvedores que desejam ter mais controle sobre o processo de desenvolvimento web, optando por componentes específicos conforme necessário, em vez de uma estrutura mais robusta e completa.
Por que usar o Flask Python?
Daremos 7 motivos válidos para usar Flask na criação de seus aplicativos:
- Ele é um microframework web gratuito e de código aberto, utilizado por empresas de todos os tamanhos, isso significa que consegue abranger diversas necessidades;
- O Flask é conhecido por sua leveza e flexibilidade, permitindo criar uma ampla gama de aplicativos web;
- Ele é leve e rápido, executando facilmente em servidores com recursos limitados;
- É fácil de aprender e usar, com uma sintaxe simples e intuitiva, adequada mesmo para desenvolvedores não familiarizados com Python;
- A grande comunidade de usuários e desenvolvedores do Flask tem recursos preciosos para aprender e usar sua estrutura;
- O Flask difere de outras aplicações por ser um microframework que oferece apenas as funcionalidades básicas, permitindo maior controle sobre o design do aplicativo;
- Recursos adicionais, como tutoriais, documentação e fóruns de discussão para suporte no uso do Flask, todos criados pela ampla comunidade.
Como instalar e usar o Flask Python?
Comece com a instalação do Python, através do site oficial e segundo o sistema operacional em que irá trabalhar. Usando um terminal, digite o comando abaixo:
$ pip install FlaskCriar um aplicativo Flask simples: exemplos práticos
Para ilustrar como uma API se parece em Flask, usamos o código abaixo (aplicação mínima):
from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello_world():
return "<p>Hello, World!</p>"O decorator @app.route("/") é usado para decorar a estrutura de outras classes e funções. Assim, ele injeta a função que inicializa um socket de comunicação, seguindo o padrão REST, quando o argumento da rota é passado.
Primeiramente, importamos a classe Flask, que servirá como a base do nosso aplicativo WSGI.
Em seguida, criamos uma instância dessa classe, passando o nome do módulo ou pacote do aplicativo como argumento. É uma prática comum usar "name" para isso, permitindo que o Flask localize recursos importantes, como modelos e arquivos estáticos.
Então, utilizamos o decorador "route()" para informar ao Flask qual URL deve acionar a função que definiremos.
A função em questão retorna a mensagem que desejamos exibir no navegador do usuário. O navegador renderiza o HTML contido na string, pois o tipo de conteúdo é HTML por padrão.
É fundamental salvar esse arquivo com o nome "hello.py" ou algo semelhante, evitando assim chamá-lo de "flask.py", pois isso entraria em conflito com o próprio Flask.
Aplicação com 3 rotas e padrão REST (GET, POST, PUT, DELETE)
from flask import Flask, jsonify, request
app = Flask(__name__)
# Dados de exemplo (simulando um banco de dados)
books = [
{
'id': 1,
'title': 'Livro 1',
'author': 'Autor 1'
},
{
'id': 2,
'title': 'Livro 2',
'author': 'Autor 2'
}
]
# Rota para listar todos os livros (GET)
@app.route('/books', methods=['GET'])
def get_books():
return jsonify(books)
# Rota para obter detalhes de um livro específico (GET)
@app.route('/books/<int:book_id>', methods=['GET'])
def get_book(book_id):
book = next((book for book in books if book['id'] == book_id), None)
if book:
return jsonify(book)
else:
return jsonify({'message': 'Livro não encontrado'}), 404
# Rota para adicionar um novo livro (POST)
@app.route('/books', methods=['POST'])
def add_book():
new_book = {
'id': len(books) + 1,
'title': request.json['title'],
'author': request.json['author']
}
books.append(new_book)
return jsonify(new_book), 201
# Rota para atualizar os detalhes de um livro existente (PUT)
@app.route('/books/<int:book_id>', methods=['PUT'])
def update_book(book_id):
book = next((book for book in books if book['id'] == book_id), None)
if book:
book['title'] = request.json['title']
book['author'] = request.json['author']
return jsonify(book)
else:
return jsonify({'message': 'Livro não encontrado'}), 404
# Rota para excluir um livro (DELETE)
@app.route('/books/<int:book_id>', methods=['DELETE'])
def delete_book(book_id):
book = next((book for book in books if book['id'] == book_id), None)
if book:
books.remove(book)
return jsonify({'message': 'Livro excluído'})
else:
return jsonify({'message': 'Livro não encontrado'}), 404
if __name__ == '__main__':
app.run()Neste exemplo, utilizamos uma lista de livros como dados de exemplo. As rotas “/books” nos permitem obter uma lista de todos os livros e adicionar um novo livro. A rota "/books/" permite que os usuários obtenham detalhes de um livro específico, atualizem os detalhes desse livro e excluam o livro. Mapeamos os métodos REST para cada rota, permitindo a execução das operações CRUD correspondentes.
Usar rotas no Flask
O Flask define as rotas usando o decorador @app.route(). Assim, o decorador associa uma função a uma URL específica, permitindo que o Flask saiba qual função será chamada quando uma determinada URL for acessada.
Exemplo de como usar rotas no Flask
from flask import Flask
app = Flask(__name__)
# Rota inicial
@app.route('/')
def index():
return 'Página inicial'
# Rota para a página "Sobre"
@app.route('/sobre')
def about():
return 'Esta é a página Sobre'
# Rota dinâmica com parâmetro
@app.route('/usuario/<nome>')
def user(nome):
return f'Olá, {nome}! Bem-vindo(a) à sua página de usuário.'
if __name__ == '__main__':
app.run()
Temos três rotas diferentes:
- Rota inicial (“/”): A função
index()será chamada quando a raiz do aplicativo for acessada. Ela retorna a string “Página inicial”. - Rota “/sobre”: A função
about()será chamada quando a URL “/sobre” for acessada. Ela retorna a string “Esta é a página Sobre”. - Rota dinâmica com parâmetro (“/usuario/<nome>”): A função
user(nome)será chamada quando a URL “/usuario/<nome>” for acessada, onde<nome>é um parâmetro variável passado na URL. Ela retorna uma mensagem personalizada com o nome fornecido na URL.
Quando você executa o aplicativo Flask, ele acessa as diferentes rotas em um navegador ou por meio de solicitações HTTP e executa a função correspondente para retornar a resposta adequada.
Ainda assim, é importante lembrar de importar a classe Flask do módulo flask e inicializar o aplicativo Flask chamando app.run() no final do código.
Usar templates no Flask Python
É possível usar templates para renderizar páginas HTML de dinamicamente. Para isso, você precisa seguir os seguintes passos:
- Crie uma pasta chamada
templatesno diretório raiz do seu projeto Flask. - Na pasta
templates, crie um arquivo HTML para o template desejado. Por exemplo, crie um arquivo chamadoindex.htmlcom o seguinte conteúdo:
<!DOCTYPE html>
<html>
<head>
<title>Meu Site</title>
</head>
<body>
<h1>{{ titulo }}</h1>
<p>Bem-vindo(a) ao meu site!</p>
</body>
</html>
- No seu arquivo Python do Flask, importe a classe
render_templatedo móduloflask:
from flask import Flask, render_template
app = Flask(__name__)
# Rota inicial
@app.route('/')
def index():
titulo = "Página Inicial"
return render_template('index.html', titulo=titulo)
if __name__ == '__main__':
app.run()
- No exemplo acima, a função
index()retorna o resultado derender_template(), que renderiza o templateindex.html. A funçãorender_template()aceita dois argumentos: o nome do arquivo do template e quaisquer variáveis que você deseja passar para o template. - No template, você pode usar
{{ variavel }}para exibir o valor das variáveis passadas pelo Flask. No exemplo acima, a variáveltituloé passada para o template e exibida no elemento<h1>. - Ao executar o aplicativo, o Flask renderiza o template com os valores das variáveis passadas. Dessa forma, a página HTML resultante fica visível no navegador.
Banco de dados em Flask Python
Você pode incorporar uma biblioteca de acesso a banco de dados, como o SQLAlchemy, que é um ORM (Object-Relational Mapping) muito usado e bastante poderoso.
A seguir, explicaremos como usar um banco de dados no Flask com o SQLAlchemy:
Instale o SQLAlchemy:
- Para incorporar o SQLAlchemy, execute o seguinte comando:
pip install flask-sqlalchemy
Configure o Banco de Dados:
- No arquivo Python do Flask, importe as classes
FlaskeSQLAlchemydo móduloflask. - Defina a URL de conexão do banco de dados. Por exemplo, para utilizar o SQLite, você pode configurar a URL como
sqlite:///nome_do_banco_de_dados.db. - Inicialize o objeto SQLAlchemy passando o aplicativo Flask e a URL do banco de dados.
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///mydatabase.db'
db = SQLAlchemy(app)
# Defina os modelos (tabelas)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
# Rota inicial
@app.route('/')
def index():
# Exemplo de consulta ao banco de dados
users = User.query.all()
return f'Total de usuários: {len(users)}'
if __name__ == '__main__':
app.run()Defina os Modelos:
- Defina as tabelas do banco de dados como classes, herdando da classe
db.Modeldo SQLAlchemy. - Adicione atributos às classes para representar as colunas da tabela, usando as classes
db.Columne os tipos de dados correspondentes. - Você pode definir relacionamentos, índices, restrições e outros detalhes conforme necessário.
Interaja com o Banco de Dados:
- Utilize as operações CRUD (Create, Read, Update, Delete) para interagir com o banco de dados.
- Por exemplo, para criar um novo usuário, você pode instanciar um objeto da classe
User, definir os atributos e adicioná-lo ao banco de dados usandodb.session.add(user). - Para consultar registros, você pode usar métodos como
query.all()para obter todos os registros de uma tabela.
É essencial lembrar que o exemplo acima utiliza o SQLite como banco de dados. No entanto, o SQLAlchemy oferece suporte a outros bancos de dados, como MySQL, PostgreSQL, Oracle, entre outros. A URL de conexão e algumas configurações podem variar dependendo do banco de dados escolhido.
Além disso, é necessário criar o banco de dados antes de executar o aplicativo Flask. Isso pode ser feito usando o comando db.create_all() ou migrando o esquema do banco de dados com o auxílio das migrações do SQLAlchemy.
Testar aplicativos Flask
Para iniciar um script Flask, você pode usar o seguinte comando:
flask runCertifique-se de estar no diretório raiz do projeto Flask, que contém o arquivo Python principal do aplicativo (normalmente chamado de app.py ou main.py). Executando o comando flask run, o servidor de desenvolvimento embutido do Flask será iniciado, permitindo que você acesse o aplicativo Flask em http://localhost:5000.
Para testar todas as rotas usando o curl, você pode utilizar o seguinte comando:
curl -iX GET http://localhost:5000/Esse comando enviará uma solicitação GET para a rota raiz (/) do aplicativo Flask. É possível substituir / por qualquer outra rota que você queira testar. O parâmetro -i incluirá os cabeçalhos da resposta no resultado e o parâmetro -X especificará o método da solicitação (neste caso, GET). Também é possível utilizar outros métodos HTTP, como POST, PUT e DELETE, dependendo da rota que está sendo testada.
Lembrando que é importante ajustar a porta (neste exemplo, 5000) se você tiver definido uma porta diferente para o seu aplicativo Flask.
É possível executar comandos curl adicionais para testar outras rotas, substituindo a URL e o método da solicitação conforme as rotas do seu aplicativo Flask.
Alternativas ao Flask Python
Django
É um framework web completo escrito em Python. Ele é mais complexo do que o Flask, mas também oferece mais recursos. Django é uma boa escolha para o desenvolvimento de aplicativos web de grande porte.
Pyramid
Pyramid é um framework web completo escrito em Python. Ele é semelhante ao Django em termos de recursos e complexidade. Assim, o Pyramid é uma boa escolha para o desenvolvimento de aplicativos web de qualquer porte.
Bottle
É um microframework web minúsculo escrito em Python. Ele é ainda menor e mais leve do que o Flask. Bottle, portanto, é uma boa escolha para o desenvolvimento de aplicativos web muito simples.
A melhor escolha para você dependerá de suas necessidades e preferências específicas. Se você está procurando um microframework web leve, extensível e fácil de aprender e usar, o Flask é uma ótima opção.
Ainda que precise de um framework web mais complexo com mais recursos, Django ou Pyramid podem ser uma melhor escolha. Se você está procurando um microframework web muito simples, Bottle pode ser uma boa opção.
Conclusão
Em suma, o Flask oferece flexibilidade para se adaptar a uma ampla gama de projetos, desde aplicações web simples até aplicações mais complexas. Ele traz adaptabilidade para desenvolvedores construírem desde pequenos projetos até aplicações mais complexas.
Se você acredita que o Flask não atende às suas necessidades específicas, existem outras opções disponíveis. É importante explorar e considerar diferentes frameworks e bibliotecas para encontrar a solução que melhor se adapte ao seu propósito.
Nós fornecemos, no entanto, outras opções além do Flask, caso você esteja buscando uma alternativa mais adequada para o seu caso de uso. Cada framework tem suas próprias vantagens e características, então recomendamos pesquisar e explorar as diferentes opções antes de decidir.
