¿Cómo funcionan los formularios en Django?

Question

Accepted Answer

Los **formularios** de Django manejan el ciclo de vida completo de la entrada del usuario: renderizar campos de formulario HTML, **validar** datos enviados y convertirlos a valores Python limpios. Abstraen el trabajo tedioso y propenso a errores del manejo manual de entrada y validación — una característica importante para la productividad y la seguridad. ## Un formulario 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 formulario declara su tipo y reglas de validación. El formulario puede renderizarse como HTML y validar la entrada contra esas reglas. ## Manejo de un formulario en una vista (el patrón estándar) ```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}) ``` Los métodos clave: `is_valid()` ejecuta la validación y, en caso de éxito, `cleaned_data` te proporciona valores seguros, validados y convertidos de tipo. En caso de fallo, el formulario retiene la entrada y recopila mensajes de error. ## ModelForms — formularios 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! ``` Los **ModelForms** generan un formulario automáticamente a partir de los campos de un modelo y pueden guardarse directamente en la base de datos — encarnando DRY (el modelo impulsa el formulario), eliminando código repetitivo para formularios CRUD. ## Validación 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") ``` ## Renderización y seguridad ```html ``` Los formularios se integran con la **protección CSRF** de Django (`{% csrf_token %}`) y renderizan automáticamente campos con sus mensajes de error de validación. ## Por qué es importante Los formularios de Django son una característica central para manejar la entrada del usuario de forma segura y productiva — y manejar la entrada correctamente es tanto ubicuo (casi todas las aplicaciones tienen formularios) como crítico para la seguridad. Entender los formularios es esencial porque abstraen el trabajo tedioso y propenso a errores del manejo de entrada: renderizar campos HTML, **validar** datos contra reglas, convertirlos a valores Python tipados limpios (`cleaned_data`), preservar la entrada y mostrar errores en caso de fallo, y proteger contra ataques. El aspecto de validación es especialmente importante para la **seguridad y robustez** — los formularios aseguran que nunca confíes en la entrada bruta del usuario, capturando datos malformados o maliciosos antes de que lleguen a tu lógica de negocio. Los **ModelForms** son una victoria importante para la productividad, encarnando DRY al generar formularios directamente a partir de modelos y guardando en la base de datos con código mínimo — eliminando código repetitivo para el caso extremadamente común de formularios CRUD. Conocer el patrón de vista estándar (`is_valid()` + `cleaned_data`), cómo añadir validación personalizada a nivel de campo y entre campos, ModelForms para formularios respaldados por modelos, y la integración con **protección CSRF** es fundamental para construir cualquier aplicación Django que acepte entrada del usuario. Los formularios unen el manejo de entrada, validación, seguridad y la capa del modelo, convirtiéndolos en una parte importante y frecuentemente utilizada del framework y una razón clave por la que Django es tan productivo para aplicaciones con muchas entradas de datos.