目录：Django其他篇

01：Django基础篇

02：Django进阶篇

03：Django数据库操作--->Model

04: Form 验证用户数据 & 生成html

05：ModelForm 数据验证 & 生成html & 数据库操作

06: Django Admin

07: Django 学习补充

目录：

1.1 ModelForm作用及基本使用返回顶部

　　1、form 作用

　　　　　　1、功能1：  验证

　　　　　　2、功能2：  生成html标签（默认功能：保留上次提交的值）

　　　　　　3、功能3：  数据操作

　　　　　　4、功能4： HTML Form提交保留上次提交数据

　　　　　　5、功能5： 初始化页面显示内容

　　2、form使用原则

　　　　　　1、 新url方式操作（一定要用form方式生成html，避免提交刷新页面，丢失当前页面中填的值）

　　　　　　2、 发Ajax请求时可以不用form生成html标签，仅用form做验证，因为ajax请求本身不刷新页面，不必担心填

　　　　　　     的值会丢失，当然使用form生成html也是可以的

1.2 Meta中定义字段验证规则返回顶部

　　　　注意： 导入模块名（fields、widgets）和字段名重复，所以导入时要起个别名。

  1. from django import forms
  2. from django.forms import fields as Ffields
  3. from django.forms import widgets as Fwidgets
  4. class UserInfoModelForm(forms.ModelForm):
  5.  
  6.     is_rmb = Ffields.CharField(widget=Fwidgets.CheckboxInput())
  7.  
  8.     class Meta:
  9.         model = models.UserInfo
  10.         fields = '__all__'
  11.         # fields =  ['username','email']
  12.         # exclude = ['username']
  13.         labels = {
  14.             'username': '用户名',
  15.             'email': '邮箱',
  16.         }
  17.         help_texts = {
  18.             'username': '...'
  19.         }
  20.         widgets = {
  21.             'username': Fwidgets.Textarea(attrs={'class': 'c1'})
  22.         }
  23.         error_messages = {
  24.             '__all__':{    # 整体错误信息
  25.  
  26.             },
  27.             'email': {
  28.                 'required': '邮箱不能为空',
  29.                 'invalid': '邮箱格式错误..',
  30.             }
  31.         }
  32.         field_classes = {  # 定义字段的类是什么
  33.             # 'email': Ffields.URLField  # 这里只能填类，加上括号就是对象了。
  34.         }
  35.  
  36.         # localized_fields=('ctime',)  # 哪些字段做本地化

Meta中可以定义的字段类型

1.3 ModelForm应用：编辑默认选中 及 提交自动保存返回顶部

　　1、所有文件

  1. from app01 import views
  2. urlpatterns = [
  3.     url(r'^admin/', admin.site.urls),
  4.     url(r'^index/', views.index),
  5.     url(r'^user_list/', views.user_list),
  6.     url(r'^user_edit/(?P<nid>\d+)/', views.user_edit),
  7. ]

urls.py 路由系统

  1. from django.db import models
  2.  
  3. class UserType(models.Model):
  4.     caption = models.CharField(max_length=32)
  5.     def __str__(self):
  6.         return self.caption
  7.  
  8. class UserInfo(models.Model):
  9.     username = models.CharField(max_length=32)
  10.     email = models.EmailField()
  11.     user_type = models.ForeignKey(to='UserType', to_field='id')

