Como criar um Formulário em Flask e Python - Parte 1
Introdução
No mundo ágil e interconectado de hoje, a habilidade de criar aplicativos web dinâmicos é mais valiosa do que nunca. Python, com sua simplicidade e versatilidade, juntamente com o microframework Flask, oferecem uma maneira poderosa e eficiente de desenvolver essas aplicações. Este artigo destina-se a programadores que já possuem conhecimento básico de Python e desejam dar o próximo passo no desenvolvimento web. Aqui, focaremos em um aspecto fundamental de qualquer aplicativo web: a criação de formulários, mais especificamente em como criar formulários em Flask e Python.
Formulários são a espinha dorsal da interação usuário-aplicação na web. Eles coletam informações, facilitam a interação e são essenciais para uma experiência de usuário funcional. Flask, conhecido por sua natureza "minimalista", proporciona uma abordagem simples, porém robusta, para construir formulários web. Combinando Python e Flask, você pode criar um formulário que não apenas coleta dados, mas também os processa e armazena de forma eficiente.
Neste tutorial, guiaremos você através dos passos para criar um formulário web usando Flask e Python. Começaremos com a configuração básica do Flask, passando pela criação de um formulário HTML e terminando com a integração de um banco de dados SQLite para armazenar as informações coletadas. Este processo não só lhe dará uma compreensão prática de como trabalhar com Flask e formulários web, mas também serve como uma base sobre a qual você pode construir aplicações web mais complexas.
Então, vamos mergulhar no mundo do Flask e descobrir como essa poderosa dupla - Python e Flask - pode ser usada para criar um aplicativo web interativo com um formulário funcional, está é a parte 1 deste tutorial, de um total de 3 partes.
Para começarmos, você precisa ter o Flask instalado. Se ainda não o instalou, você pode fazer isso usando pip:
pip install Flask
Agora, vamos ao código. Primeiramente vou mostrar como criar um arquivo Python simples que inicia um servidor web e exibe uma mensagem. Você pode nomear este arquivo como app.py:
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return 'Bem-vindo ao meu app Flask!'
if __name__ == '__main__':
app.run(debug=True)
Explicando o que usamos acima:
from flask import Flask: Importamos a classe Flask do módulo flask.
app = Flask(__name__): Criamos uma instância da classe Flask. __name__ é uma variável especial do Python que é usada para determinar o nome do módulo em que o script é executado.
@app.route('/'): Este é um decorador que define a rota. / indica a rota raiz, então esta função será executada quando você acessar a URL inicial do servidor.
def home(): Define a função que será chamada quando a rota especificada for acessada. Ela retorna a string 'Bem-vindo ao meu app Flask!', que será exibida no navegador.
app.run(debug=True): Executa a aplicação em modo de desenvolvimento. O debug=True permite que o servidor reinicie automaticamente em caso de mudanças no código e fornece um debugger no navegador se ocorrer algum erro.
Para executar o aplicativo, você deve rodar o script app.py:
python app.py
Depois de executar o comando, você verá que o servidor Flask está rodando no seu terminal. Por padrão, ele roda na porta 5000. Para acessar o aplicativo, abra um navegador e vá para http://127.0.0.1:5000/. Você deverá ver a mensagem 'Bem-vindo ao meu app Flask!' na página.
Este é um exemplo bem básico, mas o Flask é muito flexível e poderoso, permitindo a criação de aplicações web complexas com rotas, templates, formulários, e muito mais. Vamos expandir o exemplo anterior para incluir um template de formulário e salvar os dados submetidos em um banco de dados SQLite. Primeiro, precisamos modificar o código Flask para lidar com o formulário e a conexão com o SQLite.
Vamos expandir o exemplo anterior para incluir um template de formulário e salvar os dados submetidos em um banco de dados SQLite. Primeiro, precisamos modificar o código Flask para lidar com o formulário e a conexão com o SQLite.
Você também precisará do módulo flask_sqlalchemy para facilitar a interação com o SQLite. Pode ser instalado via pip:
pip install flask_sqlalchemy
Vamos agora a construção do nosso formulário, vamos separar o entendimento em 7 passos:
1. Importar Módulos Necessários:
from flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy
Aqui, estamos importando as classes e funções necessárias dos módulos flask e flask_sqlalchemy. Flask é usado para criar o aplicativo, render_template para renderizar os templates HTML, request para acessar os dados do formulário, redirect e url_for para redirecionar o usuário, e SQLAlchemy para trabalhar com o banco de dados SQLite.
2. Configurar o Aplicativo Flask e o SQLAlchemy:
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///dados.db'
db = SQLAlchemy(app)
Aqui, criamos uma instância do Flask e configuramos o URI (Uniform Resource Identifier) do banco de dados para usar SQLite. db = SQLAlchemy(app) inicializa o SQLAlchemy com as configurações do nosso app Flask.
3. Definir o Modelo de Banco de Dados:
class DadosFormulario(db.Model): id = db.Column(db.Integer, primary_key=True) nome = db.Column(db.String(80), nullable=False) mensagem = db.Column(db.String(200), nullable=False)- Esta classe define a estrutura da tabela DadosFormulario no banco de dados. Ela tem três campos: id (uma chave primária autoincrementada), nome e mensagem. Estes campos correspondem aos dados que serão coletados do formulário.
4. Criar Tabelas do Banco de Dados:
with app.app_context(): db.create_all() - Esta função é executada antes da primeira solicitação ao servidor e garante que as tabelas do banco de dados sejam criadas com base nas classes de modelos definidas.
5. Definir a Rota da Página Inicial e Renderizar o Formulário:
@app.route('/')
def home():
return render_template('formulario.html')
Esta rota ('/') define a página inicial do nosso aplicativo. Quando acessada, ela renderiza o arquivo HTML formulario.html.
6. Definir a Rota para Processar o Formulário:
@app.route('/enviar', methods=['POST'])
def enviar():
nome = request.form['nome']
mensagem = request.form['mensagem']
novo_dado = DadosFormulario(nome=nome, mensagem=mensagem)
db.session.add(novo_dado)
db.session.commit()
return render_template('formulario.html', nome=novo_dado.nome, mensagem=novo_dado.mensagem)
Esta rota lida com a submissão do formulário. Quando o formulário é enviado, os dados são acessados através de request.form, um novo registro é criado no banco de dados e, em seguida, salvamos esses dados no banco de dados. Após salvar os dados, o usuário é redirecionado de volta para a página inicial, com os dados que ele acabou de criar sendo enviados nas variáveis nome e mensagem para que o template adicione na tela do usuário.
7. Criando o nosso formulário no arquivo HTML:
<!DOCTYPE html>
<html>
<head>
<title>Formulário Flask</title>
</head>
<body>
<h1>Formulário</h1>
<form method="POST" action="/enviar">
<label for="nome">Nome:</label><br>
<input type="text" id="nome" name="nome"><br>
<label for="mensagem">Mensagem:</label><br>
<input type="text" id="mensagem" name="mensagem"><br><br>
<input type="submit" value="Enviar">
</form> <h1>Dados Criados</h1>
<p><strong>Nome:</strong> {{ nome }}</p>
<p><strong>Mensagem:</strong> {{ mensagem }}</p>
</body>
</html>Crie um arquivo HTML para o formulário chamado formulario.html e coloque-o na pasta templates (você precisa criar esta pasta no mesmo diretório do seu arquivo app.py). O Flask procura automaticamente por templates nessa pasta. O conteúdo de formulario.html pode ser algo assim:
Assim fica o código final do nosso app.py:
from flask import Flask, render_template, request, redirect, url_for from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///dados.db' db = SQLAlchemy(app)class DadosFormulario(db.Model): id = db.Column(db.Integer, primary_key=True) nome = db.Column(db.String(80), nullable=False) mensagem = db.Column(db.String(200), nullable=False)with app.app_context(): db.create_all() @app.route('/') def home(): return render_template('formulario.html') @app.route('/enviar', methods=['POST']) def enviar(): nome = request.form['nome'] mensagem = request.form['mensagem'] novo_dado = DadosFormulario(nome=nome, mensagem=mensagem) db.session.add(novo_dado) db.session.commit() return render_template('formulario.html', nome=novo_dado.nome, mensagem=novo_dado.mensagem) if __name__ == '__main__': app.run(debug=True)
Agora vamos executar nossa aplicação por completo com o comando abaixo:
if __name__ == '__main__':
app.run(debug=True)
Agora acesse novamente seu servidor na url http://127.0.0.1:5000 e sua tela deverá estar como a mostrada abaixo. Com as etapas abordadas neste tutorial, você agora tem um aplicativo Flask funcional capaz de coletar dados através de um formulário e armazená-los em um banco de dados SQLite. É importante lembrar que a pasta instance do seu projeto Flask deve conter o arquivo dados.db, que é o banco de dados SQLite onde os dados do formulário são armazenados. Este arquivo é criado e gerenciado automaticamente pelo SQLAlchemy, conforme definimos em nosso código.
E os arquivos na sua pasta devem estar na seguinte estrutura:
Conclusão da Parte 1: Criando e Armazenando Dados de Formulários com Flask
Neste primeiro segmento do nosso tutorial sobre Flask, demos um passo significativo na jornada do desenvolvimento web com Python. Cobrimos os fundamentos do Flask, desde a configuração inicial de um aplicativo até a criação de um formulário web interativo e o armazenamento de seus dados em um banco de dados SQLite.
Ao longo desta parte, você aprendeu como:
- 1. Configurar um ambiente Flask básico.
- 2. Criar um modelo de dados simples usando SQLAlchemy para armazenar informações de formulários.
- 3. Implementar um formulário HTML para capturar dados do usuário.
- 4. Processar e salvar esses dados no banco de dados SQLite através de rotas Flask.
Este conhecimento é essencial para qualquer desenvolvedor aspirante a trabalhar com aplicações web em Flask. Os conceitos e técnicas aprendidos aqui servirão como uma base sólida para construir aplicações web mais complexas e interativas.
Na próxima parte deste tutorial, vamos expandir nosso aplicativo para incluir funcionalidades de listagem e deleção de registros, permitindo uma gestão mais eficaz dos dados coletados. Este será um passo crucial para entender melhor o gerenciamento de dados dentro de aplicações web.
Agradecemos por seguir até aqui e esperamos que você esteja tão entusiasmado quanto nós para continuar esta jornada de aprendizado. Até a próxima parte, sinta-se à vontade para experimentar e expandir o que aprendeu, e não hesite em mergulhar mais fundo nos poderosos recursos que o Flask tem a oferecer.
Esté é o link para a parte 2 deste tutorial de Como Criar Um Formulario em Flask e Python Parte 2.
Comentarios Recentes