Classes de Formulário no Django

O Django fornece ferramentas avançadas para trabalhar com formulários, como a possibilidade de defini-los em classes reutilizáveis. Essas classes centralizam a lógica dos formulários, simplificam a validação de dados, permitem o vínculo com modelos e oferecem outros benefícios que tornam o desenvolvimento mais organizado.

Criando Classes de Formulário

No Django, os formulários podem ser definidos como classes que herdam de forms.Form. Normalmente, essas classes são organizadas em arquivos como forms.py, mas também podem ser incluídas em outros arquivos do projeto, como views.py ou models.py, dependendo da estrutura escolhida.

PROGRAMICIO
hello/
|-- migrations/
|-- templates/
        |-- index.html
|-- __init__.py
|-- admin.py
|-- apps.py
|-- forms.py
|-- models.py
|-- tests.py
|-- views.py
programicio/
|-- __init__.py
|-- asgi.py
|-- settings.py
|-- urls.py
|-- wsgi.py

Um exemplo básico de definição de formulário em forms.py:

from django import forms

class UserForm(forms.Form):
    name = forms.CharField()
    age = forms.IntegerField()

Nesta classe:

O campo name utiliza forms.CharField, que gera um campo de entrada do tipo text.
O campo age utiliza forms.IntegerField, que gera um campo de entrada do tipo number

Renderizando o Formulário no Template

No arquivo views.py, a classe do formulário pode ser usada para renderizar um formulário vazio na página inicial:

from django.shortcuts import render
from .forms import UserForm

def index(request):
    userform = UserForm()
    return render(request, "index.html", {"form": userform})

No arquivo urls.py, definimos a rota para a view:

from django.urls import path
from hello import views

urlpatterns = [
    path("", views.index),
]

No template index.html, o formulário é renderizado diretamente:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>Formulário de Usuário</title>
  </head>
  <body>
    <table>
      {{ form }}
    </table>
  </body>
</html>

Quando renderizado, o formulário gera o seguinte HTML:

<tr>
  <th><label for="id_name">Name:</label></th>
  <td><input type="text" name="name" required id="id_name" /></td>
</tr>
<tr>
  <th><label for="id_age">Age:</label></th>
  <td><input type="number" name="age" required id="id_age" /></td>
</tr>

Classes de Formulário em Django

Enviando e Processando Dados com o Formulário

Para permitir o envio de dados, ajustamos o template index.html para incluir um formulário HTML completo:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>Formulário de Usuário</title>
  </head>
  <body>
    <form method="POST">
      {% csrf_token %}
      <table>
        {{ form }}
      </table>
      <input type="submit" value="Enviar" />
    </form>
  </body>
</html>

O elemento <form> encapsula os campos e utiliza o atributo method="POST" para indicar que os dados serão enviados ao servidor. O token CSRF, gerado pelo Django, protege a aplicação contra ataques CSRF.

No arquivo views.py, a lógica para processar os dados enviados pode ser implementada da seguinte forma:

from django.shortcuts import render
from django.http import HttpResponse
from .forms import UserForm

def index(request):
    if request.method == "POST":
        name = request.POST.get("name")
        age = request.POST.get("age")
        return HttpResponse(f"<h2>Olá, {name}. Sua idade é: {age}</h2>")
    else:
        userform = UserForm()
        return render(request, "index.html", {"form": userform})

Aqui, a view trata tanto requisições GET quanto POST:

Se o método for POST, os dados enviados pelo formulário são acessados através de request.POST e processados.
Se o método for GET, o formulário vazio é renderizado na página.

Após preencher e enviar o formulário, a resposta exibirá os dados processados pelo servidor.

Navegador exibindo dados após envio do formulário

Documentação oficial:

Working with forms