models.py 定义表

  1. from django.shortcuts import render,HttpResponse
  2. from app01 import models
  3. from app01.forms import UserInfoModelForm
  4.  
  5. #1、创建UserInfo表中数据
  6. def index(request):
  7.     if request.method == 'GET':
  8.         obj = UserInfoModelForm()
  9.         return render(request,'index.html',{'obj':obj})
  10.     elif request.method == 'POST':
  11.         obj = UserInfoModelForm(request.POST)
  12.         if obj.is_valid():
  13.             obj.save()
  14.         return render(request,'index.html',{'obj':obj})
  15.  
  16. #2、展示UserInfo表中数据
  17. def user_list(request):
  18.     li = models.UserInfo.objects.all().select_related('user_type')
  19.     return render(request,'user_list.html',{'li':li})
  20.  
  21. #3、编辑默认选中 & 提交自动保存
  22. def user_edit(request,nid):
  23.     if request.method == 'GET':
  24.         user_obj = models.UserInfo.objects.filter(id=nid).first()
  25.         mf = UserInfoModelForm(instance=user_obj)                       #只用传入instance点击编辑时就会默认选中
  26.         return render(request,'user_edit.html',{'mf':mf,'nid':nid})
  27.     elif request.method == 'POST':                                     #ModelForm修改
  28.         user_obj = models.UserInfo.objects.filter(id=nid).first()       # 如果这里没有传入 instance=user_obj就会变成ModelForm添加
  29.         mf = UserInfoModelForm(request.POST,instance=user_obj)          #修改后数据要传递进去
  30.         if mf.is_valid():
  31.             mf.save()
  32.         else:
  33.             print(mf.errors.as_json())
  34.         return render(request,'user_edit.html',{'mf':mf,'nid':nid})
  35.  
  36. ####################  自动生成UserType 和 UserInfo 表中的数据   ##############
  37.  
  38. usertype_list = [
  39.     {'caption':'python_group'},
  40.     {'caption':'linux_group'},
  41. ]
  42.  
  43. userinfo_list = [
  44.     {'username':'zhangsan','email':'zhangsan@qq.com','user_type_id':1,},
  45.     {'username':'lisi','email':'lisi@qq.com','user_type_id':1,},
  46.     {'username':'wangwu','email':'wangwu@qq.com','user_type_id':1,},
  47. ]
  48.  
  49. '''
  50. for u_type in usertype_list:
  51.     models.UserType.objects.create(**u_type)
  52.  
  53. for userinfo in userinfo_list:
  54.     models.UserInfo.objects.create(**userinfo)
  55. '''

views.py 视图函数

  1. from django.shortcuts import render,HttpResponse
  2. from django import forms
  3.  
  4. # 在ModelForm中有插件名widgets，所以这里引入插件时要取别名，否则报错
  5. from django.forms import fields as Ffields
  6. from django.forms import widgets as Fwidgets
  7. from app01 import models
  8.  
  9. class UserInfoModelForm(forms.ModelForm):
  10.     extraField = Ffields.CharField( widget=Fwidgets.CheckboxInput() )     #ModelForm中可以自定制额外字段
  11.     class Meta:
  12.         model = models.UserInfo                   #model指定关联那个类
  13.         fields = '__all__'
  14.  
  15.         labels = {
  16.             'username':'用户名',
  17.             'email':'邮箱',
  18.         }
  19.  
  20.         help_texts = {
  21.             'username':'username字段提示信息'
  22.         }
  23.  
  24.         widgets = {
  25.             'username':Fwidgets.Textarea(attrs={'class':'c1',})
  26.         }
  27.  
  28.         error_messages = {
  29.             '__all__':{},                     #定义整体的错误信息
  30.             'email':{
  31.                 'required':'邮箱不能为空',
  32.                 'invalid':'邮箱格式错误',
  33.             }
  34.         }
  35.  
  36.         field_classes = {
  37.             # 'email':Ffields.URLField         #改变字段格式为url
  38.         }
  39.  
  40.         localized_fields=('birth_date',)

forms.py 数据验证规则

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <form action="/index/" method="POST">
  9.         {% csrf_token %}
  10.         <p>{{ obj.username.label }}: {{ obj.username }} {{ obj.errors.username.0 }}</p>
  11.         <p>{{ obj.email.label }}: {{ obj.email }} {{ obj.errors.email.0 }}</p>
  12.         <p>{{ obj.user_type.label }}: {{ obj.user_type }} {{ obj.errors.user_type.0 }}</p>
  13.         <p>{{ obj.extraField.label }}: {{ obj.extraField }} {{ obj.errors.extraField.0 }}</p>
  14.  
  15.         <input type="submit" value="提交">
  16.     </form>
  17. </body>
  18. </html>

index.html生成html 创建数据

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <ul>
  9.         {% for row in li %}
  10.             <li>{{ row.username }}-{{ row.user_type.caption }}
  11.                 <a href="/user_edit/{{ row.id }}/">编辑</a></li>
  12.         {% endfor %}
  13.     </ul>
  14. </body>
  15. </html>

