Maison > Article > développement back-end > Comment utiliser la validation de formulaire Django en Python

Comment utiliser la validation de formulaire Django en Python

高洛峰original: 2017-03-30 17:20:432096parcourir

1. django pourmValidation du formulaire Introduction

Parfois, nous devons utiliser get, post, put, etc. pour soumettre certaines données à l'exemple de traitement en arrière-plan sur la page HTML frontale ;

<!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 -fin de soumission et acquisition d'arrière-plan :

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))

Cela complète la fonction de base et est fondamentalement prêt à être utilisé

Cependant, si la saisie de l'utilisateur le fait. ne respectez pas les exigences (comme un numéro de téléphone portable). La longueur des données saisies est de 11 chiffres, la complexité du mot de passe, etc.), et les données qui ont été saisies seront perdues lorsque vous reviendrez après la soumission

Bien sûr, si nous obtenons manuellement toutes les données après leur saisie dans les vues, les transmettre à la page Web est réalisable, mais c'est très gênant, donc Django fournit des formulaires plus simples et plus faciles à utiliser pour résoudre une série. de problèmes tels que la vérification

. Ici, je dois mentionner la véritable bibliothèque de plug-ins de Django. Elle est très puissante, simple et facile à développer. Le contenu ci-dessus présente uniquement pourquoi le formulaire doit être utilisé. sur l'enregistrement de l'utilisation du formulaire Django

2. Application de vérification du formulaire

Doit être créé dans l'application Django Un module form.py, le contenu spécifique est le suivant

class RegisterForm(forms.Form):
  email = forms.EmailField(required=True,
               error_messages={&#39;required&#39;: "邮箱不能为空"})
  password = forms.CharField(max_length=120,
                min_length=6,
                required=True,
                error_messages={&#39;required&#39;: "密码不能为空"})
  invite_code = forms.CharField(required=True,error_messages={&#39;required&#39;: "验证码不能为空"})

Page d'accueil

<!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>

Traitement des vues backend

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) utilise la classe de formulaire Pour traiter les données soumises afin de vérifier la légalité du data, le traitement logique après is_valid() est légal, les données vérifiées sont enregistrées dans les cleaning_data renvoyées après l'instanciation,

cleaned_data est un format de données de dictionnaire, Les informations d'erreur sont enregistrées sous forme. Par exemple, si vous souhaitez afficher toutes les informations sur les erreurs dans les vuesimprimer(f.errors), si vous souhaitez uniquement voir les informations de l'utilisateur, vous pouvez

 print(form.errors[&#39;username&#39;][0])

Nous. peut utiliser le modèle pour afficher vers la page frontale du message d'erreur, par exemple

<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. Zone de saisie auto-générée

Classe de formulaire

class RegisterForm(forms.Form):
  style = &#39;form-control input-lg&#39;
  phone = forms.CharField(widget=forms.TextInput(attrs={&#39;class&#39;: style,
                              &#39;name&#39;: &#39;title&#39;})),
              required=True,
              error_messages={&#39;required&#39;: ugettext_lazy(&#39;*Required&#39;)})
  code = forms.CharField(widget=forms.NumberInput(attrs={&#39;placeholder&#39;: &#39;验证码&#39;,
                              &#39;class&#39;: style}),
              min_length=4,
              max_length=4,
              required=True,
              error_messages={&#39;required&#39;: ugettext_lazy(&#39;*Required&#39;)})
  password = forms.CharField(widget=forms.PasswordInput(attrs={&#39;placeholder&#39;: &#39;请输入密码&#39;,
                                 &#39;class&#39;: style}),
                min_length=6,
                required=True,
                error_messages={&#39;required&#39;: ugettext_lazy(&#39;*Required&#39;)})

vues

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})

Page frontale

<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. La validation du formulaire est parfaite

docs.djangoproject.com/ fr/dev/ref/forms/validation/

L'ordre d'exécution de la vérification du formulaire est init, clean, validate, save

où clean et validate seront appelés successivement dans le form.is_valid( ) méthode

clean et autres étapes. Exception reçue : Exception Valeur : l'argument de type 'NoneType' n'est pas itérable

Il se peut qu'une certaine valeur de champ soit présente dans. clean_data devrait être une liste, mais il s'agit en fait d'une valeur nulle.

Lors de la réécriture de la méthode clean, n'oubliez pas de renvoyer les données nettoyées

Ce type de réécriture peut faire en sorte que les données soumises par l'utilisateur renvoient les données à l'utilisateur après avoir effectué la détection dans le formulaire classe et effectuer une logique une fois le traitement des données légal, il n'est pas nécessaire d'effectuer un traitement supplémentaire et de revenir à l'utilisateur, ce qui est plus pratique et raisonnable

Supplémentaire :

5. méthodes d'initialisation du formulaire

① Instancier oneform(initial={ 'onefield':value})

②Donner une valeur initiale lors de la définition d'un champ oneformfield = Forms.CharField(initial=value)

③Réécrivez la méthode init() de la classe Form : self.fields ['onefield'].initial = value

④Lorsque vous passez le paramètre instanse au formulaire (c'est-à-dire oneform(instanse=onemodel_instance)), le Les trois premières méthodes d'initialisation échoueront toutes. Même lors de la réécriture de init, appelez-le d'abord. L'initialisation de la classe parent utilise à nouveau la méthode ③, mais cela ne fonctionne toujours pas (pas très cool).

Si vous souhaitez réinitialiser la valeur du champ à ce moment, vous ne pouvez utiliser que self.initial['title'] = value dans init(), et attribuer directement la valeur à l'attribut initial dictionnaire de la classe Form.

from django import forms
class RegisterForm(forms.Form):
  email = forms.EmailField(required=True,
               error_messages={&#39;required&#39;: "邮箱不能为空"})
  password = forms.CharField(max_length=120,
                min_length=6,
                required=True,
                error_messages={&#39;required&#39;: "密码不能为空"})
  invite_code = forms.CharField(required=True,error_messages={&#39;required&#39;: "验证码不能为空"})
  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_data

Ce qui précède est la méthode d'utilisation de la vérification du formulaire Django en Python introduite par l'éditeur. J'espère qu'elle vous sera utile. Si vous avez des questions, veuillez me laisser un message ainsi qu'à l'éditeur. répondra rapidement à tout le monde. Je voudrais également vous remercier tous pour votre soutien au site Web PHP chinois !

Pour plus d'articles sur l'utilisation de la validation de formulaire Django en Python, veuillez faire attention au site Web PHP chinois !

Déclaration：

Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Article précédent：Python Django utilise des formulaires pour implémenter la fonctionnalité de commentairesArticle suivant：Python Django utilise des formulaires pour implémenter la fonctionnalité de commentaires

Articles Liés

Voir plus