django表单什么写(Django表单)

导读：本篇文章首席CTO笔记来给大家介绍有关django表单什么写的相关内容，希望对大家有所帮助，一起来看看吧。

django 怎么将表单上的数据写到数据库里

首先，在views中需要判断你的form合不合法（不合法请查看InputForm与输入的是否符合),可以在if form.is_valid():并列的地方添加一个else,print form看看，可以类似form.company.errors.其实如果合法要存到数据库中，你的model方法有问题，一般是add_input=Input(xx=xx,xx=xx)

add_input.save()

或者Input.objects.create(xx=xx=,xx=xx)＃并不需要赋值，和调用save()方法，因为create内部有调用save方法

我是怎么做到使用django动态定义表单的

django中表单向导使用起来很简单的.

[python] view plain copy

from django.utils.translation import ugettext_lazy as _

from django import forms

from django.forms.formsets import BaseFormSet

from django.forms.fields import FileField

from django.forms.util import ValidationError

from django.shortcuts import render_to_response

from django.contrib.formtools.wizard import FormWizard

from ddtcms.office.equipment.models import Equipment,Characteristic,CharacteristicValue

class EquipmentForm(forms.ModelForm):

class Meta:

model = Equipment

class CharacteristicValueForm(forms.Form):

def clean(self):

a=self.fields

s=self.data

self.cleaned_data = {}

# 下面的这一段for 是从 django的forms.py中的 full_clean 中复制来的

for name, field in self.fields.items():

# value_from_datadict() gets the data from the data dictionaries.

# Each widget type knows how to retrieve its own data, because some

# widgets split data over several HTML fields.

value = field.widget.value_from_datadict(self.data, self.files, self.add_prefix(name))

try:

if isinstance(field, FileField):

initial = self.initial.get(name, field.initial)

value = field.clean(value, initial)

else:

value = field.clean(value)

self.cleaned_data[name] = value

if hasattr(self, 'clean_%s' % name):

value = getattr(self, 'clean_%s' % name)()

self.cleaned_data[name] = value

except ValidationError, e:

self._errors[name] = self.error_class(e.messages)

if name in self.cleaned_data:

del self.cleaned_data[name]

#cl=self.cleaned_data

#debug()调试用的,查看cl的值,主要是看self.cleaned_data的值,如果return了,就看不到了

return self.cleaned_data

class EquipmentCreateWizard(FormWizard):

def done(self, request, form_list):

return render_to_response('equipment/done.html',

{

'form_data': [form.cleaned_data for form in form_list],

})

def get_form(self, step, data=None):

"Helper method that returns the Form instance for the given step."

form = self.form_list[step](data, prefix=self.prefix_for_step(step), initial=self.initial.get(step, None))

if step == 1:

if data:

cg = data.get('0-category', 1)

cs = Characteristic.objects.all().filter(category__id=cg)

for c in cs:

form.fields['Characteristic-'+str(c.id)] = forms.CharField(label = c.name)

g=form.fields

#debug()

return form

# 从wizard.py中复制过来进行更改的.

def render(self, form, request, step, context=None):

"Renders the given Form object, returning an HttpResponse."

old_data = request.POST

prev_fields = []

if old_data:

hidden = forms.HiddenInput()

# Collect all data from previous steps and render it as HTML hidden fields.

for i in range(step):

old_form = self.get_form(i, old_data)

hash_name = 'hash_%s' % i

prev_fields.extend([bf.as_hidden() for bf in old_form])

prev_fields.append(hidden.render(hash_name, old_data.get(hash_name, self.security_hash(request, old_form))))

if step == 1:

cg = old_data.get('0-category', 1)

cs = Characteristic.objects.all().filter(category__id=cg)

for c in cs:

form.fields['Characteristic-'+str(c.id)] = forms.CharField(label = c.name)

g=form.fields

#debug()

if step == 2:

debug()

return super(EquipmentCreateWizard, self).render(form, request, step, context=None)

def get_template(self, step):

return 'equipment/wizard_%s.html' % step

EquipmentCreateWizard其实也可以放在views.py中,而且我觉得更合理一点.

在EquipmentCreateWizard 中,我试着修改过process_step 函数,但是得不到正确的结果,后来修改了get_form,都是想从django的formtools的wizard.py中复制过来再进行修改的.

