class ProjectForm(forms.Form):  
    name = forms.CharField(label='项目名称', max_length=20)  

class Form(six.with_metaclass(DeclarativeFieldsMetaclass, BaseForm)):  
    "A collection of Fields, plus their associated data."  
    # This is a separate class from BaseForm in order to abstract the way  
    # self.fields is specified. This class (Form) is the one that does the  
    # fancy metaclass stuff purely for the semantic sugar -- it allows one  
    # to define a form using declarative syntax.  
    # BaseForm itself has no way of designating self.fields.  

class BaseForm(object):  
    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,  
                 initial=None, error_class=ErrorList, label_suffix=None,  
                 empty_permitted=False, field_order=None, use_required_attribute=None):  
        #data参数用于接收request.POST字典，如果是GET方法就不传  
    self.data = data or {}  
    #files用于接收request.FILES，也就是处理上传文件  
    self.files = files or {}  
    #本篇文章的重点在于多个表单集成到一个form中，此时为防止有同名的field，需要加prefix前缀  
        if prefix is not None:  
            self.prefix = prefix  
    #GET显示表单时，如果要显示初始值，请用initial参数  
        self.initial = initial or {}  
  
    #模板中显示{{form}}时，默认是以<table></table>显示的  
    def __str__(self):  
        return self.as_table()  
  
    #如果模板中不想写重复代码，只以固定的格式来显示每一个field，那么就用{% for field, val in form %}来遍历处理吧  
    def __iter__(self):  
        for name in self.fields:  
            yield self[name]  
  
    #如果传入了prefix参数，html中每个field的name和id里都会加上prefix前缀  
    def add_prefix(self, field_name):  
        return '%s-%s' % (self.prefix, field_name) if self.prefix else field_name  
  
    #模板中以html格式显示form就靠这个方法  
    def _html_output(self, normal_row, error_row, row_ender, help_text_html, errors_on_separate_row):  
        "Helper function for outputting HTML. Used by as_table(), as_ul(), as_p()."  
        top_errors = self.non_field_errors()  # Errors that should be displayed above all fields.  
        output, hidden_fields = [], []  
  
    #除了默认的table方式显示外，还可以<ul><li>或者<p>方式显示  
    def as_table(self):  
        "Returns this form rendered as HTML <tr>s -- excluding the <table></table>."  
    def as_ul(self):  
        "Returns this form rendered as HTML <li>s -- excluding the <ul></ul>."  
    def as_p(self):  
        "Returns this form rendered as HTML <p>s."  

class ProjectForm(ModelForm):  
    class Meta:  
        model = Project  
        fields = ['approvals','manager','name','fund_rource','content','range',]  

class ModelForm(six.with_metaclass(ModelFormMetaclass, BaseModelForm)):  
    pass  

class BaseModelForm(BaseForm):  
    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,  
                 initial=None, error_class=ErrorList, label_suffix=None,  
                 empty_permitted=False, instance=None, use_required_attribute=None):  
        opts = self._meta  
    #相比较BaseForm，多了instance参数，它等价于Model模型的一个实例  
        if instance is None:  
            #不传instance参数，则会新构造model对象  
            self.instance = opts.model()  
            object_data = {}  
        else:  
            self.instance = instance  
            object_data = model_to_dict(instance, opts.fields, opts.exclude)  
    #此时传递了initial也一样可以生效，同时还会设置到Model中  
        if initial is not None:  
            object_data.update(initial)  
  
    def save(self, commit=True):  
    #默认commit是True，此时就会保存Model实例到数据库  
        if commit:  
            self.instance.save()  
    #同时保存many-to-many字段对应的关系表  
            self._save_m2m()  
        else:  
    #注意，本篇文章主要用到commit=False这个参数，它会返回Model实例，允许我们在修改instance后，在instance上再调用save方法  
            self.save_m2m = self._save_m2m  
        return self.instance  

class PrimeContract(models.Model):  
    address = models.ForeignKey(Address, related_name="prime_contract_address", verbose_name="address")  
    project = models.ForeignKey(Project, related_name="prime_contract", verbose_name="project")  
class Project(models.Model):  
    address = models.ForeignKey(Address, related_name="project_address", verbose_name="project address")  
class Address(models.Model):  
    pass  

class AddressForm(ModelForm):  
    class Meta:  
        model = Address  
        fields = ...  
class ProjectForm(ModelForm):  
    class Meta:  
        model = Project  
        fields = ...  
class PrimeContractForm(ModelForm):  
    class Meta:  
        model = PrimeContract  
        fields = ...  

class PrimeContractAdd(CreateView):  
    success_url = ...  
    template_name = ...  
    form_class = PrimeContractForm  
    def get_context_data(self, **kwargs):  
        context = super(PrimeContractAdd, self).get_context_data(**kwargs)  
        #SingleObjectMixin父类只会处理PrimeContractForm表单，另外三条数据库记录对应的表单我们要自己处理了，此时prefix派上用场了，因为Field重名是百分百的事  
        if self.request.method == 'POST':  
            contractAddressForm = AddressForm(self.request.POST, prefix='contractAddressForm')  
            projectAddressForm = AddressForm(self.request.POST, prefix='projectAddressForm')  
            projectForm = ProjectForm(self.request.POST, prefix='projectForm')  
        else:  
            contractAddressForm = AddressForm(prefix='contractAddressForm')  
            projectAddressForm = AddressForm(prefix='projectAddressForm')  
            projectForm = ProjectForm(prefix='projectForm')  
        #注意要把自己处理的表单放到context上下文中，供模板文件使用  
        context['contractAddressForm'] = contractAddressForm  
        context['projectAddressForm'] = projectAddressForm  
        context['projectForm'] = projectForm  
        return context  
      
    #重写form_valid，父类ProcessFormView会在PrimeContractForm表单is_valid方法返回True时调用该方法  
    def form_valid(self, form):  
        #首先我们要获取到PrimeContractForm表单对应的模型，此时是不能save的，因为外键project和address对应的数据库记录还没有创建，所以commit传为False  
        contract = form.save(commit=False)  
        #获取上面get_context_data方法中在POST里得到的表单  
        context = self.get_context_data()  
        #按照四条数据库记录的顺序依次的创建（调用save方法）、主键赋到下一条记录的外键中、下一次记录创建（save）  
        projectAddress = context['projectAddressForm'].save()  
        #从项目表单中获取到模型，先把地址的id赋到外键上再保存  
        project = context['projectForm'].save(commit=False)  
        project.address = projectAddress  
        project.save()  
        contractAddress = context['contractAddressForm'].save()  
        #将合同模型中的address和project都设置好后再保存  
        contract.address = contractAddress  
        contract.project = project  
        contract.save()  
          
        return super(PrimeContractAdd, self).form_valid(form)  

#这三个表单我们手动处理过的  
{{ contractAddressForm }}  
{{ projectAddressForm }}  
{{ projectForm }}  
#这是FormMixin父类帮我们生成的  
{{ form }}