django 记录六Form、ModelForm和modelformset_factory

于 2020-07-21 10:44:40 发布
阅读量1.1k 收藏 9
点赞数 1
分类专栏： web框架 # django框架
原文链接：https://www.cnblogs.com/clschao/articles/10486468.html#top
版权

django form组件

  • 生成页面可用的HTML页面
  • 对用户提交的数据进行校验
  • 保留上次输入的内容

 

基本示例

# views

from django.shortcuts import render, HttpResponse
from django import forms


class RegForm(forms.Form):
    name = forms.CharField(
        required=True,              # 是否为空
        label='用户名',             # 定义前端页面显示名字
        min_length=6,               # 定义规则
        initial='user',             # 给一个默认值
        help_text='请输入用户名',   # 文本提示
        error_messages={'required': '不能为空', 'min_length': '太短了'},       # 替换原始错误信息
        widget=forms.widgets.TextInput(attrs={'class': 'form-control'}),       # 添加一些样式等信息
    )
    password = forms.CharField(label='密码')


def login(request):
    form_obj = RegForm()
    if request.method == 'GET':
        return render(request, "login.html", {'form_obj': form_obj})
    else:
        form_obj = RegForm(request.POST)
        print(form_obj.fields)
        print(form_obj.is_valid())      # 判断是否通过验证
        if form_obj.is_valid():
            print(form_obj.cleaned_data)    # 取得通过验证的字段字典
            return HttpResponse('登录成功')
        else:
            print(form_obj.errors)
            return render(request, 'login.html', {'form_obj': form_obj})

<form method="post" novalidate>
    {% csrf_token %}
    <div>
        <label for="">{{ form_obj.name.label }}</label>
        {{ form_obj.name }}
        {{ form_obj.name.help_text }}
        <!--{{ form_obj.errors }} 这是全局的所有错误，找对应字段的错误，就要form_obj.字段名-->
        <span style="color: red;font-size: 14px;">{{ form_obj.name.errors.0 }}</span>
    </div>
    <div>
        <label for="">{{ form_obj.password.label }}</label>
        {{ form_obj.password }}
        <span style="color: red;font-size: 14px;">{{ form_obj.password.errors.0 }}</span>
    </div>
    <input type="submit">
</form>

 

form常用字段与插件

initial——初始值，input框里面的初始值。

class LoginForm(forms.Form):
    username = forms.CharField(  
        min_length=8,
        label="用户名",
        initial="张三"  # 设置默认值
    )
    pwd = forms.CharField(min_length=6, label="密码")

error_messages——重写错误信息。

class LoginForm(forms.Form):
    username = forms.CharField(
        min_length=8,
        label="用户名",
        initial="张三",
        error_messages={
            "required": "不能为空",
            "invalid": "格式错误",
            "min_length": "用户名最短8位"
        }
    )
    pwd = forms.CharField(min_length=6, label="密码")

 

password

class LoginForm(forms.Form):
    ...
    pwd = forms.CharField(
        min_length=6,
        label="密码",
        widget=forms.widgets.PasswordInput(attrs={'class': 'c1'}, render_value=True) #这个密码字段和其他字段不一样，默认在前端输入数据错误的时候，点击提交之后，默认是不保存的原来数据的，但是可以通过这个render_value=True让这个字段在前端保留用户输入的数据
    )

radioSelect——单radio值为字符串

class LoginForm(forms.Form):
    username = forms.CharField(  #其他选择框或者输入框，基本都是在这个CharField的基础上通过插件来搞的
        min_length=8,
        label="用户名",
        initial="张三",
        error_messages={
            "required": "不能为空",
            "invalid": "格式错误",
            "min_length": "用户名最短8位"
        }
    )
    pwd = forms.CharField(min_length=6, label="密码")
    gender = forms.fields.ChoiceField(
        choices=((1, "男"), (2, "女"), (3, "保密")),
        label="性别",
        initial=3,
        widget=forms.widgets.RadioSelect()
    )

