Heim > Artikel > Backend-Entwicklung > So verwenden Sie die Django-Formularvalidierung in Python
So verwenden Sie die Django-Formularvalidierung in Python
- 高洛峰Original
- 2017-03-30 17:20:432110Durchsuche
1. django fürmFormularvalidierung Einführung
Manchmal müssen wir get, post, put usw. verwenden, um einige Daten an das Hintergrundverarbeitungsbeispiel auf der Front-End-HTML-Seite zu senden;
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Form</title>
</head>
<body>
<p>
<form action="url" method="post" enctype="multipart/form-data">{% csrf_token %}
<input type="text" name="username"/>
<input type="password" name="password"/>
<input type="submit" value="submit"/>
</form>
</p>
</body>Front -Ende-Übermittlung und Hintergrunderfassung:
from django.shortcuts import render,HttpResponse,redirect
from app01 import models
def Login(request):
if request.method == "POST":
username = request.POST.get("username")
password = request.POST.get("password")
return HttpResponse("Hello,%s"%(username))
Damit ist die Grundfunktion abgeschlossen und grundsätzlich einsatzbereit
Wenn die Benutzereingabe jedoch erfolgt Wenn Sie die Anforderungen nicht erfüllen (z. B. die Länge der eingegebenen Daten beträgt 11 Ziffern, die Komplexität des Passworts usw.), gehen die eingegebenen Daten verloren, wenn Sie nach der Übermittlung zurückkehren
Wenn wir alle Daten nach der Eingabe in Ansichten manuell abrufen, ist die Übergabe an die Webseite natürlich möglich, aber sehr unpraktisch, daher bietet Django einfachere und benutzerfreundlichere Formulare zum Lösen einer Reihe von Problemen wie der Verifizierung
Hier muss ich die echte Plug-in-Bibliothek von Django erwähnen. Sie ist sehr leistungsstark, einfach und leicht zu erweitern. Der obige Inhalt stellt nur vor, warum das Formular verwendet werden sollte zum Aufzeichnen der Verwendung von Django-Formularen
2. Formular-Formularüberprüfungsanwendung
Muss in der Django-APP erstellt werden. Ein Modul form.py, der spezifische Inhalt ist wie folgt
class RegisterForm(forms.Form):
email = forms.EmailField(required=True,
error_messages={'required': "邮箱不能为空"})
password = forms.CharField(max_length=120,
min_length=6,
required=True,
error_messages={'required': "密码不能为空"})
invite_code = forms.CharField(required=True,error_messages={'required': "验证码不能为空"})Frontend-Seite
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>register</title>
</head>
<body>
<p>
<form action="url" method="post" enctype="multipart/form-data">
<input type="text" name="username"/>
<input type="password" name="password"/>
<input type="text" name="code"/>
<input type="submit" value="submit"/>
</form>
</p>
</body>Backend-Ansichtsverarbeitung
def register(request):
if request.method == "POST":
f = Reg_Form(request.POST)
if f.is_valid():
user = f.cleaned_data["username"]
pwd = f.cleaned_data["password"]
code = f.cleaned_data["code"]
res_code = request.session.get("code", None)
result = models.UserInfo.objects.filter(userexact=user,pwdexact=pwd)
if code.upper() == res_code.upper() and result:
models.UserInfo.objects.filter(userexact=user).update(status=1)
request.session["user"] = user
return redirect("/home")
else:
return render(request, "register.html", {"error": f.errors, "form": f})else:return render(request, "register.html")Reg_Form(request.POST) verwendet die Formularklasse, um die übermittelten Daten zu verarbeiten und die Rechtmäßigkeit der zu überprüfen Daten, die logische Verarbeitung nach is_valid() ist legal, die überprüften Daten werden in den nach der Instanziierung zurückgegebenen clean_data gespeichert,
cleaned_data ist ein Wörterbuchdatenformat, Fehlerinformationen werden im Formular gespeichert. Wenn Sie beispielsweise alle Fehlerinformationen in Ansichten anzeigen möchtendrucken(f.Fehler), wenn Sie nur die Informationen des Benutzers sehen möchten, können Sie
print(form.errors['username'][0])
Wir Sie können die -Vorlage verwenden, um für die Fehlermeldung wieder auf die Startseite zu rendern, zum Beispiel
<form action="/form/" method="POST">
{% csrf_token %}
<p class="input-group">
{#接收后台传过来的form对象，自动生成input标签#}
{{ form.user }}
{#从后台传过来的error是字典，直接{{ error.user.0 }}呈现错误信息#}
{#如果后台返回了错误信息，将错误信息放入span标签，在页面显示，否则不显示#}
{% if error.username.0 %}
<span>{{ error.userusername.0 }}</span>
{% endif %}
</p>
<p class="input-group">
{{ form.password }}
{% if error.pwd.0 %}
<span>{{ error.password .0 }}</span>
{% endif %}
</p>
<p>
<input type="submit" value="提交" />
</p>
</form>3. Selbstgeneriertes Eingabefeld
Formularklasse
class RegisterForm(forms.Form):
style = 'form-control input-lg'
phone = forms.CharField(widget=forms.TextInput(attrs={'class': style,
'name': 'title'})),
required=True,
error_messages={'required': ugettext_lazy('*Required')})
code = forms.CharField(widget=forms.NumberInput(attrs={'placeholder': '验证码',
'class': style}),
min_length=4,
max_length=4,
required=True,
error_messages={'required': ugettext_lazy('*Required')})
password = forms.CharField(widget=forms.PasswordInput(attrs={'placeholder': '请输入密码',
'class': style}),
min_length=6,
required=True,
error_messages={'required': ugettext_lazy('*Required')})Ansichten
def register(request):
if request.method == "POST":
f = RegisterForm(request.POST)
if f.is_valid():
user = f.cleaned_data["username"]
pwd = f.cleaned_data["password"]
code = f.cleaned_data["code"]
res_code = request.session.get("CheckCode", None)
result = models.UserInfo.objects.filter(userexact=user,pwdexact=pwd)
if code.upper() == res_code.upper() and result:
models.UserInfo.objects.filter(userexact=user).update(status=1)
request.session["user"] = user
return redirect("/home")
else:
return render(request, "login.html", {"error": f.errors, "form": f})
else:
return render(request, "login.html", {"error": f.errors, "form": f})
else:
# 如果不是post提交数据，就不传参数创建对象，并将对象返回给前台，直接生成input标签，内容为空
f = Log_Form()
return render(request, "login.html", {"form": f})Frontend-Seite
<body>
<form action="/form/" method="POST">
{% csrf_token %}
<p class="input-group">
{# 接收后台传过来的form对象，自动生成input标签#}
{{ form.user }}
{# 从后台传过来的error是字典，直接{{ error.user.0 }}呈现错误信息#}
{# 如果后台返回了错误信息，将错误信息放入span标签，在页面显示，否则不显示#}
<p class="input-group">
{{ form.email }}
{% if error.email.0 %}
<span>{{ error.email.0 }}</span>
{% endif %}
</p>
<p class="input-group">
{{ form.password }}
{% if error.password.0 %}
<span>{{ error.password.0 }}</span>
{% endif %}
</p>
<p class="input-group">
{{ form.code }}
{% if error.book_type.0 %}
<span>{{ error.code.0 }}</span>
{% endif %}
</p>
<p>
<input type="submit" value="提交" />
</p>
</form>
</body>
</html>4. Die Formularvalidierung ist perfekt
docs.djangoproject.com/ en/dev/ref/forms/validation/
Die Reihenfolge der Formularüberprüfung lautet „init“, „clean“, „validate“, „save“
wobei „clean“ und „validate“ nacheinander im Formular aufgerufen werden.is_valid( ) Methode
saubere und andere Schritte. Ausnahme erhalten: Ausnahme Wert: Argument vom Typ „NoneType“ ist nicht iterierbar
Möglicherweise liegt ein bestimmter Feldwert vor „cleaned_data“ sollte eine Liste sein, ist aber eigentlich ein Nullwert.
Vergessen Sie beim Umschreiben der Clean-Methode nicht, clean_data zurückzugeben
Diese Art des Umschreibens kann dazu führen, dass die vom Benutzer übermittelten Daten nach der Erkennung im Formular an den Benutzer zurückgegeben werden Klasse und Ausführung der Logik nach der Verarbeitung der Daten ist keine weitere Verarbeitung und Rückgabe an den Benutzer erforderlich.
Ergänzung:
Viertens Initialisierungsmethoden des Formulars
① Instanziieren Sie oneform(initial={ 'onefield':value})
②Geben Sie einen Anfangswert an, wenn Sie ein Feld definieren oneformfield = forms.CharField(initial=value)
③Schreiben Sie die init()-Methode der Form-Klasse neu: self.fields ['onefield'].initial = value
④Bei der Übergabe des Parameters instanse an form (d. h. oneform(instanse=onemodel_instance)) wird der Die ersten drei Initialisierungsmethoden schlagen alle fehl, auch wenn init neu geschrieben wird. Rufen Sie es zuerst auf. Die init der übergeordneten Klasse verwendet erneut Methode ③, aber sie funktioniert immer noch nicht (nicht sehr cool).
Wenn Sie den Feldwert zu diesem Zeitpunkt neu initialisieren möchten, können Sie nur self.initial['title'] = value in init() verwenden und den Wert direkt dem anfänglichenAttribut Wörterbuch der Form-Klasse.
from django import forms
class RegisterForm(forms.Form):
email = forms.EmailField(required=True,
error_messages={'required': "邮箱不能为空"})
password = forms.CharField(max_length=120,
min_length=6,
required=True,
error_messages={'required': "密码不能为空"})
invite_code = forms.CharField(required=True,error_messages={'required': "验证码不能为空"})
def clean(self):
# 用户名
try:
email = self.cleaned_data['email']
except Exception as e:
raise forms.ValidationError(u"注册账号需为邮箱格式")
# 验证邮箱
user = User.objects.filter(username=email)
if user: # 邮箱已经被注册了
raise forms.ValidationError(u"邮箱已被注册")
# 密码
try:
password = self.cleaned_data['password']
except Exception as e:
print('except: ' + str(e))
raise forms.ValidationError(u"请输入至少6位密码")
return self.cleaned_dataDie oben beschriebene Methode zur Verwendung der Django-Formularüberprüfung in Python wird Ihnen hoffentlich weiterhelfen. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht Ich werde allen umgehend antworten. Ich möchte mich auch bei Ihnen allen für Ihre Unterstützung der chinesischen PHP-Website bedanken! Weitere verwandte Artikel zur Verwendung der Django-Formularvalidierung in Python finden Sie auf der chinesischen PHP-Website!