精华内容
下载资源
问答
  • Django表单

    2021-04-07 16:08:33
    类似模型,Django表单也由各种字段组成。表单可以自定义(forms.Form),也可以由模型Models创建(forms.ModelForm)。值得注意的是模型里用的是verbose_name来描述一个字段, 而表单用的是label。 下面是两个Cont

    什么是表单?何时使用表单?

    在web开发里表单的使用必不可少。表单用于让用户提交数据或上传文件,表单也用于让用户编辑已有数据。Django的表单Forms类的作用是把用户输入的数据转化成Python对象格式,便于后续操作(比如存储,修改)。

    自定义表单

    类似模型,Django表单也由各种字段组成。表单可以自定义(forms.Form),也可以由模型Models创建(forms.ModelForm)。值得注意的是模型里用的是verbose_name来描述一个字段, 而表单用的是label。

    下面是两个ContactForm的例子。一个自定义,一个从Model创建。

    from django import forms
    from .models import Contact
    
    
    class ContactForm1(forms.Form):
        
        name = forms.CharField(label="Your Name", max_length=255)
        email = forms.EmailField(label="Email address")
    
    
    class ContactForm2(forms.ModelForm):
        
        class Meta:
            model = Contact
            fields = ('name', 'email',)
    

    Django的常用做法是在app文件夹下创建一个forms.py,专门存放app中所定义的各种表单,这样方便集中管理表单。如果要使用上述表单,我们可以在视图views.py里把它们像模型一样import进来直接使用。

    表单实例化

    下面方法可以实例化一个空表单,但里面没有任何数据,可以通过 {{ form }}在模板中渲染。

    form = ContactForm()
    

    用户提交的数据可以通过以下方法与表单结合,生成与数据结合过的表单(Bound forms)。Django只能对Bound forms进行验证。

    form = ContactForm(data=request.POST, files=request.FILES)
    

    模板文件中使用form

    模板文件中我们可以通过{{ form.as_p }}, {{ form.as_li }} 和 {{ form.as_table }}中渲染表单。如果你想详细控制每个field的格式,你可以采取以下方式。

    {% block content %}
    <div class="form-wrapper">
       <form method="post" action="" enctype="multipart/form-data">
          {% csrf_token %}
          {% for field in form %}
               <div class="fieldWrapper">
            {{ field.errors }}
            {{ field.label_tag }} {{ field }}
            {% if field.help_text %}
                 <p class="help">{{ field.help_text|safe }}</p>
            {% endif %}
               </div>
            {% endfor %}
          <div class="button-wrapper submit">
             <input type="submit" value="Submit" />
          </div>
       </form>
    </div>
    {% endblock %}
    

    表单实际使用案例

    我们现在需要设计一个表单让用户完成注册。我们先在app目录下新建forms.py, 然后创建一个RegistrationForm。代码如下:

    from django import forms
    from django.contrib.auth.models import User
    
    
    class RegistrationForm(forms.Form):
    
        username = forms.CharField(label='Username', max_length=50)
        email = forms.EmailField(label='Email',)
        password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
        password2 = forms.CharField(label='Password Confirmation', widget=forms.PasswordInput)
    

    当然你也可以不用新建forms.py而直接在html模板里写表单,但我并不建议这么做。用forms.py的好处显而易见:

    • 所有的表单在一个文件里,非常便于后期维护,比如增添或修订字段。
    • forms.py可通过clean方法自定义表单验证,非常便捷(见后文)。

    我们使用RegistrationForm的视图views.py是这样子的。

    from django.shortcuts import render, get_object_or_404
    from django.contrib.auth.models import User
    from .forms import RegistrationForm
    from django.http import HttpResponseRedirect
    
    
    def register(request):
        if request.method == 'POST':
    
            form = RegistrationForm(request.POST)
            if form.is_valid():
                username = form.cleaned_data['username']
                email = form.cleaned_data['email']
                password = form.cleaned_data['password2']
                # 使用内置User自带create_user方法创建用户,不需要使用save()
                user = User.objects.create_user(username=username, password=password, email=email)
                # 如果直接使用objects.create()方法后不需要使用save()
                return HttpResponseRedirect("/accounts/login/")
    
        else:
            form = RegistrationForm()
    
        return render(request, 'users/registration.html', {'form': form})
    

    我们来看下RegistrationForm是怎么工作的:

    • 当用户通过POST方法提交表单,我们将提交的数据与RegistrationForm结合,然后验证表单RegistrationForm的数据是否有效。

    • 如果表单数据有效,我们先用Django User模型自带的create_user方法创建user对象,再创建user_profile。用户通过一张表单提交数据,我们实际上分别存储在两张表里。

    • 如果用户注册成功,我们通过HttpResponseRedirect方法转到登陆页面

    • 如果用户没有提交表单或不是通过POST方法提交表单,我们转到注册页面,生成一张空的RegistrationForm

    表单的验证

    每个forms类可以通过clean方法自定义表单验证。如果你只想对某些字段进行验证,你可以通过clean_字段名方式自定义表单验证。如果用户提交的数据未通过验证,会返回ValidationError,并呈现给用户。如果用户提交的数据有效form.is_valid(),则会将数据存储在cleaned_data里。

    在上述用户注册的案例里,我们在RegistrationForm通过clean方法添加了用户名验证,邮箱格式验证和密码验证。代码如下。

    from django import forms
    from django.contrib.auth.models import User
    import re
    
    
    def email_check(email):
        pattern = re.compile(r"\"?([-a-zA-Z0-9.`?{}]+@\w+\.\w+)\"?")
        return re.match(pattern, email)
    
    
    class RegistrationForm(forms.Form):
    
        username = forms.CharField(label='Username', max_length=50)
        email = forms.EmailField(label='Email',)
        password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
        password2 = forms.CharField(label='Password Confirmation', widget=forms.PasswordInput)
    
        # Use clean methods to define custom validation rules
    
        def clean_username(self):
            username = self.cleaned_data.get('username')
    
            if len(username) < 6:
                raise forms.ValidationError("Your username must be at least 6 characters long.")
            elif len(username) > 50:
                raise forms.ValidationError("Your username is too long.")
            else:
                filter_result = User.objects.filter(username__exact=username)
                if len(filter_result) > 0:
                    raise forms.ValidationError("Your username already exists.")
    
            return username
    
        def clean_email(self):
            email = self.cleaned_data.get('email')
    
            if email_check(email):
                filter_result = User.objects.filter(email__exact=email)
                if len(filter_result) > 0:
                    raise forms.ValidationError("Your email already exists.")
            else:
                raise forms.ValidationError("Please enter a valid email.")
    
            return email
    
        def clean_password1(self):
            password1 = self.cleaned_data.get('password1')
    
            if len(password1) < 6:
                raise forms.ValidationError("Your password is too short.")
            elif len(password1) > 20:
                raise forms.ValidationError("Your password is too long.")
    
            return password1
    
        def clean_password2(self):
            password1 = self.cleaned_data.get('password1')
            password2 = self.cleaned_data.get('password2')
    
            if password1 and password2 and password1 != password2:
                raise forms.ValidationError("Password mismatch. Please enter again.")
    
            return password2
    

    通用视图里使用表单

    在Django基于类的视图(Class Based View)里使用表单也非常容易,只需定义form_class就好了。下面是一个创建一篇新文章的例子。

    from django.views.generic.edit import CreateView
    from .models import Article
    from .forms import ArticleForm
    
    
    class ArticleCreateView(CreateView):
        model = Article
        form_class = ArticleForm
        template_name = 'blog/article_create_form.html'
    
    

    自定义表单输入的widget

    Django forms的每个字段你都可以选择你喜欢的输入widget,比如多选,复选框。你还可以定义每个widget的css属性。如果你不指定,Django会使用默认的widget,有时比较丑。

    比如下面这段代码定义了表单姓名字段的输入控件为Textarea,还指定了其样式css。

    from django import forms
    
    
    class ContactForm(forms.Form):
        name = forms.CharField(
            max_length=255,
            widget=forms.Textarea(
                attrs={'class': 'custom'},
            ),
        )
    

    设置widget可以是你的表单大大美化,方便用户选择输入。比如下面案例里对年份使用了SelectDateWidget,颜色则使用了复选框CheckboxSelectMultiple。单选可以用RadioSelect和Select。常见文本输入可以用TextInput和TextArea。

    from django import forms
    
    BIRTH_YEAR_CHOICES = ('1980', '1981', '1982')
    COLORS_CHOICES = (
        ('blue', 'Blue'),
        ('green', 'Green'),
        ('black', 'Black'),
    )
    
    class SimpleForm(forms.Form):
        birth_year = forms.DateField(widget=forms.SelectDateWidget(years=BIRTH_YEAR_CHOICES))
        favorite_colors = forms.MultipleChoiceField(
            required=False,
            widget=forms.CheckboxSelectMultiple,
            choices=COLORS_CHOICES,
        )
    

    表单数据初始化

    有时我们需要对表单设置一些初始数据,我们可以通过initial方法,如下所示。

    form = ContactForm(
        initial={
            'name': 'First and Last Name',
        },)
    

    其编辑修改类应用场景中,我们还要给表单提供现有对象的数据,而不是渲染一张空表单,这时我们可这么做。该方法仅适用于由模型创建的ModelForm,而不适用于自定义的表单。

    contact = Contact.objects.get(id=1)
    form =  ContactForm(instance = contact)
    对于自定义的表单,可以设置default_data。
    
    
    default_data = {'name': 'John', 'email': 'someone@hotmail.com', }
    form = ContactForm(default_data)
    

    Formset的使用

    有的时候用户需要在1个页面上使用多个表单,比如一次性提交添加多本书的信息,这时我们可以使用formset。这是一个表单的集合。

    创建一个FormSet我们可以这么做:

    from django import forms
    
    
    class BookForm(forms.Form):
        name = forms.CharField(max_length=100)
        title = forms.CharField()
        pub_date = forms.DateField(required=False)
    
    
    #forms.py - build a formset of books
    
    from django.forms import formset_factory
    from .forms import BookForm
    
    #extra: 额外的空表单数量
    #max_num: 包含表单数量(不含空表单)
    
    BookFormSet = formset_factory(BookForm, extra=2, max_num=1)
    

    在视图文件views.py里,我们可以像使用form一样使用formset。

    #views.py - formsets example.
    from .forms import BookFormSet
    from django.shortcuts import render
    
    def manage_books(request):
        if request.method == 'POST':
            formset = BookFormSet(request.POST, request.FILES)
            if formset.is_valid():
                # do something with the formset.cleaned_data
                pass
        else:
            formset = BookFormSet()
        return render(request, 'manage_books.html', {'formset': formset})
    

    模板里可以这样使用formset。

    <form action=”.” method=”POST”>
    {{ formset }}
    </form>
    
    展开全文
  • Django的“ formtools”是Django表单的一组高级抽象。 当前用于表单预览和多步骤表单。 该代码曾经在django.contrib.formtools中的Django中正常使用,但在Django 1.8中被分成独立的软件包,以保持框架的核心干净。...
  • 以下是Django框架获取各种form表单数据的方法 Django中获取text,password 名字:<input type="text" name="name"> <br>  密码:<input type="password" name="password">  Form表单提交数据...
  • Django 表单

    万次阅读 2020-09-08 11:43:54
    Django 表单 HTML表单是网站交互性的经典方式。 本章将介绍如何用Django对用户提交的表单数据进行处理。 HTTP 请求 HTTP协议以"请求-回复"的方式工作。客户发送请求时,可以在请求中附加数据。服务器通过解析请求...

    Django 表单

    HTML表单是网站交互性的经典方式。 本章将介绍如何用Django对用户提交的表单数据进行处理。


    HTTP 请求

    HTTP协议以"请求-回复"的方式工作。客户发送请求时,可以在请求中附加数据。服务器通过解析请求,就可以获得客户传来的数据,并根据URL来提供特定的服务。

    GET 方法

    我们在之前的项目中创建一个 search.py 文件,用于接收用户的请求:

    /HelloWorld/HelloWorld/search.py 文件代码:

    from django.http import HttpResponse 
    from django.shortcuts import render # 表单 
    def search_form(request):    
    	return render(request, 'search_form.html')  # 接收请求数据 
    def search(request):      
    	request.encoding='utf-8'    
    	if 'q' in request.GET and request.GET['q']:        
    		message = '你搜索的内容为: ' + request.GET['q']    
    	else:        
    		message = '你提交了空表单'    
    	return HttpResponse(message)
    

    在模板目录 templates 中添加 search_form.html 表单:

    /HelloWorld/templates/search_form.html 文件代码:

    <!DOCTYPE html> 
    <html> 
    	<head> 
    		<meta charset="utf-8"> 
    			<title>菜鸟教程(runoob.com)</title> 
    		</head> 
    		<body>    
    		<form action="/search" method="get">        
    			<input type="text" name="q">        
    			<input type="submit" value="搜索">    
    		</form> 
    	</body> 
    </html>
    

    urls.py 规则修改为如下形式:

    /HelloWorld/HelloWorld/urls.py 文件代码:

    from django.conf.urls import url 
    from . import view,testdb,search  
    urlpatterns = [    
    	url(r'^hello$', views.runoob),    
    	url(r'^testdb$', testdb.testdb),    
    	url(r'^search-form$', search.search_form),    
    	url(r'^search$', search.search),
     ]
    

    访问地址 http://127.0.0.1:8000/search-form 并搜索,结果如下所示:

    img

    POST 方法

    上面我们使用了GET方法。视图显示和请求处理分成两个函数处理。

    提交数据时更常用POST方法。我们下面使用该方法,并用一个URL和处理函数,同时显示视图和处理请求。

    我们在 templates 创建 post.html:

    /HelloWorld/templates/post.html 文件代码:

    <!DOCTYPE html> 
    <html> 
    	<head> 
    	<meta charset="utf-8"> 
    		<title>菜鸟教程(runoob.com)</title> 
    	</head> 
    	<body>    
    	<form action="/search-post" method="post">        
    		{% csrf_token %}        
    		<input type="text" name="q">        
    		<input type="submit" value="Submit">    
    	</form>     
    	<p>{{ rlt }}</p> 
    	</body> 
    </html>
    

    在模板的末尾,我们增加一个 rlt 记号,为表格处理结果预留位置。

    表格后面还有一个{% csrf_token %}的标签。csrf 全称是 Cross Site Request Forgery。这是Django提供的防止伪装提交请求的功能。POST 方法提交的表格,必须有此标签。

    在HelloWorld目录下新建 search2.py 文件并使用 search_post 函数来处理 POST 请求:

    /HelloWorld/HelloWorld/search2.py 文件代码:

    \# -*- coding: utf-8 -*-  
    from django.shortcuts import render 
    from django.views.decorators import csrf  # 接收POST请求数据 
    def search_post(request):    
    	ctx ={}    
    if request.POST:        
    	ctx['rlt'] = request.POST['q']    
    	return render(request, "post.html", ctx)
    

    urls.py 规则修改为如下形式:

    /HelloWorld/HelloWorld/urls.py 文件代码:

    from django.conf.urls import url from . import view,testdb,search,search2  
    urlpatterns = [   
    	 url(r'^hello$', view.hello),    
    	 url(r'^testdb$', testdb.testdb),    
    	 url(r'^search-form$', search.search_form),    
    	 url(r'^search$', search.search),    
    	 url(r'^search-post$', search2.search_post),
      ]
    

    访问 http://127.0.0.1:8000/search-post 显示结果如下:

    img

    完成以上实例后,我们的目录结构为:

    HelloWorld
    |-- HelloWorld
    |   |-- __init__.py
    |   |-- __init__.pyc
    |   |-- search.py
    |   |-- search.pyc
    |   |-- search2.py
    |   |-- search2.pyc
    |   |-- settings.py
    |   |-- settings.pyc
    |   |-- testdb.py
    |   |-- testdb.pyc
    |   |-- urls.py
    |   |-- urls.pyc
    |   |-- view.py
    |   |-- view.pyc
    |   |-- wsgi.py
    |   `-- wsgi.pyc
    |-- TestModel
    |   |-- __init__.py
    |   |-- __init__.pyc
    |   |-- admin.py
    |   |-- admin.pyc
    |   |-- apps.py
    |   |-- migrations
    |   |   |-- 0001_initial.py
    |   |   |-- 0001_initial.pyc
    |   |   |-- __init__.py
    |   |   `-- __init__.pyc
    |   |-- models.py
    |   |-- models.pyc
    |   |-- tests.py
    |   `-- views.py
    |-- db.sqlite3
    |-- manage.py
    `-- templates
        |-- base.html
        |-- hello.html
        |-- post.html
        `-- search_form.html
    

    Request 对象

    每个视图函数的第一个参数是一个 HttpRequest 对象,就像下面这个 runoob() 函数:

    from django.http import HttpResponse
    
    def runoob(request):
        return HttpResponse("Hello world")
    

    HttpRequest对象包含当前请求URL的一些信息:

    属性描述
    path请求页面的全路径,不包括域名—例如, “/hello/”。
    method请求中使用的HTTP方法的字符串表示。全大写表示。例如:if request.method == ‘GET’: do_something() elif request.method == ‘POST’: do_something_else()
    GET包含所有HTTP GET参数的类字典对象。参见QueryDict 文档。
    POST包含所有HTTP POST参数的类字典对象。参见QueryDict 文档。服务器收到空的POST请求的情况也是有可能发生的。也就是说,表单form通过HTTP POST方法提交请求,但是表单中可以没有数据。因此,不能使用语句if request.POST来判断是否使用HTTP POST方法;应该使用if request.method == “POST” (参见本表的method属性)。注意: POST不包括file-upload信息。参见FILES属性。
    REQUEST为了方便,该属性是POST和GET属性的集合体,但是有特殊性,先查找POST属性,然后再查找GET属性。借鉴PHP’s $_REQUEST。例如,如果GET = {“name”: “john”} 和POST = {“age”: ‘34’},则 REQUEST[“name”] 的值是"john", REQUEST[“age”]的值是"34".强烈建议使用GET and POST,因为这两个属性更加显式化,写出的代码也更易理解。
    COOKIES包含所有cookies的标准Python字典对象。Keys和values都是字符串。
    FILES包含所有上传文件的类字典对象。FILES中的每个Key都是标签中name属性的值. FILES中的每个value 同时也是一个标准Python字典对象,包含下面三个Keys:filename: 上传文件名,用Python字符串表示content-type: 上传文件的Content typecontent: 上传文件的原始内容注意:只有在请求方法是POST,并且请求页面中有enctype="multipart/form-data"属性时FILES才拥有数据。否则,FILES 是一个空字典。
    META包含所有可用HTTP头部信息的字典。 例如:CONTENT_LENGTHCONTENT_TYPEQUERY_STRING: 未解析的原始查询字符串REMOTE_ADDR: 客户端IP地址REMOTE_HOST: 客户端主机名SERVER_NAME: 服务器主机名SERVER_PORT: 服务器端口META 中这些头加上前缀 HTTP_ 为 Key, 冒号(:)后面的为 Value, 例如:HTTP_ACCEPT_ENCODINGHTTP_ACCEPT_LANGUAGEHTTP_HOST: 客户发送的HTTP主机头信息HTTP_REFERER: referring页HTTP_USER_AGENT: 客户端的user-agent字符串HTTP_X_BENDER: X-Bender头信息
    user是一个django.contrib.auth.models.User 对象,代表当前登录的用户。如果访问用户当前没有登录,user将被初始化为django.contrib.auth.models.AnonymousUser的实例。你可以通过user的is_authenticated()方法来辨别用户是否登录:if request.user.is_authenticated(): # Do something for logged-in users. else: # Do something for anonymous users.只有激活Django中的AuthenticationMiddleware时该属性才可用
    session唯一可读写的属性,代表当前会话的字典对象。只有激活Django中的session支持时该属性才可用。
    raw_post_data原始HTTP POST数据,未解析过。 高级处理时会有用处。

    Request对象也有一些有用的方法:

    方法描述
    getitem(key)返回GET/POST的键值,先取POST,后取GET。如果键不存在抛出 KeyError。 这是我们可以使用字典语法访问HttpRequest对象。 例如,request[“foo”]等同于先request.POST[“foo”] 然后 request.GET[“foo”]的操作。
    has_key()检查request.GET or request.POST中是否包含参数指定的Key。
    get_full_path()返回包含查询字符串的请求路径。例如, “/music/bands/the_beatles/?print=true”
    is_secure()如果请求是安全的,返回True,就是说,发出的是HTTPS请求。

    QueryDict对象

    在HttpRequest对象中, GET和POST属性是django.http.QueryDict类的实例。

    QueryDict类似字典的自定义类,用来处理单键对应多值的情况。

    QueryDict实现所有标准的词典方法。还包括一些特有的方法:

    方法描述
    getitem和标准字典的处理有一点不同,就是,如果Key对应多个Value,getitem()返回最后一个value。
    setitem设置参数指定key的value列表(一个Python list)。注意:它只能在一个mutable QueryDict 对象上被调用(就是通过copy()产生的一个QueryDict对象的拷贝).
    get()如果key对应多个value,get()返回最后一个value。
    update()参数可以是QueryDict,也可以是标准字典。和标准字典的update方法不同,该方法添加字典 items,而不是替换它们:>>> q = QueryDict('a=1') >>> q = q.copy() # to make it mutable >>> q.update({'a': '2'}) >>> q.getlist('a') ['1', '2'] >>> q['a'] # returns the last ['2']
    items()和标准字典的items()方法有一点不同,该方法使用单值逻辑的__getitem__():>>> q = QueryDict('a=1&a=2&a=3') >>> q.items() [('a', '3')]
    values()和标准字典的values()方法有一点不同,该方法使用单值逻辑的__getitem__():

    此外, QueryDict也有一些方法,如下表:

    方法描述
    copy()返回对象的拷贝,内部实现是用Python标准库的copy.deepcopy()。该拷贝是mutable(可更改的) — 就是说,可以更改该拷贝的值。
    getlist(key)返回和参数key对应的所有值,作为一个Python list返回。如果key不存在,则返回空list。 It’s guaranteed to return a list of some sort…
    setlist(key,list_)设置key的值为list_ (unlike setitem()).
    appendlist(key,item)添加item到和key关联的内部list.
    setlistdefault(key,list)和setdefault有一点不同,它接受list而不是单个value作为参数。
    lists()和items()有一点不同, 它会返回key的所有值,作为一个list, 例如:>>> q = QueryDict('a=1&a=2&a=3') >>> q.lists() [('a', ['1', '2', '3'])]
    urlencode()返回一个以查询字符串格式进行格式化后的字符串(例如:“a=2&b=3&b=5”)。
    展开全文
  • Django表单中的CSS样式

    2021-08-05 01:42:52
    考虑以这种方式呈现表单:{{ form.non_field_errors }}{{ form.subject.errors }}{{ form.subject.label_tag }}{{ form.subject }}{{ form.subject.help_text }}form.subject是BoundField具有该as_widget()方法的...

    小编典典

    可以使用自定义模板过滤器来完成。考虑以这种方式呈现表单:

    {{ form.non_field_errors }}

    {{ form.subject.errors }}

    {{ form.subject.label_tag }}

    {{ form.subject }}

    {{ form.subject.help_text }}

    form.subject是BoundField具有该as_widget()方法的实例。

    你可以addclass在my_app / templatetags / myfilters.py中创建自定义过滤器:

    from django import template

    register = template.Library()

    @register.filter(name='addclass')

    def addclass(value, arg):

    return value.as_widget(attrs={'class': arg})

    然后应用你的过滤器:

    {% load myfilters %}

    {{ form.non_field_errors }}

    {{ form.subject.errors }}

    {{ form.subject.label_tag }}

    {{ form.subject|addclass:'MyClass' }}

    {{ form.subject.help_text }}

    form.subjects然后将使用MyClassCSS类呈现。

    2020-03-26

    展开全文
  • Django项目模板 Django项目模板
  • Django Simple Captcha Django Simple Captcha是一个非常简单但高度可定制的Django应用程序,用于将Captcha图像添加到任何Django表单中。 功能非常易于设置和部署,但也很容易配置Django Simple Captcha Django ...
  • 其实 django 已经为我们提供了一些可用的表单控件,比如:多选框、单选按钮等,下面就以单选按钮为例: # forms.py from django import forms from .models import MyModel class MyForm(forms.ModelForm): xxx = ...
  • 然后将表单提交回页面,得到一组经过筛选的注释,并返回并呈现。这里有一个视图解决方案,它可以更好地实现您想要的功能,但更全面地使用基于类的通用视图。在class FilterCommentsUIView(Fo...

    正如其他人所说,你对所有代码都在get_context_data中这一事实有异议。实际上,您甚至不需要使用get_context_data来完成您要做的事情。在

    据我所见,你试图在页面上得到评论。然后将表单提交回页面,得到一组经过筛选的注释,并返回并呈现。这里有一个视图解决方案,它可以更好地实现您想要的功能,但更全面地使用基于类的通用视图。在class FilterCommentsUIView(FormMixin, ListView):

    template_name = 'allcomments.html'

    form_class = CommentFilterForm

    paginate_by = 20

    model = Item

    context_object_name = 'comments'

    qs_kwargs = {}

    def post(self, request, *args, **kwargs):

    """

    Handles POST requests, instantiating a form instance with the passed

    POST variables and then checked for validity.

    """

    form_class = self.get_form_class()

    form = self.get_form(form_class)

    if form.is_valid():

    return self.form_valid(form)

    else:

    return self.form_invalid(form)

    def get_queryset(self):

    qs = super(FilterCommentsUIView, self).get_queryset()

    if self.qs_kwargs:

    return qs.filter(**self.qs_kwargs)

    return qs

    def form_valid(self, form):

    parenttype = form.cleaned_data['pchoice']

    users = form.cleaned_data('users')

    tags = form.cleaned_data('tags')

    fdate = form.cleaned_data('fdate')

    tdate = form.cleaned_data('tdate')

    typeuser = form.cleaned_data('typeuser')

    query = form.cleaned_data('query')

    userid = User.objects.get(username ='pavan')

    # put logic here on what to expand into a filter on orm

    self.qs_kwargs['user'] = userid.id

    self.render_to_response(self.get_context_data())

    我还没有运行这段代码,但它应该是这样工作的。在

    这将使用FormMixin为我们提供表单功能以及您的Item类的ListView。这将负责查询对象并对它们进行分页,以及一个基本的get方法。在

    另外,ListView继承自TemplateResponseMixin,它有你的模板代码,所以你不需要从TemplateView继承,所以在上面的代码中我删除了它。在

    根据基础View类的本质,ListView使用dispatch方法检测您是否正在执行GET、POST、PUT、DELETE等。。。因此,它在视图上调用适当的方法。在本例中,由于您正在执行POST,因此它将在视图中调用post方法。FormView的post实现如下:

    ^{pr2}$

    因为我们没有使用FormView,而是使用FormMixin,所以我们需要包括它。在

    所以它所做的就是让您在self.form_class中设置的form类实例化它,然后检查它是否有效。如果是这样,则调用form_valid方法。因此,我们重写了上面的form_valid方法。因为它与它一起传递表单,并且它已经清除了所有数据,所以我们可以使用form.cleaned_data的普通django格式。这有助于我们的安全性,因此我们应该使用它来获取信息。在

    在form_valid方法的最后一部分,我们返回render_to_response。通常这只是重定向到self.success_url,但我们希望呈现页面,所以我们只需执行render-to-u响应并将其传递到上下文数据中。我们称之为self.get_context_data(),因为这是为我们需要的注释分页而构建的所有数据。在

    现在有点magic。如果你注意到有self.qs_kwargs。这通常不在GCBV中,但我为这个实现添加了一些内容。在这里,您可以在get_queryset中的orm调用中构建过滤器字典。{31>如果我们需要把它打包到cd31>中,因为我们需要把它打包到cd31>中。在

    如果你有:

    qs_kwargs = {'user': user.id, 'created__gt': somedate}

    你也会:

    qs.filter(**qs_kwargs)或{}

    这与以下操作大致相同:

    qs.filter(user=user.id, created__gt=somedate)或{}

    最后,如果您注意get_queryset方法,您会注意到它会返回所有结果,就像您想要的那样,除非填充了qs_kwargs,这是从form_valid方法发生的。所以它考虑了页面上的GET和{}。在

    同样为了简单起见,您的html应该如下所示:

    {% for comment in comments %}

    {{ comment }}

    {% endfor %}

    {% if page_obj.has_previous() %}

    Previous

    {% endif %}

    {% for pg in paginator.page_range %}

    {% if page_obj.number == pg %}

    {{ pg }}

    {% else %}

    {{ pg }}

    {% endif %}

    {% endfor %}

    {% if page_obj.has_next() %}

    Next

    {% endif %}

    {% csrf_token %}

    {{ form.as_p }}

    希望有帮助。在

    展开全文
  • 1.form表单提交数据的三个数据1、form标签必须要有action和method属性2、所有获取用户输入的标签必须有name属性3、必须有submit按钮2、Django 三件套from django.shortcuts import HttpResponse,render,rediect1、...
  • Django表单层字段解释

    2021-11-17 17:02:02
    前言 这几年一直在it行业里摸爬滚打,一路走来,不少总结了一些python行业里的高频面试,看到大部分初入行的新鲜血液,还在为各样的面试题答案或收录有各种困难问题 于是乎,我自己开发了一款面试宝典...django提供了一
  • django-money:Django表单和模型的Money字段
  • Django表单字段如:forms.CharField, forms.EmailField等,会默认传入参数required=True,也就是默认表单字段不能为空,如果对html5新特性不了解,会以为这仅仅是控制相应表单不能为空。 然后会碰到一个很奇怪的现象...
  • 我的Save按钮没有将用户输入的数据以django形式保存到数据库中,问题在哪里?在模型.pyclass Cemetery(models.Model):id = models.AutoField(primary_key=True)name=models.CharField(verbose_name="Cemetery Name",...
  • Django表单重新加载数据的精确副本 首先,orgList是在表单定义中求值的,这就是选择不变的原因。 您应该将getOrgUnitList放置在表单的__init__中(或其他某种方法中)。 其次,您不向表单传递任何数据,可能是您想要 ...
  • 本文基于Django 表单验证一文,补充完善表单验证器之自定义表单验证器 具体步骤总结如下: 第一:在formValidation.py 文件中,添加自定义名称敏感验证器(NameValidation) # 自定义名称敏感校验器 class ...
  • python - 如何构建多个提交按钮django表单?我有一个输入电子邮件的表单和两个提交按钮来订阅和取消订阅时事通讯:{{ form_newsletter }}我也有课堂形式:class NewsletterForm(forms.ModelForm):class Meta:model =...
  • 表单如此: 如何获取表单上交的信息呢? def add(request): name=request.POST.get('name') # request.POST.get(标签名称name属性) score=request.POST.get('score') context = { 'name': name, 'sc...
  • django表单forms实现下拉列表(Select)

    千次阅读 2018-06-01 20:23:48
    from django import forms from blog.models import * CATEGORY = Category.objects.all() class ArticleForm(forms.Form): title = forms.CharField(required=True, max_length=50) content = forms.Char...
  • 源码包括: 1、django的原生Form表单数据验证。 2、Ajax方式的Form表单数据验证
  • 一、表单类型 1、Django内置字段如下: Field # 有Field类型,其他类型基本都有Field类型的字段 required=True, 是否允许为空 widget=None, HTML插件 label=None, 用于生成Label标签或显示内容 init...
  • 前言不要将Widget与表单的fields字段混淆。表单字段负责验证输入并直接在模板中使用。而Widget负责渲染网页上HTML表单的输入元素和提取提交的原始数据。widget是字段的一个内在属性,用于定义字段在浏览器的页面里以...
  • 目录:1.Form 基本使用django中的Form组件有以下几个功能:生成HTML标签验证用户数据(显示错误信息)HTML Form提交保留上次提交数据初始化页面显示内容2.Form中字段及...1.Django内置字段如下:Field:required=True, ...
  • layui图片上传功能,和表单同步上传或只上传表单,若看不懂,文件里有完整项目分享

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,632
精华内容 13,052
关键字:

django表单

友情链接: G1120TB105GG资料.zip