单选Select

class LoginForm(forms.Form):
    ...
    hobby = forms.fields.ChoiceField(  #注意，单选框用的是ChoiceField，并且里面的插件是Select，不然验证的时候会报错， Select a valid choice的错误。
        choices=((1, "篮球"), (2, "足球"), (3, "双色球"), ),
        label="爱好",
        initial=3,
        widget=forms.widgets.Select()
    )

多选Select

class LoginForm(forms.Form):
    ...
    hobby = forms.fields.MultipleChoiceField( #多选框的时候用MultipleChoiceField，并且里面的插件用的是SelectMultiple，不然验证的时候会报错。
        choices=((1, "篮球"), (2, "足球"), (3, "双色球"), ),
        label="爱好",
        initial=[1, 3],
        widget=forms.widgets.SelectMultiple()
    )

单选checkbox

#单选的checkbox
    class TestForm2(forms.Form):
        keep = forms.ChoiceField(
            choices=(
                ('True',1),
                ('False',0),
            ),

            label="是否7天内自动登录",
            initial="1",
            widget=forms.widgets.CheckboxInput(), 
        )
    选中:'True'   #form只是帮我们做校验,校验选择内容的时候,就是看在没在我们的choices里面,里面有这个值,表示合法,没有就不合法
    没选中:'False'
    ---保存到数据库里面  keep:'True'
    if keep == 'True':
        session 设置有效期7天
    else:
        pass

多选checkbox

class LoginForm(forms.Form):
    ...
    hobby = forms.fields.MultipleChoiceField(
        choices=((1, "篮球"), (2, "足球"), (3, "双色球"),),
        label="爱好",
        initial=[1, 3],
        widget=forms.widgets.CheckboxSelectMultiple()
    )

date类型

from django import forms
from django.forms import widgets
class BookForm(forms.Form):
    date = forms.DateField(widget=widgets.TextInput(attrs={'type':'date'}))  #必须指定type，不然不能渲染成选择时间的input框

choice字段注意事项

在使用选择标签时，需要注意choices的选项可以配置从数据库中获取，但是由于是静态字段 获取的值无法实时更新，需要重写构造方法从而实现choice实时更新

# 方法一
from django.forms import Form
from django.forms import widgets
from django.forms import fields

 
class MyForm(Form):
 
    user = fields.ChoiceField(
        # choices=((1, '上海'), (2, '北京'),),
        initial=2,
        widget=widgets.Select
    )
 
    def __init__(self, *args, **kwargs):
        super(MyForm,self).__init__(*args, **kwargs) #注意重写init方法的时候，*args和**kwargs一定要给人家写上，不然会出问题，并且验证总是不能通过，还不显示报错信息
        # self.fields['user'].choices = ((1, '上海'), (2, '北京'),)
        # 或
        self.fields['user'].choices = models.Classes.objects.all().values_list('id','caption')
# 方法二
from django import forms
from django.forms import fields
from django.forms import models as form_model

 
class FInfo(forms.Form):
　　
    authors = forms.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())  # 多选
    #或者下面这种方式，通过forms里面的models中提供的方法也是一样的。
    authors = form_model.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())  # 多选
    #authors = form_model.ModelChoiceField(queryset=models.NNewType.objects.all())  # 单选

    #或者，forms.ModelChoiceField(queryset=models.Publisth.objects.all(),widget=forms.widgets.Select()) 单选
    #
   authors = forms.ModelMultipleChoiceField(
    queryset=models.Author.objects.all(),
    widget = forms.widgets.Select(attrs={'class': 'form-control'}
   ))
   #如果用这种方式，别忘了model表中，NNEWType的__str__方法要写上，不然选择框里面是一个个的object对象

 

Form所有内置字段