user_list.html 展示数据

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <form method="POST" action="/user_edit/{{ nid }}/">
  9.         {% csrf_token %}
  10.         {{ mf.as_p }}
  11.         <input type="submit" value="提交">
  12.     </form>
  13. </body>
  14. </html>

user_edit.html 编辑数据

 　　2、说明

　　　　　　1. http://127.0.0.1:8000/index/  页面用来新建用户（在views.py中也有批量创建的for循环）

　　　　　　2. http://127.0.0.1:8000/user_list/ 页面用来展示已创建用户，当点击编辑是会携带对应用户的id，已gett请求提交给user_edit

　　　　　　3. http://127.0.0.1:8000/user_edit/1/ 这个路径携带有需要修改的用户id，实现编辑默认选中 及 提交自动保存

1.4 MordelForm中生成html & 数据验证 常用方法返回顶部

　　1、生成HTML常用语法

　　　　　　1、 obj.user.label                     标签显示内容（如：用户名）
　　　　　　      obj.user.label_tag

　　　　　　2、 obj.user                            自动生成一个input标签，这种表自动保留上一次提交的数据功能

　　　　　　3、 obj.errors.user.0              获取字段错误信息（提取到user字段）
　　　　　　      obj.errors                          所有字段错误信息的html字符串
　　　　　　      obj.user.errors                 错误信息（返回html标签）<ul class="errorlist"><li>用户名不能为空</li></ul>

　　　　　　4、 obj.email.help_text          获取提示帮助信息（必须输入邮箱格式）

　　4、ModelForm对象数据验证

　　　　1. 用于验证

　　　　　　　　model_form_obj = XXOOModelForm(request.POST)           # 将POST中提交的所有数据传给处理类（类中做校验）
　　　　　　　　model_form_obj.is_valid()                                                # 类中对输入信息校验结果，符合返回True,否则返回False
　　　　　　　　model_form_obj.clean()                                                   # 用户POST中所有正确信息，格式就是字典
　　　　　　　　model_form_obj.cleaned_data

　　　　　　　　model_form_obj.errors.as_json()                                     # 错误信息转换成json格式
　　　　　　　　model_form_obj.errors                                                       # 所有错误信息的html字符串（ul li格式）

　　　　2. 用于创建保存

　　　　　　　　# 默认保存多对多
　　　　　　　　obj = form.save(commit=True)

　　　　　　　　# 不做任何操作，内部定义 save_m2m（用于保存多对多）
　　　　　　　　obj = form.save(commit=False)
　　　　　　　　obj.save()                                                 # 保存单表信息
　　　　　　　　obj.save_m2m()                                       # 保存关联多对多信息

　　　　4、新建数据 、修改数据、默认选中

　　　　　　　　UserInfoModelForm(request.POST,instance=user_obj)           # 修改新旧数据都需要提交

　　　　　　　　UserInfoModelForm(request.POST)                                        # 新建只需提交request.POST数据

　　　　　　　　UserInfoModelForm(instance=user_obj)                                 # 只用传入instance点击编辑时就会默认选中　

　　　　5. 验证执行过程
　　　　　　　　is_valid -> full_clean -> 钩子 -> 整体错误

  1. def clean_字段名(self):
  2.     # 可以抛出异常
  3.     # from django.core.exceptions import ValidationError
  4.     return "新值"

定义字段钩子

1.5 ModelForm验证规则中的内置钩子返回顶部

　　1. from验证经历的顺序（搜索：Form and field validation）

　　　　　　 验证执行过程：  is_valid -> full_clean -> 钩子 -> 整体错误

　　　　　　1、拿到字段：用户发送一堆数据，根据form循环，拿到第一个字段

　　　　　　2、正则匹配：先进行fields默认正则表达式判断，然后进行自定的正则表达式判断（如果有）

　　　　　　3、字段钩子函数：然后执行字段的钩子函数，接着进行第二个字段，然后是第二个字段钩子函数...

　　　　　　4、clean钩子函数：字段钩子函数执行完了再执行clean钩子函数进行整体验证

　　　　　　5、_post_clean:     最后执行_post_clean钩子做其他验证

　　2、 form验证的错误信息存放位置

　　　　　　1、字段钩子错误信息放到对应的字段中 （obj.error中对应的字段字典）

　　　　　　2、整体错误信息会放到 {"__all__":[],}中等价于{'NON_FIELD_ERRORS':[],} （如：执行clean）

