Como os formulários Django funcionam?

Question

Accepted Answer

Os **formulários** Django lidam com todo o ciclo de vida da entrada do usuário: renderizar campos de formulário HTML, **validar** dados enviados e convertê-los em valores Python limpos. Eles abstraem o trabalho tedioso e propenso a erros do tratamento manual de entrada e validação — um recurso importante de produtividade e segurança. ## Um formulário básico ```python from django import forms class ContactForm(forms.Form): name = forms.CharField(max_length=100) email = forms.EmailField() # validates email format age = forms.IntegerField(min_value=0, required=False) message = forms.CharField(widget=forms.Textarea) ``` Cada campo de formulário declara seu tipo e regras de validação. O formulário pode se renderizar como HTML e validar entrada contra essas regras. ## Tratando um formulário em uma view (o padrão padrão) ```python def contact(request): if request.method == "POST": form = ContactForm(request.POST) # bind submitted data if form.is_valid(): # run validation # cleaned_data = validated, type-converted Python values name = form.cleaned_data["name"] send_email(form.cleaned_data) return redirect("success") else: form = ContactForm() # empty form for GET return render(request, "contact.html", {"form": form}) ``` Os métodos principais: `is_valid()` executa a validação, e em caso de sucesso `cleaned_data` fornece valores seguros, validados e convertidos de tipo. Em caso de falha, o formulário retém a entrada e coleta mensagens de erro. ## ModelForms — formulários a partir de modelos (DRY) ```python from django.forms import ModelForm class ArticleForm(ModelForm): class Meta: model = Article # build the form FROM a model fields = ["title", "body", "published"] # which fields to include # ModelForm can SAVE directly to the database def create(request): form = ArticleForm(request.POST) if form.is_valid(): form.save() # creates/updates the model instance! ``` **ModelForms** geram um formulário automaticamente a partir dos campos de um modelo e podem salvar diretamente no banco de dados — incorporando DRY (o modelo conduz o formulário), eliminando boilerplate para formulários CRUD. ## Validação personalizada ```python class SignupForm(forms.Form): password = forms.CharField() confirm = forms.CharField() def clean_password(self): # field-level validation pw = self.cleaned_data["password"] if len(pw) < 8: raise forms.ValidationError("Too short") return pw def clean(self): # form-level (cross-field) validation data = super().clean() if data.get("password") != data.get("confirm"): raise forms.ValidationError("Passwords don't match") ``` ## Renderização e segurança ```html ``` Os formulários se integram com a **proteção CSRF** do Django (`{% csrf_token %}`) e renderizam automaticamente campos com seus erros de validação. ## Por que isso importa Os formulários Django são um recurso central para tratar entrada do usuário de forma segura e produtiva — e tratar entrada corretamente é tanto onipresente (quase todo aplicativo tem formulários) quanto crítico para segurança. Compreender formulários é essencial porque eles abstraem o trabalho tedioso e propenso a erros do tratamento de entrada: renderizar campos HTML, **validar** dados contra regras, convertê-los em valores Python digitados e limpos (`cleaned_data`), preservar entrada e exibir erros em caso de falha, e proteger contra ataques. O aspecto de validação é especialmente importante para **segurança e robustez** — formulários garantem que você nunca confie em entrada bruta do usuário, capturando dados malformados ou maliciosos antes que cheguem à sua lógica de negócios. **ModelForms** são um grande ganho de produtividade, incorporando DRY gerando formulários diretamente a partir de modelos e salvando no banco de dados com código mínimo — eliminando boilerplate para o caso extremamente comum de formulários CRUD. Conhecer o padrão padrão de view (`is_valid()` + `cleaned_data`), como adicionar validação personalizada em nível de campo e entre campos, ModelForms para formulários apoiados por modelo, e a integração com **proteção CSRF** é fundamental para construir qualquer aplicativo Django que aceite entrada do usuário. Os formulários vinculam tratamento de entrada, validação, segurança e a camada de modelo, tornando-os uma parte importante e frequentemente usada do framework e uma razão-chave pela qual Django é tão produtivo para aplicativos com muita entrada de dados.