Como criar um site com Python: primeira página

O que é Flask?

Flask é um microframework Python para desenvolvimento web. Ele foi criado por Armin Ronacher e faz parte do projeto Pallets. A palavra "micro" não significa que ele é limitado — significa que o núcleo é enxuto e você adiciona extensões conforme a necessidade do projeto.

Diferente do Django, que já vem com ORM, admin e sistema de autenticação, o Flask te dá liberdade para escolher cada peça. Isso o torna ideal para quem está aprendendo, porque você entende cada camada da aplicação.

Por que escolher Flask?

• Curva de aprendizado suave: poucas linhas para ter algo funcionando
• Documentação excelente e comunidade ativa
• Flexibilidade total na estrutura do projeto
• Ecossistema rico de extensões (SQLAlchemy, WTForms, Login, etc.)
• Perfeito tanto para APIs quanto para sites com templates

Instalação com pip e venv

Antes de instalar qualquer pacote, crie um ambiente virtual. Isso isola as dependências do seu projeto e evita conflitos com outros projetos na mesma máquina.

# crie a pasta do projeto e entre nela
mkdir meu-projeto-flask
cd meu-projeto-flask

# crie o ambiente virtual
python -m venv venv

# ative o ambiente (Linux/Mac)
source venv/bin/activate

# ative o ambiente (Windows)
venv\Scripts\activate

# instale o Flask
pip install flask

Para confirmar que a instalação funcionou:

python -c "import flask; print(flask.__version__)"

Criando o app.py mínimo

Crie um arquivo chamado app.py na raiz do projeto. Este é o ponto de entrada da sua aplicação Flask:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Ola, Flask!"

São apenas cinco linhas. Vamos entender cada uma:

1. Importamos a classe Flask do pacote flask
2. Criamos uma instância passando __name__, que ajuda o Flask a localizar templates e arquivos estáticos
3. Usamos o decorador @app.route para associar a URL / à função index
4. A função retorna o conteúdo que será enviado ao navegador

Como funciona o decorador @app.route

O decorador @app.route é o coração do sistema de rotas do Flask. Ele registra uma função como handler para uma URL específica. Quando o navegador acessa aquela URL, o Flask chama a função correspondente e devolve o retorno como resposta HTTP.

@app.route("/")
def pagina_inicial():
    return "Pagina inicial"

@app.route("/sobre")
def sobre():
    return "Pagina sobre"

@app.route("/contato")
def contato():
    return "Pagina de contato"

Cada rota precisa de uma função com nome único. O Flask usa o nome da função internamente para gerar URLs com a função url_for.

Rodando o servidor de desenvolvimento

Existem duas formas de rodar sua aplicação. A primeira é pelo terminal com o comando flask run:

# defina a variavel de ambiente com o arquivo principal
export FLASK_APP=app.py

# rode o servidor
flask run

A segunda forma, mais prática durante o desenvolvimento, é adicionar o bloco if __name__ ao final do app.py:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Ola, Flask!"

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

Com debug=True, o servidor reinicia automaticamente quando você salva alterações no código e exibe mensagens de erro detalhadas no navegador. Acesse http://127.0.0.1:5000 para ver o resultado.

Atenção: nunca use debug=True em produção. O modo debug permite execução de código arbitrário no servidor.

Rotas com diferentes paths

O Flask permite criar rotas dinâmicas usando variáveis na URL. Isso é útil para páginas de perfil, produtos, artigos e qualquer recurso identificado por um valor único.

@app.route("/usuario/<nome>")
def perfil(nome):
    return f"Perfil de {nome}"

@app.route("/produto/<int:produto_id>")
def produto(produto_id):
    return f"Produto numero {produto_id}"

@app.route("/artigo/<slug>")
def artigo(slug):
    return f"Artigo: {slug}"

Os conversores disponíveis são: string (padrão), int, float, path e uuid. Eles validam o valor automaticamente — se alguém acessar /produto/abc, o Flask retorna 404 porque abc não é um inteiro.

Métodos HTTP: GET vs POST

Por padrão, as rotas do Flask aceitam apenas requisições GET. Para aceitar outros métodos, use o parâmetro methods:

from flask import Flask, request

app = Flask(__name__)

@app.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        usuario = request.form.get("usuario")
        senha = request.form.get("senha")
        return f"Tentativa de login: {usuario}"
    return "Formulario de login"

• GET é usado para buscar informações (carregar uma página, listar dados)
• POST é usado para enviar informações (formulários, criação de recursos)

O objeto request é importado do Flask e contém todos os dados da requisição: headers, formulário, query string, JSON e mais.

Retornando HTML simples vs JSON

O Flask permite retornar diferentes tipos de conteúdo. Para páginas web, você retorna HTML. Para APIs, retorna JSON.

from flask import Flask, jsonify

app = Flask(__name__)

# retornando HTML simples
@app.route("/")
def index():
    return """
    <html>
        <head><title>Meu Site</title></head>
        <body>
            <h1>Bem-vindo ao Flask</h1>
            <p>Esta pagina foi gerada pelo Python.</p>
        </body>
    </html>
    """

# retornando JSON para APIs
@app.route("/api/status")
def api_status():
    return jsonify({
        "status": "online",
        "versao": "1.0.0",
        "framework": "Flask"
    })

# retornando JSON com lista de dados
@app.route("/api/tarefas")
def listar_tarefas():
    tarefas = [
        {"id": 1, "titulo": "Estudar Flask", "concluida": False},
        {"id": 2, "titulo": "Criar projeto", "concluida": False},
    ]
    return jsonify(tarefas)

A função jsonify converte dicionários e listas Python em respostas JSON com o header Content-Type: application/json configurado automaticamente.

Estrutura de pastas recomendada

Para projetos pequenos, um único app.py resolve. Mas conforme o projeto cresce, organizar os arquivos em pastas facilita a manutenção. Esta é a estrutura recomendada:

meu-projeto-flask/
├── venv/
├── app/
│   ├── __init__.py
│   ├── routes.py
│   ├── models.py
│   ├── templates/
│   │   ├── base.html
│   │   └── index.html
│   └── static/
│       ├── css/
│       ├── js/
│       └── img/
├── config.py
├── run.py
└── requirements.txt

O arquivo __init__.py dentro de app/ é onde você cria a instância do Flask usando o padrão Application Factory:

from flask import Flask

def create_app():
    app = Flask(__name__)
    app.config["SECRET_KEY"] = "chave-secreta-aqui"

    from app.routes import main
    app.register_blueprint(main)

    return app

E o run.py na raiz fica simples:

from app import create_app

app = create_app()

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

Essa estrutura é a base que vamos usar nos próximos artigos da série, adicionando templates, banco de dados e autenticação passo a passo.