　　3、forms.py文件中使用这三种钩子

  1. from django import forms
  2. from django.forms import fields as Ffields
  3. from django.forms import widgets as Fwidgets
  4. from app01 import models
  5. from django.core.exceptions import ValidationError
  6.  
  7. class UserInfoModelForm(forms.ModelForm):
  8.     extraField = Ffields.CharField( widget=Fwidgets.CheckboxInput() )     #ModelForm中可以自定制额外字段
  9.     class Meta:
  10.         model = models.User                    #model指定关联那个类
  11.         fields = '__all__'
  12.  
  13.         labels = {
  14.             'name':'用户名',
  15.             'pwd':'密码',
  16.         }
  17.  
  18.     #1 clean_字段名 是字段钩子（每个字段都有对应的这个钩子）：如判断：“用户名已存在”
  19.     def clean_user(self):
  20.         # self.cleand_data['user']是用户提交的数据'
  21.         c = models.User.objects.filter(name=self.cleand_data['user']).count()
  22.         if not c:
  23.             return self.cleand_data['user']     #必须要有返回值
  24.         else:
  25.             raise ValidationError('用户名已存在',code='xxx')
  26.  
  27.     #2 clean钩子对整体验证：如判断“用户名或密码错误”
  28.     def clean(self):
  29.         c = models.User.objects.filter(
  30.             name=self.cleand_data['user'],
  31.             pwd=self.cleand_data['pwd']).count()
  32.         if c:
  33.             return self.cleand_data     #正确的值必须return回去
  34.         else:
  35.             raise ValidationError('用户名或密码错误')
  36.  
  37.     #3 在这里可以做 其他验证
  38.     def _post_clean(self):
  39.         pass

forms.py文件中使用这三种钩子

1.6 使用type动态生成ModelForm类进行数据验证、生成html返回顶部

  1. from django.db import models
  2.  
  3. class User(models.Model):
  4.     username = models.CharField(max_length=32)
  5.     def __str__(self):
  6.         return self.username
  7.  
  8.     def default_form_validation(self):
  9.         ''' 每个class_admin都可以重写这个方法来对整体验证'''

models.py创建表

  1. from django.shortcuts import render
  2. from app01 import models
  3. from app01.forms import create_model_form
  4.  
  5. def login(request):
  6.     model_form_class = create_model_form(request,models.User)
  7.  
  8.     form_obj = model_form_class()
  9.  
  10.     if request.method == 'POST':
  11.         obj = models.User.objects.get(id=1)
  12.         form_obj = model_form_class(instance=obj)
  13.         form_obj = model_form_class(request.POST,instance=obj)
  14.         if form_obj.is_valid():
  15.             form_obj.save()
  16.         else:
  17.             print('errors',form_obj.errors)
  18.     return render(request, 'loin.html',{'form_obj':form_obj})

views.py视图函数

  1. from django.forms import ModelForm,ValidationError
  2. from app01 import models
  3.  
  4. def create_model_form(request,admin_class):
  5.     def __new__(cls,*args,**kwargs):                               # 重写ModelForm的__new__方法
  6.         '''
  7.         作用1--> 添加字段样式： class="form-control"
  8.         作用2--> 添加字段钩子： clean_字段名
  9.         '''
  10.         for field_name, field_obj in cls.base_fields.items():
  11.             # field_name : 字段名称，比如 "username"
  12.             # field_obj  : 定义字段样式的类
  13.             field_obj.widget.attrs['class'] = "form-control"      # 给所有字段添加样式：class="form-control"
  14.  
  15.             if hasattr(admin_class, "clean_%s" % field_name):      # clean_字段名 是字段钩子（每个字段都有对应的这个钩子）
  16.                 field_clean_func = getattr(admin_class, "clean_%s" % field_name)
  17.                 setattr(cls, "clean_%s" % field_name, field_clean_func)
  18.         return ModelForm.__new__(cls)                              # 调用一下ModelForm的__new__方法否则不往下走
  19.  
  20.     def default_clean(self):                                        # 重写ModelForm的 default_clean 方法
  21.         '''添加默认钩子'''
  22.         error_list = []
  23.  
  24.         # 在这个cleaned方法中定义一个允许用户自己定义的方法做验证
  25.         response = admin_class.default_form_validation(self)
  26.         if response:
  27.             error_list.append(response)
  28.  
  29.         if error_list:
  30.             raise ValidationError(error_list)
  31.  
  32.     class Meta:                          # ModelForm中使用Meta类进行条件过滤
  33.         model = models.User              # model指定关联那个类
  34.         fields = "__all__"               # 对那些字段过滤
  35.  
  36.         labels = {
  37.             'username': '用户名',
  38.         }
  39.  
  40.     attrs = {'Meta':Meta}
  41.  
  42.     _model_form_class = type("DynamicModelForm",(ModelForm,),attrs)       #创建类并设置Meta属性
  43.     setattr(_model_form_class,"__new__",__new__)                           #动态将__new__函数添加到类中
  44.     setattr(_model_form_class,'clean',default_clean)                       #动态将_default_clean__函数添加到类中
  45.  
  46.     return _model_form_class