get_form的修改也没有得到正确的结果.后来就修改render函数,在第2步的时候,我将动态参数个数显示出来了.但是到最后结束done的环节,取得的formdata中,第二个form没有数据,就是一个空的{},

于是我又重新修改get_form函数,无非就是判断是不是第二步,然后给第二个form动态添加几个field:

[python] view plain copy

if step == 1:

cg = old_data.get('0-category', 1)

cs = Characteristic.objects.all().filter(category__id=cg)

for c in cs:

form.fields['Characteristic-'+str(c.id)] = forms.CharField(label = c.name)

g=form.fields

#debug()

这段代码在get_form和 render中都有,都是判断是不是第2步,然后就根据第1步中选择的设备的分类来查询到具体的分类,再根据分类来获取该种分类的设备有哪些参数,然后根据参数个数修改form的参数field的个数.

'Characteristic-'+str(c.id)是用来以后保存数据的时候,split这个字符串,得到参数的id,并在参数值表中保存Characteristic-1,Characteristic-2...的value.

g=form.fields

#debug()

用来断点查看参数field有多少个,是否修改成功.

=========================

[python] view plain copy

from django.conf.urls.defaults import *

from ddtcms.office.equipment.forms import EquipmentForm,CharacteristicValueForm,EquipmentCreateWizard

urlpatterns = patterns('ddtcms.office.equipment.views',

url(r'^$', 'index', name="equipment_index"),

url(r'^add/$', 'equipment_create', name="equipment_create"),

url(r'^add-by-wizard/$',EquipmentCreateWizard([EquipmentForm, CharacteristicValueForm]), name="equipment_create_by_wizard"), )

以上代码,csdnbolg 自动过滤了 $符号,我加了上去,可能有不对的地方.

==========================

wizard_0.html

[html] view plain copy

{% block content %}

h2添加/修改设备向导/h2

p第 {{ step }} 步, 共 {{ step_count }} 步./p

p填写设备基本情况/p

form method="POST" action=""{% csrf_token %}

table

/table

input type="hidden" name="{{ step_field }}" value="{{ step0 }}" /

input type="submit" value="Submit" /

/form

{% endblock %}

===================

wizard_1.html

[html] view plain copy

{% block content %}

h2添加/修改设备向导/h2

p第 {{ step }} 步, 共 {{ step_count }} 步./p

p填写设备参数, 如果没有要填写的内容, 请直接点击确定./p

form method="POST" action=""{% csrf_token %}

table

/table

input type="hidden" name="{{ step_field }}" value="{{ step0 }}" /

input type="submit" value="Submit" /

/form

{% endblock %}

====================

done.html

[html] view plain copy

{% block content %}

h2添加/修改设备向导/h2

p您已经成功添加了一个设备./p

{% endblock %}

============

还可以用另外的form来实现formwizard,就是第一个form1,主要用来让用户选择设备的分类,form2就根据前面的来动态生成参数的表单.原理是一样的.

还有就是写2个view来模拟formwizard,第一个view增加一个设备,第二个view带设备id这个参数即可,可以很有效的增加设备的参数.

django 如何写表单提交

django 一般是用template来做页面的，如何编写模板和调用模板请参考：

当然如果页面里不用加载数据的话你可以直接写个静态的HTML页面。

“设置文本框默认有字，点修改按钮可以把文本框中的字改变。”这些要求在HTML里写个简单的脚本就行了（模板和HTML差不多的，模板不一样的地方就是用编地方需要服务器填充数据）。

学一学书里的django是怎么写views.py的

from django.core.urlresolvers import reverse_lazy

from django.shortcuts import redirect, get_object_or_404

from django.forms.models import modelform_factory

from django.apps import apps

from django.views.generic.base import TemplateResponseMixin, View

from django.views.generic.list import ListView

from django.views.generic.edit import CreateView, UpdateView, DeleteView

from braces.views import LoginRequiredMixin, PermissionRequiredMixin

from braces.views import CsrfExemptMixin, JsonRequestResponseMixin

from .models import Course, Module, Content

from .forms import ModuleFormSet

from django.db.models import Count

from .models import Subject

from django.views.generic.detail import DetailView