Field
    required=True,               是否允许为空
    widget=None,                 HTML插件
    label=None,                  用于生成Label标签或显示内容
    initial=None,                初始值
    help_text='',                帮助信息(在标签旁边显示)
    error_messages=None,         错误信息 {'required': '不能为空', 'invalid': '格式错误'}
    validators=[],               自定义验证规则
    localize=False,              是否支持本地化
    disabled=False,              是否可以编辑
    label_suffix=None            Label内容后缀
 
 
CharField(Field)
    max_length=None,             最大长度
    min_length=None,             最小长度
    strip=True                   是否移除用户输入空白
 
IntegerField(Field)
    max_value=None,              最大值
    min_value=None,              最小值
 
FloatField(IntegerField)
    ...
 
DecimalField(IntegerField)
    max_value=None,              最大值
    min_value=None,              最小值
    max_digits=None,             总长度
    decimal_places=None,         小数位长度
 
BaseTemporalField(Field)
    input_formats=None          时间格式化   
 
DateField(BaseTemporalField)    格式：2015-09-01
TimeField(BaseTemporalField)    格式：11:12
DateTimeField(BaseTemporalField)格式：2015-09-01 11:12
 
DurationField(Field)            时间间隔：%d %H:%M:%S.%f
    ...
 
RegexField(CharField)
    regex,                      自定制正则表达式
    max_length=None,            最大长度
    min_length=None,            最小长度
    error_message=None,         忽略，错误信息使用 error_messages={'invalid': '...'}
 
EmailField(CharField)      
    ...
 
FileField(Field)
    allow_empty_file=False     是否允许空文件
 
ImageField(FileField)      
    ...
    注：需要PIL模块，pip3 install Pillow
    以上两个字典使用时，需要注意两点：
        - form表单中 enctype="multipart/form-data"
        - view函数中 obj = MyForm(request.POST, request.FILES)
 
URLField(Field)
    ...
 
 
BooleanField(Field)  
    ...
 
NullBooleanField(BooleanField)
    ...
 
ChoiceField(Field)
    ...
    choices=(),                选项，如：choices = ((0,'上海'),(1,'北京'),)
    required=True,             是否必填
    widget=None,               插件，默认select插件
    label=None,                Label内容
    initial=None,              初始值
    help_text='',              帮助提示
 
 
ModelChoiceField(ChoiceField)
    ...                        django.forms.models.ModelChoiceField
    queryset,                  # 查询数据库中的数据
    empty_label="---------",   # 默认空显示内容
    to_field_name=None,        # HTML中value的值对应的字段
    limit_choices_to=None      # ModelForm中对queryset二次筛选
     
ModelMultipleChoiceField(ModelChoiceField)
    ...                        django.forms.models.ModelMultipleChoiceField
 
 
     
TypedChoiceField(ChoiceField)
    coerce = lambda val: val   对选中的值进行一次转换
    empty_value= ''            空值的默认值
 
MultipleChoiceField(ChoiceField)
    ...
 
TypedMultipleChoiceField(MultipleChoiceField)
    coerce = lambda val: val   对选中的每一个值进行一次转换
    empty_value= ''            空值的默认值
 
ComboField(Field)
    fields=()                  使用多个验证，如下：即验证最大长度20，又验证邮箱格式
                               fields.ComboField(fields=[fields.CharField(max_length=20), fields.EmailField(),])
 
MultiValueField(Field)
    PS: 抽象类，子类中可以实现聚合多个字典去匹配一个值，要配合MultiWidget使用
 
SplitDateTimeField(MultiValueField)
    input_date_formats=None,   格式列表：['%Y--%m--%d', '%m%d/%Y', '%m/%d/%y']
    input_time_formats=None    格式列表：['%H:%M:%S', '%H:%M:%S.%f', '%H:%M']
 
