Wie funktionieren Django-Formulare?

Question

Accepted Answer

Django **Formulare** verwalten den gesamten Lebenszyklus von Benutzereingaben: Rendern von HTML-Formularfeldern, **Validierung** übermittelter Daten und deren Umwandlung in saubere Python-Werte. Sie abstrahieren die mühsame und fehleranfällige Arbeit der manuellen Eingabebehandlung und Validierung — eine wichtige Produktivitäts- und Sicherheitsfunktion. ## Ein einfaches Formular ```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) ``` Jedes Formularfeld deklariert seinen Typ und seine Validierungsregeln. Das Formular kann sich selbst als HTML rendern und Eingaben gegen diese Regeln validieren. ## Ein Formular in einer View verarbeiten (das Standardmuster) ```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}) ``` Die Schlüsselmethoden: `is_valid()` führt die Validierung aus, und bei Erfolg gibt `cleaned_data` Ihnen sichere, validierte, typkonvertierte Werte. Bei Fehler behält das Formular die Eingabe bei und sammelt Fehlermeldungen. ## ModelForms — Formulare aus Modellen (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** generieren ein Formular automatisch aus den Feldern eines Modells und können direkt in der Datenbank speichern — verkörpern DRY (das Modell treibt das Formular), eliminieren Boilerplate für CRUD-Formulare. ## Benutzerdefinierte Validierung ```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") ``` ## Rendern und Sicherheit ```html ``` Formulare integrieren sich mit Djangos **CSRF-Schutz** (`{% csrf_token %}`) und rendern automatisch Felder mit ihren Validierungsfehlern. ## Warum es wichtig ist Django-Formulare sind ein Kernfeature für sichere und produktive Behandlung von Benutzereingaben — und die richtige Behandlung von Eingaben ist sowohl allgegenwärtig (fast jede Anwendung hat Formulare) als auch sicherheitskritisch. Das Verständnis von Formularen ist essentiell, weil sie die mühsame und fehleranfällige Arbeit der Eingabebehandlung abstrahieren: Rendern von HTML-Feldern, **Validierung** von Daten gegen Regeln, Umwandlung in saubere typisierte Python-Werte (`cleaned_data`), Beibehaltung der Eingabe und Anzeige von Fehlern bei Misserfolg, sowie Schutz vor Angriffen. Der Validierungsaspekt ist besonders wichtig für **Sicherheit und Robustheit** — Formulare stellen sicher, dass Sie rohe Benutzereingaben niemals vertrauen, indem sie fehlerhafte oder bösartige Daten erfassen, bevor sie Ihre Geschäftslogik erreichen. **ModelForms** sind ein großer Produktivitätsgewinn, verkörpern DRY durch direkte Formulargenerierung aus Modellen und Speicherung in der Datenbank mit minimalem Code — eliminieren Boilerplate für den äußerst häufigen Fall von CRUD-Formularen. Das Kennen des Standardansicht-Musters (`is_valid()` + `cleaned_data`), das Hinzufügen von benutzerdefinierten Feld- und feldübergreifenden Validierungen, ModelForms für modellgestützte Formulare und die Integration mit **CSRF-Schutz** ist fundamental für das Erstellen jeder Django-Anwendung, die Benutzereingaben akzeptiert. Formulare verbinden Eingabebehandlung, Validierung, Sicherheit und die Modellebene und machen sie zu einem wichtigen, häufig verwendeten Teil des Frameworks und einem Schlüsselgrund dafür, dass Django so produktiv für datenerfassungsintensive Anwendungen ist.