froms.py动态生成ModelForm类

1.7 ModelForm实例：不使用ModelForm生成html、并用ajax提交显示错误信息返回顶部

　　相关知识点：

　　　　　　1、不使用ModelForm生成html
　　　　　　2、使用ajax提交数据，所以无法使用obj.errors.xxx 在前端显示错误信息
　　　　　　3、使用json序列化ModelForm验证的错误信息
　　　　　　4、使用ajax将错误信息放到对应位置

  1. from django.shortcuts import render,HttpResponse
  2. from django.utils import timezone
  3. from django.core.exceptions import ValidationError
  4.  
  5. import hashlib
  6. import json
  7.  
  8. from app01.models import User
  9. from app01.forms import RegisterFrm
  10.  
  11. class JsonCustomEncoder(json.JSONEncoder):
  12.     def default(self, field):
  13.         if isinstance(field, ValidationError):
  14.             return {'code':field.code,'messages':field.messages}
  15.         else:
  16.             return json.JSONEncoder.default(self, field)
  17.  
  18. def register(request):
  19.     if request.method == 'POST':
  20.         if request.method == 'POST':
  21.             ret = {'status': False, 'error': None, 'data': None}
  22.             obj = RegisterFrm(request.POST)
  23.             if obj.is_valid():
  24.                 cd = obj.cleaned_data
  25.                 new_user = obj.save(commit=False)
  26.  
  27.                 # 将密码md5加密后再存到数据库中
  28.                 password2 = cd.get("password2")
  29.                 m = hashlib.md5()
  30.                 m.update(password2.encode())
  31.                 new_user.password = m.hexdigest()
  32.                 new_user.save()
  33.                 ret['status']=True
  34.                 return HttpResponse(json.dumps(ret))
  35.             else:
  36.                 ret['error'] = obj.errors.as_data()  # as_json() 返回的是字符串
  37.             request = json.dumps(ret, cls=JsonCustomEncoder)
  38.             return HttpResponse(request)
  39.     obj = RegisterFrm()
  40.     return render(request,'register.html',{'obj':obj})
  41.  
  42. # 登陆 ： 这里没有做登录界面只有验证密码的函数
  43. def login(request):
  44.     if request.method == 'POST':
  45.         login_name = request.POST.get("login_name")
  46.         password = request.POST.get("password")
  47.         if login_name and password:
  48.             # 将密码转md5
  49.             m = hashlib.md5()
  50.             m.update(password.encode())
  51.             password_md5 = m.hexdigest()
  52.             # 获取用户对象
  53.             user = User.objects.filter(login_name=login_name, password=password_md5).first()
  54.             if user:
  55.                 print('用户密码正确')

views.py

  1. from django.db import models
  2.  
  3. class User(models.Model):
  4.     login_name = models.CharField(max_length=32,unique=True,verbose_name="用户名",error_messages={'unique':"用户名已占用"})
  5.     password = models.CharField(max_length=32)
  6.     email = models.EmailField(unique=True,error_messages={'unique':'邮箱已注册'})
  7.     def __str__(self):
  8.         return self.login_name