FilePathField(ChoiceField)     文件选项，目录下文件显示在页面中
    path,                      文件夹路径
    match=None,                正则匹配
    recursive=False,           递归下面的文件夹
    allow_files=True,          允许文件
    allow_folders=False,       允许文件夹
    required=True,
    widget=None,
    label=None,
    initial=None,
    help_text=''
 
GenericIPAddressField
    protocol='both',           both,ipv4,ipv6支持的IP格式
    unpack_ipv4=False          解析ipv4地址，如果是::ffff:192.0.2.1时候，可解析为192.0.2.1， PS：protocol必须为both才能启用
 
SlugField(CharField)           数字，字母，下划线，减号（连字符）
    ...
 
UUIDField(CharField)           uuid类型

 

字段校验

RegexValidator验证器

from django.forms import Form
from django.forms import widgets
from django.forms import fields
from django.core.validators import RegexValidator
 
class MyForm(Form):
    user = fields.CharField(
        validators=[RegexValidator(r'^[0-9]+$', '请输入数字'), RegexValidator(r'^159[0-9]+$', '数字必须以159开头')],
    )

自定义验证函数

import re
from django.forms import Form
from django.forms import widgets
from django.forms import fields
from django.core.exceptions import ValidationError
 
 
# 自定义验证规则
def mobile_validate(value):
    mobile_re = re.compile(r'^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$')
    if not mobile_re.match(value):
        raise ValidationError('手机号码格式错误')  #自定义验证规则的时候，如果不符合你的规则，需要自己发起错误
 
 
class PublishForm(Form):
    title = fields.CharField(max_length=20,
                            min_length=5,
                            error_messages={'required': '标题不能为空',
                                            'min_length': '标题最少为5个字符',
                                            'max_length': '标题最多为20个字符'},
                            widget=widgets.TextInput(attrs={'class': "form-control",
                                                          'placeholder': '标题5-20个字符'}))
 
 
    # 使用自定义验证规则
    phone = fields.CharField(validators=[mobile_validate, ],
                            error_messages={'required': '手机不能为空'},
                            widget=widgets.TextInput(attrs={'class': "form-control",
                                                          'placeholder': u'手机号码'}))
 
    email = fields.EmailField(required=False,
                            error_messages={'required': u'邮箱不能为空','invalid': u'邮箱格式错误'},
                            widget=widgets.TextInput(attrs={'class': "form-control", 'placeholder': u'邮箱'}))

 

Hook钩子方法

局部钩子——clean_字段名称

# views

from django.shortcuts import render, HttpResponse
from django import forms
from django.core.exceptions import ValidationError


class RegForm(forms.Form):
    name = forms.CharField(
        label='用户名',             # 定义前端页面显示名字
        min_length=6,               # 定义规则
        initial='user',             # 给一个默认值
    )
    password = forms.CharField(label='密码')

    # 局部钩子
    def clean_name(self):
        value = self.clean_data['name']
        if '金瓶梅' in value:
            raise ValidationError('含有敏感词汇')
        else:
            return value

全局钩子——clean

# views

from django.shortcuts import render, HttpResponse
from django import forms
from django.core.exceptions import ValidationError


class RegForm(forms.Form):
    name = forms.CharField(
        label='用户名',             # 定义前端页面显示名字
        min_length=6,               # 定义规则
        initial='user',             # 给一个默认值
    )
    password1 = forms.CharField(label='密码')
    password2 = forms.CharField(label='确认密码')

    # 定义一个全局样式
    def __init__(self, *args, **kwargs):        
        super().__init__(*args, **kwargs)
        for field in self.fields.values():
            field.widget.attrs.update({'class': 'form-control'})

    # 局部钩子
    def clean_name(self):
        value = self.cleaned_data['name']
        if '金瓶梅' in value:
            raise ValidationError('含有敏感词汇')
        else:
            return value

    # 全局钩子
    def clean(self):
        value = self.cleaned_data
        p1 = value['password1']
        p2 = value['password2']
        if p1 == p2:
            return value
        else:
            self.add_error('re_password', '两次密码不一致') # 在password2这个字段的错误列表中加上一个错误，并且clean_data里面会自动清除这个password2的值，所以打印clean_data的时候会看不到它
            raise ValidationError('两次密码不一致')    # 非必须字段