from students.forms import CourseEnrollForm

# Create your views here.

class OwnerMixin(object):

def get_queryset(self):

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

return qs.filter(owner=self.request.user)

class OwnerEditMixin(object):

def form_valid(self, form):

form.instance.owner = self.request.user

return super(OwnerEditMixin, self).form_valid(form)

class OwnerCourseMixin(OwnerMixin, LoginRequiredMixin):

model = Course

fields = ['subject', 'title', 'slug', 'overview']

success_url = reverse_lazy('manage_course_list')

class OwnerCourseEditMinxin(OwnerCourseMixin, OwnerEditMixin):

fields = ['subject', 'title', 'slug', 'overview']

success_url = reverse_lazy('manage_course_list')

template_name = 'courses/manage/course/form.html'

class ManageCourseListView(OwnerCourseMixin, ListView):

template_name = 'courses/manage/course/list.html'

class CourseCreateView(PermissionRequiredMixin,

OwnerCourseEditMinxin,

CreateView):

permission_required = 'courses.add_course'

class CourseUpdateView(PermissionRequiredMixin,

OwnerCourseEditMinxin,

UpdateView):

permission_required = 'courses.change_course'

class CourseDeleteView(PermissionRequiredMixin,

OwnerCourseMixin,

DeleteView):

template_name = 'courses/manage/course/delete.html'

success_url = reverse_lazy('manage_course_list')

permission_required = 'courses.delete_course'

class CourseModuleUpdateView(TemplateResponseMixin, View):

template_name = 'courses/manage/module/formset.html'

course = None

def get_formset(self, data=None):

return ModuleFormSet(instance=self.course,

data=data)

def dispatch(self, request, pk):

self.course = get_object_or_404(Course, id=pk, owner=request.user)

return super(CourseModuleUpdateView, self).dispatch(request, pk)

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

formset = self.get_formset()

return self.render_to_response({'course': self.course,

'formset': formset})

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

formset = self.get_formset(data=request.POST)

if formset.is_valid():

formset.save()

return redirect('manage_course_list')

return self.render_to_response({'course': self.course,

'formset': formset})

class ContentCreateUpdateView(TemplateResponseMixin, View):

module = None

model = None

obj = None

template_name = 'courses/manage/content/form.html'

def get_model(self, model_name):

if model_name in ['text', 'video', 'image', 'file']:

return apps.get_model(app_label='courses',

model_name=model_name)

return None

def get_form(self, model, *args, **kwargs):

Form = modelform_factory(model, exclude=['owner',

'order',

'created',

'updated'])

return Form(*args, **kwargs)

def dispatch(self, request, module_id, model_name, id=None):

self.module = get_object_or_404(Module,

id=module_id,

course__owner=request.user)

self.model = self.get_model(model_name)

if id:

self.obj = get_object_or_404(self.model, id=id, owner=request.user)

return super(ContentCreateUpdateView, self).dispatch(request, module_id, model_name, id)

def get(self, request, module_id, model_name, id=None):

form = self.get_form(self.model, instance=self.obj)

return self.render_to_response({'form': form, 'object': self.obj})

def post(self, request, module_id, model_name, id=None):

form = self.get_form(self.model,

instance=self.obj,

data=request.POST,

files=request.FILES)

if form.is_valid():

obj = form.save(commit=False)

obj.owner = request.user

obj.save()

print id, ''

if not id:

print '****************'

Content.objects.create(module=self.module,

item=obj)

print '****************'

return redirect('module_content_list', self.module.id)

return self.render_to_response({'form': form, 'object': self.obj})

class ContentDeleteView(View):

def post(self, request, id):

content = get_object_or_404(Content,

id=id,

module__course__owner=request.user)

module = content.module

content.item.delete()

content.delete()

return redirect('module_content_list', module.id)

class ModuleContentListView(TemplateResponseMixin, View):

template_name = 'courses/manage/module/content_list.html'

def get(self, request, module_id):

module = get_object_or_404(Module,

id=module_id,

course__owner=request.user)

return self.render_to_response({'module': module})

class ModuleOrderView(CsrfExemptMixin,

JsonRequestResponseMixin,

View):

def post(self, request):

for id, order in self.request_json.items():

Module.objects.filter(id=id,

course__owner=request.user).update(order=order)