models.py

  1. from django import forms
  2. from django.forms import fields
  3. from app01.models import User
  4.  
  5. class RegisterFrm(forms.ModelForm):
  6.     login_name = forms.CharField(
  7.         required=True,
  8.         error_messages={
  9.             'required': '用户名不能为空',
  10.     })
  11.     email = forms.EmailField(
  12.         error_messages={
  13.             'required': '邮箱不能为空',
  14.             'invalid':'邮箱格式错误'
  15.     })
  16.     password = forms.CharField(
  17.         widget=forms.PasswordInput,
  18.         label="密码",
  19.         error_messages={
  20.             'required': '密码不能为空',
  21.     })
  22.     password2 = forms.CharField(
  23.         widget=forms.PasswordInput,
  24.         label="确认密码",
  25.         error_messages={
  26.             'required': '确认密码不能为空',
  27.     })
  28.  
  29.     class Meta:
  30.         model = User
  31.         fields = ("login_name", "password", "email")
  32.  
  33.     def clean_login_name(self):
  34.         """login_name里不允许有空格"""
  35.         cd = self.cleaned_data
  36.         login_name = cd.get("login_name").strip()
  37.         if " " in login_name:
  38.             raise forms.ValidationError("用户名不能有空格")
  39.         return login_name
  40.  
  41.     def clean_password2(self):
  42.         """两次密码是否一致"""
  43.         cd = self.cleaned_data
  44.         if cd['password'] != cd['password2']:
  45.             raise forms.ValidationError('确认密码不一致')
  46.         return cd['password2']

forms.py

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <div class="reg_frm fl">
  9.         <h1>注册{{ obj.errors }}</h1>
  10.         <form id="register_frm">
  11.             <table>
  12.                 <tr>
  13.                     <th>用户名</th>
  14.                     <td><input type="text" id="login_name" name="login_name"></td>
  15.                     <td class="tips">{{ obj.login_name.errors.0 }}</td>
  16.                 </tr>
  17.                 <tr>
  18.                     <th>邮箱</th>
  19.                     <td><input type="email" id="email" name="email"></td>
  20.                     <td class="tips">{{ obj.email.errors.0 }}</td>
  21.                 </tr>
  22.                 <tr>
  23.                     <th>密码</th>
  24.                     <td><input id="password" type="password" name="password" autocomplete="off" minlength="3"></td>
  25.                     <td class="tips">{{ obj.password.errors.0 }}</td>
  26.                 </tr>
  27.                 <tr>
  28.                     <th>确认密码</th>
  29.                     <td><input id="password2" type="password" name="password2" autocomplete="off" minlength="3"></td>
  30.                     <td class="tips"></td>
  31.                 </tr>
  32.             </table>
  33.             <p><input type="button" value="ajax提交" onclick="ajaxSubmit();"></p>
  34.         </form>
  35.     </div>
  36.     <script src="/static/jquery-1.12.4.min.js"></script>
  37.     <script>
  38.         function ajaxSubmit() {
  39.             $.ajax({
  40.                 url:'/register/',
  41.                 data:$('#register_frm').serialize(),
  42.                 type:'POST',
  43.                 dataType:'json',
  44.                 success:function(arg){                //服务端返回的是字符串格式
  45.                     if(arg.status==true){
  46.                         console.log('成功创建用户后的操作')
  47.                     }else {
  48.                         var check_list = {
  49.                             'login_name':'用户名',
  50.                             'email':'邮箱',
  51.                             'password':'密码',
  52.                             'password2':'确认密码'
  53.                         };
  54.                         for(var key in check_list){
  55.                             $('#'+key).parent().parent().find('.tips').text('');
  56.                             var err_val = "arg.error." + key +"[0].messages";
  57.                             try{
  58.                                 var err = eval(err_val);
  59.                                 $('#'+key).parent().parent().find('.tips').text(err)
  60.                             }catch (err){
  61.                                 console.log(err.message);
  62.                             }
  63.                         }
  64.                     }
  65.                 }
  66.             })
  67.         }
  68.     </script>
  69. </body>
  70. </html>

register.html