具体源码流程可看我的另一篇文章：django 源码部分

 

ModelForm

会根据model中的字段转换为对应的form字段，并且自动生成标签等操作

# models
from django import forms

class Book(models.Model):

    nid = models.AutoField(primary_key=True)
    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)
    publish=models.ForeignKey(to="Publish",to_field="nid")
    authors=models.ManyToManyField(to='Author',)
    def __str__(self):
        return self.title
#modelform类的写法

class BookForm(forms.ModelForm):

    class Meta:
        model = models.Book
        fields = "__all__"
        labels = {
            "title": "书名",
            "price": "价格"
        }
        widgets = {
            "password": forms.widgets.PasswordInput(attrs={"class": "c1"}),
            "publishDate": forms.widgets.DateInput(attrs={"type": "date"}),
        }

class Meta下常用参数：

model = models.Book  # 对应的Model中的类
fields = "__all__"  # 字段，如果是__all__,就是表示列出所有的字段
exclude = None  # 排除的字段
labels = None  # 提示信息
help_texts = None  # 帮助提示信息
widgets = None  # 自定义插件
error_messages = None  # 自定义错误信息
error_messages = {
    'title':{'required':'不能为空',...} #每个字段的所有的错误都可以写，...是省略的意思，复制黏贴我代码的时候别忘了删了...
}

批量添加样式：和form的一样

class BookForm(forms.ModelForm):
    #password = forms.CharField(min_length=10) #可以重写字段，会覆盖modelform中的这个字段，那么modelform下面关于这个字段的设置就会被覆盖，比如果设置插件啊，error_messages啊等等，
    r_password = forms.CharField() #想多验证一些字段可以单独拿出来写，按照form的写法，写在Meta的上面或者下面都可以
    class Meta:
        model = models.Book
        # fields = ['title','price']
        fields = "__all__" #['title,'price'] 指定字段生成form
        # exclude=['title',] #排除字段
        labels = {
            "title": "书名",
            "price": "价格"
        }
        error_messages = {
            'title':{'required':'不能为空',} #每个字段的错误都可以写
        }
    #如果models中的字段和咱们需要验证的字段对不齐的是，比如注册时，咱们需要验证密码和确认密码两个字段数据，但是后端数据库就保存一个数据就行，那么验证是两个，数据保存是一个，就可以再接着写form字段
    r_password = forms.CharField()。
    #同样的，如果想做一些特殊的验证定制，那么和form一昂，也是那两个钩子（全局和局部），写法也是form那个的写法，直接在咱们的类里面写：
    #局部钩子：
    def clean_title(self):
        pass
　　#全局钩子
    def clean(self):
        pass
    def __init__(self,*args,**kwargs): #批量操作
        super().__init__(*args,**kwargs)
        for field in self.fields:
            #field.error_messages = {'required':'不能为空'} #批量添加错误信息,这是都一样的错误，不一样的还是要单独写。
            self.fields[field].widget.attrs.update({'class':'form-control'})

ModelForm的验证

  • 与普通的Form表单验证类型类似，ModelForm表单的验证在调用is_valid() 或访问errors 属性时隐式调用

  • 我们可以像使用Form类一样自定义局部钩子方法和全局钩子方法来实现自定义的校验规则。

  • 如果我们不重写具体字段并设置validators属性的话，ModelForm是按照模型中字段的validators来校验的

save()方法

每个ModelForm还具有一个save()方法。 这个方法根据表单绑定的数据创建并保存数据库对象。 ModelForm的子类可以接受现有的模型实例作为关键字参数instance；如果提供此功能，则save()将更新该实例。 如果没有提供，save() 将创建模型的一个新实例：