return self.render_json_response({'saved': 'OK'})

class ContentOrderView(CsrfExemptMixin,

JsonRequestResponseMixin,

View):

def post(self, request):

for id, order in self.request_json.items():

Content.objects.filter(id=id,

module__course__owner=request.user)\

.update(order=order)

return self.render_json_response({'saved': 'OK'})

class CourseListView(TemplateResponseMixin, View):

model = Course

template_name = 'courses/course/list.html'

def get(self, request, subject=None):

subjects = Subject.objects.annotate(

total_courses=Count('courses')

)

courses = Course.objects.annotate(

total_modules=Count('modules')

)

if subject:

subject = get_object_or_404(Subject, slug=subject)

courses = courses.filter(subject=subject)

print '***********', subjects, courses, subject

return self.render_to_response({'subjets': subjects,

'subject': subject,

'courses': courses})

class CourseDetailView(DetailView):

model = Course

template_name = 'courses/course/detail.html'

def get_context_data(self, **kwargs):

context = super(CourseDetailView,

self).get_context_data(**kwargs)

context['enroll_form'] = CourseEnrollForm(

initial={'course': self.object})

return context

怎么用django写好代码的重要性

Django代码注意

1、模板标签里面 extend和include是冲突的，有了extend，include无法生效，原因：是底层渲染独立机制设计导致。

2、#coding:utf-8 这句只有放在代码文件第一行才能生效，放在注释字符串后面可能会失效。

3、由于前端发展而导致的Post请求Rest化和Django原生的技术设施层简化还有事务封装前移，由此产生的结果是业务层完全可以放在views里面。同事Restful化的好处就是可以把跨业务模块调用放在前端，保证了后端模块之间的正切

4、有用户自生成富文本内容的页面上最好不要放置带XSRF的POST表单，前者可能会窃取后者的Token信息。

5、在template里面的==这一类比较逻辑运算符号两边必须有空格，否则影响模板解析

6、form.is_valid内部逻辑中的Clean_data处理中抛出的异常不会向外传递，只会变成form.is_valid()返回false.

7、Django的业务层和View层怎么切分这个问题，一个简单的方法就是给业务层传递什么层级的参数，个人觉得传递验证过的form比较合适。

8、多级if else的两个简化技巧：1是直接用except处理；2是该半路return的直接return掉,这样做虽然不符合过程编程函数设计原则，但是代码相对简洁了很多。

9、Ubuntu生产环境下不能Print Unicode中文，否则会导致error.

10、因为DJango的500机制和事务机制，所以Django的View层对异常处理代码的依赖比较弱。

11、model form定义：没有在前端页面出现的字段，一定要exclude掉或者Null了，不过Null会影响默认值，所以最好的方法是Exclude掉，否则即便blank掉，也会导致form存储时出错。因为表单中字段不出现会把默认值覆盖成Null。比exclude更方便的定义方式是定义fields元信息，这样model添加不用的字段不用跑来重新更新form定义

12、数据库存时区性数据的格式化显示一定要放在template里面用date之类的过滤器操作，如果用datetime的striftime直接格式化，会导致时区性数据丢失，出来的时间成了格林威治时间值了，如果在代码中strifttime处理,可以先用django.utils.timezone.localtime方法处理一下，这样出来的时间才是正常的

13、Django调试中的一个问题：众所周知，runserver启动，改动代码，服务会重启，但是改动自定义标签代码，服务是不会重启的。

14、form验证的errors在比较旧的版本里面是没有文本信息，前一段时间看文档，发现新版本有对errors有所加强，比较好用的比如as_json()和as_text()，两个方法，我在比较旧的版本中是自己写个函数对errors对象做解析生成反馈文本信息。

15、ManyToMany字段的through不能add or remove，为了扩展性的考虑，建议默认都加上through，可以为中间关系表加个date_added字段，顺便都加上unique_together约束，不过用through是有缺陷的：写操作略麻烦。那么如果你没加through，准备改成加through的，应该怎样最小改动的操作哪，应该是先把这个ManyToMany字段删除掉，并且migrate生效，然后再加一个有through的ManyToMany字段，当然了后台的数据还的备份重生效一次。这应该算是目前Django Migration特性的一个缺陷。