05：ModelForm 数据验证 & 生成html & 数据库操作的更多相关文章

  1. 手把手封装数据层之DataUtil数据库操作的封装

    上一篇我们写完了数据库连接的封装 没有看的请移步上一篇关于数据库连接的内容 这次我们讲数据库操作的封装.数据库的操作就是增删改查:心再大一点就可以直接分为查询和其他. 因为查询是有返回对象的,而其他都 ...

  2. Android数据读取之Sqlite数据库操作

    咱们书接上文,继续来说说Android数据读取,这回,我们要讲的是Sqlite数据库的相关操作.以一个实例开始吧: 首先,上图,看看做成后的效果: 大概描述:类似于浏览器的收藏夹,网站名称,网站地址, ...

  3. android菜鸟学习笔记20----Android数据存储(四))Android数据库操作

    Android内置了一个名为SQLite的关系型数据库,这是一款轻量型的数据库,操作十分简便.SQLite与别的数据库不同的是,它没有数据类型.可以保存任何类型的数据到你所想要保存的任何表的任何列中. ...

  4. Effective C++ .05 一些不自动生成copy assigment操作的情况

    主要讲了 1. 一般情况下编译器会为类创建默认的构造函数,拷贝构造函数和copy assignment函数 2. 执行默认的拷贝构造/copy assignment函数时,如果成员有自己的拷贝构造/c ...

  5. 03: Django Model数据库操作

    目录:Django其他篇 01:Django基础篇 02:Django进阶篇 03:Django数据库操作--->Model 04: Form 验证用户数据 & 生成html 05:Mo ...

  6. python 学习笔记十六 django深入学习一 路由系统，模板，admin，数据库操作

    django 请求流程图 django 路由系统 在django中我们可以通过定义urls,让不同的url路由到不同的处理函数 from . import views urlpatterns = [ ...

  7. 结合java的反射和泛型性质简化JDBC和相应的同步等服务器数据库操作代码

    github地址:https://github.com/hzphzp/HeartTrace_Server 我们的服务器端数据库并没有用sqllite, 而是直接用mysql,并且用JDBC直接进行操作 ...

  8. PHP 生成 MySql 数据库字典

    项目说明 通过配置 MySql 数据库信息,使用 PHP 生成数据表字典可以输出在当前页面,可以生成文件保存在指定位置,也可以下载格式支持网页HTML格式.CSV格式(Excel 读取).ZIP压缩格 ...

  9. JSP中的数据库操作，MySQL基础操作（一）

    一.JDBC JDBC(java data base concectivity),是一种用于执行SQL语句的java API,可以为多种关系库提供统一访问. 通常使用JDBC完成以下操作: 1)同数据 ...

随机推荐

  1. SQL Fundamentals || DCL(Data Control Language) || 角色ROLES

    SQL Fundamentals || Oracle SQL语言 语句 解释 Create user Creates a user(usually performed by a DBA) Grant ...

  2. Git：从github上克隆、修改和更新项目

    一.在本地新建一个文件夹,作为本地仓库,如“BigProjet”.在该文件夹打开git bash,进入到该文件夹目录下 二.将本地仓库初始化 $ git init 三.将项目从github或者服务器上 ...

  3. 从url到请求 再到页面生成

    百度面试 从url到请求 再到页面生成 - MartinDing - 博客园 https://www.cnblogs.com/martinding/p/7458723.html

  4. C#中DataSet、DataTable、DataReader的区别

    简单说就是:     DataSet:数据集.一般包含多个DataTable,用的时候,dataset["表名"]得到DataTable         DataTable:数据表 ...

  5. Map集合遍历

    Map<String,String> map = new HashMap<String, String>(); map.put("1","java ...

  6. 缓存服务，还未创建完缓存时， 需要更改图层名称、服务名称、数据源位置、mxd名称等

    缓存服务,还未创建完缓存时, 需要更改图层名称.服务名称.数据源位置.mxd名称等.已经创建好的缓存还可以再用吗? 测试后可以, 注意:新服务相对旧服务,符号样式没有改变,切片方案没有变化. 测试步骤 ...

  7. centos7设置iptables

    https://www.linuxidc.com/Linux/2017-10/147238.htm

  8. paas容器云

  9. python修饰器各种实用方法

    This page is meant to be a central repository of decorator code pieces, whether useful or not <wi ...

  10. Django单元测试简单示例

    对一个功能的验证往往是需要很多多测试用例,可以把测试用例集合在一起执行,这就产生了测试套件TestSuite 的概念,它是用来组装单个测试用例,规定用例的执行的顺序,而且TestSuite也可以嵌套T ...