>>> from myapp.models import Book
>>> from myapp.forms import BookForm

# 根据POST数据创建一个新的form对象
>>> form_obj = BookForm(request.POST)

# 创建书籍对象
>>> new_ book = form_obj.save()

# 基于一个书籍对象创建form对象
>>> edit_obj = Book.objects.get(id=1)
# 使用POST提交的数据更新书籍对象
>>> form_obj = BookForm(request.POST, instance=edit_obj)
>>> form_obj.save()
# 书籍表
def edit_book(request,n):

    book_obj = models.Book.objects.filter(pk=n).first()
    if request.method == 'GET':
        # all_authors = models.Author.objects.all() #
        # all_publish = models.Publish.objects.all()

        form = BookForm(instance=book_obj)

        return render(request,'edit_book.html',{'form':form,'n':n}) #传递的这个n参数是给form表单提交数据的是的action的url用的，因为它需要一个参数来识别是更新的哪条记录

    else:
        form = BookForm(request.POST,instance=book_obj) # 必须指定instance，不然我们调用save方法的是又变成了添加操作
        if form.is_valid():
            form.save()
            return redirect('show')
        else:
            return render(request,'edit_book.html',{'form':form,'n':n})
{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="{% static 'bootstrap-3.3.0-dist/dist/css/bootstrap.min.css' %}">
</head>
<body>

<h1>编辑页面</h1>
<div class="container-fluid">
    <div class="row">
        <div class="col-md-6 col-md-offset-3">
            <form action="{% url 'edit_book' n %}" novalidate method="post">
                {% csrf_token %}
                {% for field in form %}
                    <div class="form-group">
                        <label for="{{ field.id_for_label }}">{{ field.label }}</label>
                        {{ field }}
                        <span class="text-danger">{{ field.errors.0 }}</span>
                    </div>
                {% endfor %}

                <div class="form-group">
                    <input type="submit" class="btn btn-primary pull-right">
                </div>

            </form>

        </div>
    </div>
</div>


</body>
<script src="{% static 'bootstrap-3.3.0-dist/dist/jQuery/jquery-3.1.1.js' %}"></script>
<script src="{% static 'bootstrap-3.3.0-dist/dist/js/bootstrap.min.js' %}"></script>
</html>

 

modelformset_factory

应用于大量数据需要修改，在页面生成修改数据页面，并直接修改保存

  1. 创建forms.ModelForm
  2. 创建工厂modelformset_factory，参数model：model对象，form：创建的form对象，extra：是否留有编辑行
  3. queryset为需要加载显示的数据，如不写加载所有数据
  4. 模板添加{{ formset.management_form }}，固定写法
  5. {{ field.id }}为标识数据，否则没法保存修改
  6. instance为生成不可修改项，需要生成一个隐藏的原始数据，负责没法提交
  7. 保存验证跟modelForm一样

from django.forms.models import modelformset_factory
from django import forms

class StudyRecordForm(forms.ModelForm):
    class Meta:
        model = models.StudyRecord
        fields = '__all__'


class StudyRecord(View):
    def get(self, request, course_record_id):
        study_record = models.StudyRecord.objects.filter(course_record_id=course_record_id)
        formset_cls = modelformset_factory(model=models.StudyRecord, form=StudyRecordForm, extra=0)     # extra设定是否留有空白添加项
        formset = formset_cls(queryset=study_record)    # 这是指定数据
        return render(request, 'study_record_show.html', {"formset": formset})

    def post(self,request,course_record_id):
        formset_cls = modelformset_factory(model=models.StudyRecord, form=StudyRecordForm, extra=0)
        formset = formset_cls(request.POST)
        if formset.is_valid():
            formset.save()
            return redirect(request.path)
        else:
            return render(request, 'study_record_show.html', {formset_cls: "formset"})
            <table class="table table-hover table-bordered table-striped">
                {{ formset.management_form }}
                <thead>
                <tr>
                    <th>序号</th>
                    <th>考勤</th>
                    <th>本节成绩</th>
                    <th>作业批语</th>
                    <th>某节课程</th>
                    <th>学员</th>
                </tr>
                </thead>
                {{ formset.errors }}
                <tbody>
                {% for field in formset %}
                    <tr>
                        {{ field.id }} {#  标识记录用的，默认隐藏看不到的 #}
                        <td>{{ forloop.counter }}</td>
                        <td>{{ field.attendance }}</td>
                        <td>{{ field.score }}</td>
                        <td>{{ field.homework_note }}</td>
                        <td>{{ field.instance.course_record }}</td>
                        <td class="hidden">{{ field.course_record }}</td>
                        {#  bootstrap样式隐藏 #}
                        <td>{{ field.instance.student }}</td>
                        {#  不需要修改的数据，不生成下拉框instance #}
                        <td class="hidden">{{ field.student }}</td>
                    </tr>
                {% endfor %}
                </tbody>
            </table>

 

CrazyDemo
关注
专栏目录
django中modelformset基本使用说明
weixin_43700349的博客
05-01 534
modelformset 是基于modelform实现的批量表单，包含了modelform的特点 使用方法： 1. 创建modelform class StudyRecordModelForm(StarkModelForm): class Meta: model = models.StudyRecord fields = ['record', ] 2. 使用modelformset_factory创建modelformset 参数1:model类 参数2
django批量修改table_Django 使用 modelformset 组件批量修改表单数据
weixin_34574003的博客
01-14 341
１．ｍｏｄｅｌｓ．ｐｙ：class StudentStudyRecord(models.Model):'''学生学习记录'''student = models.ForeignKey(verbose_name="学员", to='Student',on_delete=models.CASCADE)classstudyrecord = models.ForeignKey(verbose_name="第...
django 同时提交多个重复表单formset_factory
公子世无双
01-03 993
formset_factory 官方文档：https://docs.djangoproject.com/en/3.0/topics/forms/formsets/ Step1 写个自定义表单 Step2forms.formset_factory(ReceiptForm, extra=1)注册 class ReceiptForm(forms.Form): invoice_...
Django表单集合----Formset
菲宇运维
06-26 2038
一、Formset简介 Formset（表单集）是多个表单的集合。Formset在Web开发中应用很普遍，它可以让用户在同一个页面上提交多张表单，一键添加多个数据，比如一个页面上添加多个用户信息。 Django针对不同的formset提供了三种方法：formset_factory、modelformset_factory和inlineformset_factory。 二、formset_fa...
利用modelformset_factory实现批量添加成绩
weixin_30345577的博客
11-20 210
https://www.cnblogs.com/apollo1616/articles/9990717.html 本文是基于上一篇文章的改进版,利用插件modelformset_factory完成上文中实现的手动添加 urls.py文件 from django.contrib import admin from django.urls import path,re_p...
django inlineformset_factory 内联model前端动态增删操作
潜心修炼--记录点滴
01-17 3411
用Todo来demo, 比如我们创建Todo表，首先有个topic，每个topic下面再挂着多个子item。 效果： model.py: class Topic(models.Model): title = models.CharField(max_length=255) created_date = models.DateTimeField(default=timez...
django中ModelForm多表单组合的解决方案.docx
10-26
在上面的代码中，我们首先定义了两个 ModelForm：ProjectForm 和 TaskForm。然后，我们使用 modelformset_factory 函数来创建两个 FormSet：ProjectFormSet 和 TaskFormSet。最后，我们定义了一个 CompositeForm，...
Form与ModelForm-下拉框或者多选注意//及字段补充
weixin_30906701的博客
10-26 358
一、Form 　　设计一张普通model表： class UserInfo(models.Model): name = models.CharField(verbose_name='员工姓名', max_length=16) username = models.CharField(verbose_name='用户名', max_length=32) passw...
django1.6.5 form/formset/inline formset
08-25
Django提供了modelformset_factory方法来构造ModelFormset，它与modelForm_factory非常相似，也接受多个参数来创建ModelFormset实例。 值得注意的是，Django 1.7之后支持通过将字段的name设置为none来移除父类中...
django关于ModelForm
Mr_Slower的博客
01-31 841
1.class ModelForm If you’re building a database-driven app, chances are you’ll have forms that map closely to Django models. For instance, you might have a BlogComment model, and you want to create a...
关于django model form
secretx的专栏
10-10 3600
modelform从model自动导出form，基本使用如下： class XXXForm(forms.ModelForm):     class Meta:         model = Your Model          # 指定从那个model导出         # fields=("field1", "field2")        #可以限制只导出哪部分字段
model form
a8830324的博客
06-21 308
ModelForm 能允许我们通过一个 Model 直接创建一个和该模型的字段一一对应的表单，大大方便了表单操作。 下面来看一个例子。 首先我们有这样的 model： from django.db import models TITLE_CHOICES = ( ('MR', 'Mr.'), ('MRS', 'Mrs.'), ('MS', ...
django中的modelform和modelfoemset
weixin_30666753的博客
04-14 96
一. ModelForm 　　ModelForm是根据Model来定制的Form 二. ModelForm的创建 from django import forms from app import models class MyModelForm(forms.ModelForm): class Meta: model = models.Book ...
Django重新整理4---ModelForm-set(批量处理数据)
weixin_33843947的博客
11-21 110
1. #引用modelformset from django.forms.models import modelformset_factory #必须继承forms.ModelForm！ class StudentStudyRecordModelForm(forms.ModelForm): class Meta: #需要建立关联的表StudentStudyRecord ...
Django基础(11): 表单集合Formset的高级用法详解
大江狗
08-08 1万+
Formset(表单集)是多个表单的集合。Formset在Web开发中应用很普遍，它可以让用户在同一个页面上提交多张表单，一键添加多个数据，比如一个页面上添加多个用户信息。今天小编我就介绍下Django Formset的基础知识，Formset的分类以及如何使用Formset。 为什么要使用Django Formset 我们先来下看下Django中不使用Formset情况下是如何在同...
django中ModelForm多表单组合的解决方案
热门推荐
陶辉：聚焦分布式系统的程序员
10-10 1万+
django是python语言快速实现web服务的大杀器，其开发效率可以非常的高！但因为秉承了语言的灵活性，django框架又太灵活，以至于想实现任何功能都有种“条条大路通罗马”的感觉。这么多种选择放在一起，如何分出高下？我想此时的场景下就两个标准：1、相同的功能用最少的代码实现（代码少BUG也会少）；2、相对最易于理解，从而易于维护和扩展。书归正传，web服务允许用户输入，基本上要靠表单。而dj
从模型创建表单ModelForm
defending的博客
11-02 4035
从模型创建表单 ModelForm¶ class ModelForm¶ 如果你正在构建一个数据库驱动的应用，那么你应该会有与Django 的模型紧密映射的表单。举个例子，你也许会有个BlogComment 模型，并且你还想创建一个表单让大家提交评论到这个模型中。 在这种情况下，在表单中定义字段将是冗余的，因为你已经在模型中定义了字段。 基于这个原因，Django 提
Django之路12——form modelform formset modelformset的各种用法
weixin_30840253的博客
09-10 175
首先上结论： 　　form适用于对单个表单的操作，并且需要对每个字段的验证规则自定义。 　　modelform：适用于对用户提交的单个表单操作，字段可以用model中的表的字段来作为验证规则，适用于快速的进行增加、修改。 　　formset：适用于对多个表单进行操作，字段需要也可以用model中的表的字段来作为验证规则。 　　modelfoemset：适用于对多个表单进...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值