Introdução
Este tutorial em Flask vai mostrar como criar uma aplicação web simples. Você não precisa de conhecimento prévio em programação para acompanhar. Vamos usar uma linguagem clara e exemplos práticos do dia a dia. Você entenderá cada passo para criar sua própria aplicação com Flask.
O Flask é um microframework em Python que facilita o desenvolvimento de projetos web. Microframework significa um conjunto mínimo de ferramentas para montar aplicações. Ele é leve, flexível e fácil de aprender. Vamos explorar desde a instalação até o deploy em produção.
O que é Flask
O Flask nasceu para simplificar a criação de sites e APIs em Python. Ele segue a especificação WSGI, que é a forma padrão de comunicação entre o código Python e o servidor web. Com isso, você aproveita todo o ecossistema Python e bibliotecas existentes.
O Flask fornece apenas o básico: roteamento, templates e suporte a extensões. Essa abordagem “mínima” ajuda a manter o código enxuto. Você decide quais recursos adicionar, como banco de dados ou autenticação. Essa liberdade torna o Flask uma opção popular para projetos pequenos e médios.
Por que usar Flask
- Leveza: o Flask carrega só o necessário.
- Flexibilidade: você escolhe as bibliotecas que quer usar.
- Facilidade: a curva de aprendizado é baixa.
- Comunidade ativa: há muitos tutoriais e extensões.
Esses pontos atraem iniciantes e desenvolvedores experientes. Se precisar de funcionalidades extras, basta instalar uma extensão ou escrever seu próprio módulo.
Instalação do Flask
Para começar, é recomendável usar um ambiente virtual (virtualenv). Isso evita conflitos entre pacotes de projetos diferentes.
Pensou por dois segundos
Instale o virtualenv (caso não tenha):
pip install virtualenvCrie um ambiente na pasta do projeto:
virtualenv venvAtive o ambiente no Windows:
.\venv\Scripts\activateAtive o ambiente no macOS/Linux:
source venv/bin/activateInstale o Flask:
pip install flaskVerifique a versão:
flask --version<br>Após isso, seu ambiente estará pronto para criar a aplicação.
Criando seu primeiro projeto
Vamos criar um arquivo chamado app.py. Nele, adicionamos o código abaixo:
from flask import Flask
app = Flask(__name__)
@app.route("/")
def home():
return "Olá, mundo! Bem-vindo ao seu **tutorial em Flask**."
if __name__ == "__main__":
app.run(debug=True)- Flask(name): inicializa o app.
- @app.route(“/”): define a rota para a página inicial.
- home(): função que retorna o conteúdo da página.
- debug=True: ativa o modo de depuração para testes.
Para executar, use:
python app.pyAbra o navegador em http://127.0.0.1:5000/ para ver a mensagem.
Estrutura de pastas recomendada
Manter os arquivos bem organizados ajuda no crescimento do projeto. Veja uma estrutura básica:
meu_projeto/
├── app.py
├── requirements.txt
├── venv/
└── templates/
└── index.html
- app.py: arquivo principal da aplicação.
- requirements.txt: lista de dependências. Gere com
pip freeze > requirements.txt. - templates/: pasta para templates HTML (Jinja2).
Conforme o projeto cresce, crie pastas como static/ para arquivos estáticos e models/ para o banco de dados.
Rotas no Flask
Rotas são caminhos que o usuário acessa no navegador. No exemplo anterior, definimos a rota /. Você pode criar outras:
@app.route("/sobre")
def sobre():
return "Página Sobre"Crie uma rota para cada funcionalidade. Rotas podem receber parâmetros:
@app.route("/usuario/<nome>")
def usuario(nome):
return f"Olá, {nome}!"- : segmento dinâmico na URL.
- A função recebe
nomecomo argumento.
Use listas para funções que respondem a vários métodos HTTP:
@app.route("/login", methods=["GET", "POST"])
def login():
if request.method == "POST":
# processa formulário
return render_template("login.html")Templates com Jinja2
O Flask usa o Jinja2 como motor de templates. Isso permite separar o HTML do Python.
Exemplo de template (templates/index.html):
<!DOCTYPE html>
<html lang="pt-br">
<head>
<meta charset="UTF-8">
<title>Página Inicial</title>
</head>
<body>
<h1>Bem-vindo ao seu tutorial em Flask</h1>
<p>Hoje é {{ data_atual }}</p>
</body>
</html>No app.py, passe a variável:
from flask import render_template
from datetime import date
@app.route("/")
def home():
hoje = date.today().strftime("%d/%m/%Y")
return render_template("index.html", data_atual=hoje)- render_template: renderiza o arquivo HTML.
- {{ data_atual }}: insere o valor da variável no HTML.
Trabalhando com dados e formulários
Para receber dados do usuário, use o objeto request:
from flask import request
@app.route("/contato", methods=["GET", "POST"])
def contato():
if request.method == "POST":
nome = request.form.get("nome")
mensagem = request.form.get("mensagem")
return f"Obrigado, {nome}! Recebemos sua mensagem."
return render_template("contato.html")No contato.html:
<form action="/contato" method="post">
<input type="text" name="nome" placeholder="Seu nome">
<textarea name="mensagem" placeholder="Sua mensagem"></textarea>
<button type="submit">Enviar</button>
</form>- request.form: obtém dados enviados por formulário.
method="post": define envio via POST.
Banco de dados com Flask‑SQLAlchemy
Para persistir dados, use a extensão Flask‑SQLAlchemy:
Instale:
pip install flask-sqlalchemyConfigure no app.py:
from flask_sqlalchemy import SQLAlchemy
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///dados.db"
db = SQLAlchemy(app)Crie um modelo:
class Usuario(db.Model):
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(80), nullable=False)Inicialize o banco:
python
>>> from app import db
>>> db.create_all()Adicione registros:
novo = Usuario(nome="Ana")
db.session.add(novo)
db.session.commit()Essa configuração usa o SQLite, um banco de dados leve. Você pode trocar por MySQL, PostgreSQL ou outros.
Comparação: Flask vs outros frameworks
Flask se destaca pela leveza e flexibilidade. Confira uma comparação simplificada:
| Framework | Tipo | Curva de aprendizado | Flexibilidade |
|---|---|---|---|
| Flask | Microframework | Baixa | Alta |
| Django | Full‑stack | Média | Média |
| FastAPI | Microframework | Média | Alta |
- Django oferece tudo pronto, mas é mais pesado.
- FastAPI foca em APIs e performance.
- Flask dá liberdade para criar do seu jeito.
Autenticação simples
Pensou por 6 segundos
Instale:
pip install flask-loginConfigure no app.py:
from flask_login import LoginManager, UserMixin, login_user, login_required
login_manager = LoginManager(app)Defina o modelo de usuário:
class Usuario(UserMixin, db.Model):
# campos id, nome, senha
passCarregue usuário:
@login_manager.user_loader
def load_user(user_id):
return Usuario.query.get(int(user_id))Proteja rotas:
@app.route("/dashboard")
@login_required
def dashboard():
return "Área restrita"Com Flask‑Login, você controla sessões e páginas privadas com poucas linhas de código.
Deploy da aplicação
Depois de testar localmente, é hora de publicar:
- Escolha um provedor (Heroku, PythonAnywhere, Vercel).
- Adicione um arquivo
Procfile(Heroku):web: gunicorn app:app - Instale o Gunicorn:
pip install gunicorn - Configure variáveis de ambiente (secret key, banco).
- Faça o deploy via Git ou painel do provedor.
Cada serviço tem sua própria forma de deploy. Consulte a Documentação oficial do Flask para detalhes.
Próximos passos
Após seguir este tutorial em Flask, explore extensões como Flask‑Marshmallow para serialização de dados. Crie projetos reais, como blogs ou APIs de produtos. Teste suas aplicações com pytest e Flask‑Testing.
Participe de comunidades brasileiras, como o Python Brasil, para tirar dúvidas e compartilhar projetos. Assim, você ganha experiência prática e amplia sua rede de contatos.
Conclusão
Você aprendeu o básico de Flask: instalação, rotas, templates e banco de dados. Agora é capaz de criar uma aplicação web simples em Python. Continue praticando, estude novas extensões e faça deploy em seu próprio servidor. Com esses passos, seu domínio do Flask crescerá a cada projeto.
FAQ – Perguntas Frequentes sobre o Tutorial em Flask
1. O que é Flask?
Flask é um microframework em Python. Ele oferece apenas o básico para criar sites e APIs. Isso o torna leve e fácil de aprender.
2. Por que usar um ambiente virtual?
O ambiente virtual isola as bibliotecas de cada projeto. Assim, você evita conflitos de versões e mantém tudo organizado.
3. Como faço para instalar o Flask?
Primeiro, crie e ative o ambiente virtual. Depois, rode pip install flask no terminal. Pronto: o Flask já estará disponível.
4. Como defino rotas no Flask?
Use o decorator @app.route("/caminho") antes de uma função. O nome da função renderiza o conteúdo para aquela URL.
5. Para que serve o Jinja2?
Jinja2 é o motor de templates do Flask. Ele permite misturar HTML com variáveis e controles de fluxo de forma simples.
6. Como recebo dados de formulários?
No handler da rota, use request.form.get("nome_do_campo"). Isso busca o valor enviado pelo formulário HTML.
7. Posso usar banco de dados com Flask?
Sim. A extensão Flask‑SQLAlchemy conecta sua aplicação a bancos como SQLite, MySQL ou PostgreSQL com poucos passos.
8. Como protejo páginas com login?
Utilize Flask‑Login. Ele gerencia sessões e protege rotas com o decorator @login_required.
9. O que muda no deploy de produção?
Em produção, você usa um servidor WSGI como Gunicorn. Também configura variáveis de ambiente e remove debug=True.
