Python 19 Django 详解

　　

本节概要

　　Django详解

前言

有一部分原因是，确实djando的课程有点多；并且，最近又在研究利用python做数据分析时间上耽误了。所以楼主讲所有的课程全部重新观看了一遍，再来撰写博客，其实说起来，django的博客很难写，必须是代码配合着写，尽量做到吧。为了自己，也为了大家，一定会用代码表述出所有的知识点的。

然后就是，加油！2018！希望大家都能跟我一样定下一个小目标并实现它。

关于django项目的新建其实真的没必要多说。对于其余的重点，一一讲起吧。

1、首先Django的请求生命周期

客户端发送请求==》服务器端的url  ==》对应服务器端的函数==》返回字符串 《== open html+ sql orm

Form表单提交：
	提交	-> url	-> 函数或类中的方法　　->DB 或者HTML
						 HttpResponse(已经渲染完成的字符串，obj.name已经被目的变量字符串替代)
						 render/
						 redirect
						 返回给字符串中的html语言语法，都是经过处理的，即render发送的html跟参数并不是直接返回给用户，而是处理好的标准字符串
　　　　 用户	<<<<<<<<<<<<<<返回<<<<<<<<<<<<<   字符串	（接收到redirect时）自动发起另外一个请求
	--> url	...

Ajax：
	提交	-> url	->	函数或类（HttpResponse）
	返回字符串			<<<<<<<<<<<<
	location.reload()	==> 刷新
	location.href="某个地址"	==> 跳转

　　

2、创建django project

1、django-admin startproject mysite

2、python manage.py startapp cmdb

3、模板路径、静态文件路径、注释csrf

3、路由系统　　

/index/					->	函数或类.as_view()
/detail-(\d+)/			->	函数（参数）或类.as_view() （参数）
/detail/(?P<nid>\d+)	->	函数（参数）或者类.as_view()	(参数)
/cmdb/					->	include("app01.urls")
/cmdb/ name='a1'		->	include("app01.urls")
						- 视图中：reverse
						- 模板语言中：{%url “a1”%}
　*********

　url(r'^wqefvqwbeqnwdla/', views.index, name='indexx')
　<form action='{%url 'indexx'%}' method="post">
　url(r'^wqefvqwbeqnwdla/(\d+)/', views.index, name='indexx') =>	<form action='{%url 'indexx' 2%}' method="post"> form里面的2是写死的，没办法灵活追踪

*******
urlpatterns = patterns(‘‘,
		url(r‘^article$‘,‘get_news_index‘ ，name="news_index"),
		　　　　)
<a href="{%url ‘appname:news_index‘%}">资讯</a>
其中appname是该url所在的app的name，而new_index是url(r‘^article$‘,‘get_news_index‘ ，name="news_index")中的name参数
HttpResponseRedirect(reverse("news_index"))

# 默认值
url(r‘^index/‘,views.index, {'name':'dandy'}),
def index(request, name):  # 注意这里必须接收name参数，不然报错，因为url里面有**kwargs参数的存在

# 命名空间
/admin/		include('app01.urls', namespace='admin')
/cmdb/		include('app01.urls', namespace='cmdb')

app01.urls
/index/     name ='n1'
# 同时 app01外部设置一下app01的名称、app_name = 'app01'
def index(request):
    reverse('admin:n1')  # 生成urls
模板语言里面：
    {% url 'admin:index'%}

　　

4、视图

request.GET
request.POST
request.FILES
# checkbox 等多选内容   request.POST.getlist()

# 上传文件 <form enctype="multipart/form-data">

request.path_info ==> 获取当前请求的网址
文件对象 = request.FILES.get()
文件对象.name => 文件名
文件对象.size =>字节大小
文件对象.chunks()
obj = request.FILES.get('aaa')
obj.name
f = open(obj.name, mode="wb")
for item in obj.chunks():
	f.write(item)
f.close()

　FBV：函数
　　　def index（request, *args, **kwargs）:
　　　　..
　CBV：类
　　　class Home(views.View):
　　　　def get(self, request, *args, **kwargs):
　　　　　　...

# 视图的其他信息
from django.core.handlers.wsgi import WSGIRequest  #从WSGIRequest 下钻可以查到内部environ的方法
request.environ
request.environ['HTTP_USER_AGENT']	==> 查看发送过来的终端，iphone，Android，pc. #根据key可以取很多内容，可以for循环查看

关于请求头：

\r\n\r\n 作为请求头跟body的分割
request.body	所有原生内容存储
request.Meta(...)	用户终端就存储在这里

服务器返回的时候 也是两部分，响应内容和响应头
response['name'] = 'dandy'
接受的响应头里面还有上面定制的这组键值对

　　

CBV 和 FBV的装饰器

我们以登陆用户认证为例：

- 装饰器	==>	用装饰器解决重复用户认证
FBV
	    def auth(func):
		def inner(request, *args, **kwargs):
			v = request.COOKIES.get('username')
			if not v:
    			    return redirect('/app01/temp1')
			return func(request, *args, **kwargs)
		return inner

CBV
from django.utils.decorators import method_decorator
	    def auth(func):
		def inner(request, *args, **kwargs):
			v = request.COOKIES.get('username')
			if not v:
    			    return redirect('/app01/temp1')
			return func(request, *args, **kwargs)
		return inner

	# @method_decorator(auth, name='dispatch')
	class Order(views.View):
		#@method_decorator(auth)
		#def dispatch(self, request, *args, **kwargs):
		#      return super(Order, self).dispatch(request, *args, **kwargs)

                @method_decorator(auth)
		def get(self,request):
		       v = request.COOKIES.get('username')
		       return render(request, 'temp3.html')

解读下上面的那么多装饰器；首先，CBV需要用django的自带装饰器。如果我们只想作用于一个函数方法可以直接在方法前面加上装饰器@method_decorator(auth)，就比如上面例子里面的get方法上面的那个装饰器。但是如果想要作用域所有的函数方法，比较笨的方法就是全部一个个加上装饰器，然而，之前提过一个dispatch函数，执行任何函数前，都会执行这个方法，所以我们可以改造一下这个方法，即继承并加上装饰器，就如图上的dispatch方法上面的装饰器。当然啦，高手正常连这样写都嫌烦，因为要写dispatch的继承再装饰。可以针对整个CBV进行装饰，设定装饰器的定位函数为dispatch，这么看起来就更高大上，@method_decorator(auth, name='dispatch')

5、模板语言

**************在django的模板语言里面，索引用点，没有中括号****************
# 循环取值
{% for i in dict%}
<td>{{%i.item%}}</td>
{%endfor%}

# 取值
<h1>{{obj.name}}</h1>

# if else逻辑判断
{%if a==b%}
    <p>aaa</p>
{%else%}
    <p>vvv</p>
{%endif%}

render(request,"*.html", {"obj":1234, "k1":{1,2,3,4}, "k2":{"name":"dandy"})

<h1>{{obj}}</h1>
<h2>{{k1.0}}</h1>
<h3>{{k2.name}}</h3>
{%for i in k1%}
<td>i</td>
{%endfor%}

{%for row in k2.keys%}
<td>row</td>
{%endfor%}

{%for row in k2.values%}
<td>row</td>
{%endfor%}

{%for key,value in k2.items%}
<td>key, value</td>
{%endfor%}

　模板语言序列化

　JSON.parse(data)==>转换为json数据
　JSON.stringify(data)==>json数据转换为字符串

{{forloop.counter}}	--> 模板语言里给表的每行加一个序号，自增，相当于数据库ID
{{forloop.counter0}}	-->从0开始
{{forloop.revcounter}}	-->倒序
{{forloop.revcounter0}}	-->倒序排到0
{{forloop.last}}	-->是否是最后一个循环
{{forloop.first}}	-->是否是第一个循环
{{forloop.parentloop}}	-->父循环的序列号（外层还有个循环，嵌套的在里面的用这一句，第一次输出全是1，第二次2）

模板继承与导入

- 母版..html
	模板继承
		- master		{% block content %}{% endblock %}
		- master:header	{% block title %}{% endblock %}

		页网页先写上{% extends 'master.html' %}，表明继承哪个模板
		- 子页面		{% block content %}{% endblock %}	==> 替换模板里面的哪个block
		- 子页面		{% block title %}{% endblock %}

		关于继承母版的css跟js：
		在母版的css下面写上一个	{% block css %}{% endblock %}
							{% block js %}{% endblock %}
		子页面继承：	-css	{% block css %}
							<style>
							    body{background-color: red}
							</style>
						{% endblock %}
					-js	{% block js %}
    							<script>
								..
							</script>
						{% endblock %}

include tag页面，相当于网页上某一块标签样式一直重复的使用,渲染网页的某一块
		- tag.html  ==> <form>
    				    <input type='text' />
				    <input type='button' />
				</form>

		- 要使用tag的界面==>	{% include 'tag.html'%}

模板自定义函数

自定义sample_tag
	1、在app下创建一个templatetags目录
	2、在此目录下新建任意xxoo.py文件
	3、from django import template
	   register = template.Library()

　　　　　　 @register.simple_tag
	   def func(a1, a2)
	       return a1+a2

	4、settings注册app
	5、顶部{% load xxoo%}	如果有extends，写在之后
	6、{% func 1 3%}	==>{% func arg1 arg2 %}
	缺点：不能作为if条件
	优点：参数任意
自定义filter
	1、2、同上
	3、		from django import template
			from django.utils.safestring import mark_safe
			register = template.Library()

			@register.filter
			def func(a1, a2)  # filter只能传2个参数
				return a1+a2
	4、5、
	6、	{{"maliya"|func:"LaoShi"}}	==>	{{arg1|func:"参数二"}}
	优点：可以作为if条件（模板语言里）
	缺点：参数不能任意，最多2个，不能加空格

模板语言自带的方法

帮助方法：
{{ item.event_start|date:"Y-m-d H:i:s"}}
{{ bio|truncatewords:"30" }}
{{ my_list|first|upper }}
{{ name|lower }}

　　

6、Ajax请求

$.ajax({
	url:'/host'		# 提交到哪
	type:“POST”		# 提交方式
	data:{'k1':'v1','k2':'v2'}
	success: function(data){	# 这个匿名函数会等到服务端给我们返回数据时自动触发
		if(data){
			location.reload()
		}else{
			alert(data)
		}
	}
	})
　　　　　ajax请求 return HttpResponse
	$.get(url='xxx',data={'x':'x'})
		-->调用上面的ajax，type为get

	$.post
		-->调用ajax，type为post
	$.getJson

        建议：永远让服务器端返回一个字典
	return HttpResponse(json.dumps(字典))

        模板语言序列化
	JSON.parse(data)==>转换为json数据
	JSON.stringify(data)==>json数据转换为字符串

	$.ajax({
		data:$('.edit_form').serialize()	# 获取所有的editform里面的元素值，打包
		dataType:'JSON'	# 匿名函数的data就会自动序列化成json。#如果这样写返回给success的数据已经就是json数据类型对象
		traditional:true,  # 传给后台的json数据中有列表的时候必须加上,
	})    
jquery
　　var list = []
　　hid = $(this).val()
　　list.push(hid)

7、Cookie & Session

cookie 客户端浏览器上的一个文件,信息以键值对保存。{'name':'dandy'}

# 设置cookies
res = redirect(request, '/index/')
res.set_cookies('username','dandy')	==> 设置cookie，关闭浏览器失效
或者
res = render(request, 'index.html')
res.set_cookies('username','dandy')

# 获取cookies
v = request.COOKIES.get('username')
v = request.COOKIES['username']

其他参数
key,              键
value='',         值
max_age=None,     超时时间
expires=None,    截止时间失效
path='/',         Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问
domain=None,      Cookie生效的域名
secure=False,     https传输
httponly=False    只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）

由于cookie保存在客户端的电脑上，所以，JavaScript和jquery也可以操作cookie。

<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });

加盐

# 基于salt的值加盐
obj = HttpResponse('s')
obj.set_signed_cookie('username','dandy', salt='asdfqw')
# 基于salt进行解密
request.get_signed_cookie('username', salt='asdfqw')

Session

Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：

• 数据库（默认）
• 缓存
• 文件
• 缓存+数据库
• 加密cookie

1、数据库Session

 Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。

 a. 配置 settings.py

     SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）

     SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
     SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
     SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
     SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
     SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
     SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
     SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
     SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）

 b. 使用

     def index(request):
         # 获取、设置、删除Session中数据
         request.session['k1']
         request.session.get('k1',None)
         request.session['k1'] = 123
         request.session.setdefault('k1',123) # 存在则不设置
         del request.session['k1']

         # 所有 键、值、键值对
         request.session.keys()
         request.session.values()
         request.session.items()
         request.session.iterkeys()
         request.session.itervalues()
         request.session.iteritems()

         # 用户session的随机字符串
         request.session.session_key

         # 将所有Session失效日期小于当前日期的数据删除
         request.session.clear_expired()

         # 检查 用户session的随机字符串 在数据库中是否
         request.session.exists("session_key")

         # 删除当前用户的所有Session数据
         request.session.delete("session_key")

         request.session.set_expiry(value)
             * 如果value是个整数，session会在些秒数后失效。
             * 如果value是个datatime或timedelta，session就会在这个时间后失效。
             * 如果value是0,用户关闭浏览器session就会失效。
             * 如果value是None,session会依赖全局session失效策略。

2、缓存session

 a. 配置 settings.py

     SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
     SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置

     SESSION_COOKIE_NAME ＝ "sessionid"                        # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
     SESSION_COOKIE_PATH ＝ "/"                                # Session的cookie保存的路径
     SESSION_COOKIE_DOMAIN = None                              # Session的cookie保存的域名
     SESSION_COOKIE_SECURE = False                             # 是否Https传输cookie
     SESSION_COOKIE_HTTPONLY = True                            # 是否Session的cookie只支持http传输
     SESSION_COOKIE_AGE = 1209600                              # Session的cookie失效日期（2周）
     SESSION_EXPIRE_AT_BROWSER_CLOSE = False                   # 是否关闭浏览器使得Session过期
     SESSION_SAVE_EVERY_REQUEST = False                        # 是否每次请求都保存Session，默认修改之后才保存

 b. 使用

     同上

3、文件session

 a. 配置 settings.py

     SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
     SESSION_FILE_PATH = None                                    # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()                                                            # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T

     SESSION_COOKIE_NAME ＝ "sessionid"                          # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
     SESSION_COOKIE_PATH ＝ "/"                                  # Session的cookie保存的路径
     SESSION_COOKIE_DOMAIN = None                                # Session的cookie保存的域名
     SESSION_COOKIE_SECURE = False                               # 是否Https传输cookie
     SESSION_COOKIE_HTTPONLY = True                              # 是否Session的cookie只支持http传输
     SESSION_COOKIE_AGE = 1209600                                # Session的cookie失效日期（2周）
     SESSION_EXPIRE_AT_BROWSER_CLOSE = False                     # 是否关闭浏览器使得Session过期
     SESSION_SAVE_EVERY_REQUEST = False                          # 是否每次请求都保存Session，默认修改之后才保存

 b. 使用

     同上

4、缓存 + 数据库session

 数据库用于做持久化，缓存用于提高效率

 a. 配置 settings.py

     SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎

 b. 使用

     同上

5、加密cookie session

 a. 配置 settings.py

     SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎

 b. 使用

     同上

8、CSRF

讲到这里大家基本都应该遇到了不少的这样的问题，并且百度到答案了。

大概浅浅的说一下是什么吧，因为跟百度上的csrf blog比起来，这一篇真的差远了。

前面已经说过了cookies跟session的作用，认证信息和用户私密信息都是通过session保存的，服务器会给客户端返回一串随机字符串，在服务器上，这一串随机字符串就是对应的用户信息字典。假如这是购物网站，或者银行等等，其他的恶意网页获取了找个随意字符串，通过验证，就可以随意的获取用户的session里面的私密信息。这显然是不可以的。

django里面提供的csrf的原理就是在返回给客户单数据的时候再产生一个私密的加盐字符串（只有django自身可以识别的算法字符串）。

CSRF攻击的主要目的是让用户在不知情的情况下攻击自己已登录的一个系统，类似于钓鱼。如用户当前已经登录了邮箱，或bbs，同时用户又在使用另外一个，已经被你控制的站点，我们姑且叫它钓鱼网站。这个网站上面可能因为某个图片吸引你，你去点击一下，此时可能就会触发一个js的点击事件，构造一个bbs发帖的请求，去往你的bbs发帖，由于当前你的浏览器状态已经是登陆状态，所以session登陆cookie信息都会跟正常的请求一样，纯天然的利用当前的登陆状态，让用户在不知情的情况下，帮你发帖或干其他事情。

Django里面的csrf防御机制：

一、简介

django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。

全局：

中间件 django.middleware.csrf.CsrfViewMiddleware

局部：

@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
@csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。
注：from django.views.decorators.csrf import csrf_exempt,csrf_protect

应用

form提交

 1、普通表单
 veiw中设置返回值：
 　　return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))　　
      或者
      return render(request, 'xxx.html', data)

 html中设置Token:
 　　{% csrf_token %}
 # 上面这个比较常用，反正楼主是用的这个。因为就一句话啊。。。。。

ajax提交

在ajax的函数里面加上一个header就好了
header:{'X-CSRFtoken',$.cookie('csrftoken')
	
　　　　  $.ajax({
		url:'/login/',
		type:'POST',
		data:{'user':'root','pwd':'123'},
		headers:{'X-CSRFtoken':...},
		success:function(){
		}
	})

但是当我们遇到有很多的ajax提交的时候是不是每一个都需要这样加呢？之前我们有说过一个dispatch。当然这边跟dispatch无关。只是利用同样的理念在某个地方是不是有一个位置可以写这些呢？

全局配置

$.ajaxSetup({
		beforeSend:function(xhr,settings){		# xml http request对象
		xhr.setRequestHeader('X-CSRFtoken',$.cookie('csrftoken'))
		}
	});

            $.ajaxSetup({
                data: {csrfmiddlewaretoken: '{{ csrf_token }}' }
            });

同样的并不是所有的ajax都需要这样设置的。如django官方推荐的：

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
    {% csrf_token %}
    <input type="button" onclick="Do();"  value="Do it"/>

    <script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
    <script src="/static/plugin/jquery/jquery.cookie.js"></script>
    <script type="text/javascript">
        var csrftoken = $.cookie('csrftoken');
        function csrfSafeMethod(method) {
            // these HTTP methods do not require CSRF protection
            return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));  # 这四种都不需要进行csrf认证
        }
        $.ajaxSetup({
            beforeSend: function(xhr, settings) {
                if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
        function Do(){
            $.ajax({  # ajax函数不变
                url:"/app01/test/",
                data:{id:1},
                type:'POST',
                success:function(data){
                    console.log(data);
                }
            });
        }
    </script>
</body>
</html>

Django Model操作

字段

 AutoField(Field)
         - int自增列，必须填入参数 primary_key=True

     BigAutoField(AutoField)
         - bigint自增列，必须填入参数 primary_key=True

         注：当model中如果没有自增列，则自动会创建一个列名为id的列
         from django.db import models

         class UserInfo(models.Model):
             # 自动创建一个列名为id的且为自增的整数列
             username = models.CharField(max_length=32)

         class Group(models.Model):
             # 自定义自增列
             nid = models.AutoField(primary_key=True)
             name = models.CharField(max_length=32)

     SmallIntegerField(IntegerField):
         - 小整数 -32768 ～ 32767

     PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
         - 正小整数 0 ～ 32767
     IntegerField(Field)
         - 整数列(有符号的) -2147483648 ～ 2147483647

     PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
         - 正整数 0 ～ 2147483647

     BigIntegerField(IntegerField):
         - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807

     BooleanField(Field)
         - 布尔值类型

     NullBooleanField(Field):
         - 可以为空的布尔值

     CharField(Field)
         - 字符类型
         - 必须提供max_length参数， max_length表示字符长度

     TextField(Field)
         - 文本类型

     EmailField(CharField)：
         - 字符串类型，Django Admin以及ModelForm中提供验证机制

     IPAddressField(Field)
         - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制

     GenericIPAddressField(Field)
         - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
         - 参数：
             protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
             unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both"

     URLField(CharField)
         - 字符串类型，Django Admin以及ModelForm中提供验证 URL

     SlugField(CharField)
         - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）

     CommaSeparatedIntegerField(CharField)
         - 字符串类型，格式必须为逗号分割的数字

     UUIDField(Field)
         - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证

     FilePathField(Field)
         - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
         - 参数：
                 path,                      文件夹路径
                 match=None,                正则匹配
                 recursive=False,           递归下面的文件夹
                 allow_files=True,          允许文件
                 allow_folders=False,       允许文件夹

     FileField(Field)
         - 字符串，路径保存在数据库，文件上传到指定目录
         - 参数：
             upload_to = ""      上传文件的保存路径
             storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

     ImageField(FileField)
         - 字符串，路径保存在数据库，文件上传到指定目录
         - 参数：
             upload_to = ""      上传文件的保存路径
             storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
             width_field=None,   上传图片的高度保存的数据库字段名（字符串）
             height_field=None   上传图片的宽度保存的数据库字段名（字符串）

     DateTimeField(DateField)
         - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

     DateField(DateTimeCheckMixin, Field)
         - 日期格式      YYYY-MM-DD

     TimeField(DateTimeCheckMixin, Field)
         - 时间格式      HH:MM[:ss[.uuuuuu]]

     DurationField(Field)
         - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

     FloatField(Field)
         - 浮点型

     DecimalField(Field)
         - 10进制小数
         - 参数：
             max_digits，小数总长度
             decimal_places，小数位长度

     BinaryField(Field)
         - 二进制类型

 字段列表

字段类型

 class UnsignedIntegerField(models.IntegerField):
     def db_type(self, connection):
         return 'integer UNSIGNED'

 PS: 返回值为字段在数据库中的属性，Django字段默认的值为：
     'AutoField': 'integer AUTO_INCREMENT',
     'BigAutoField': 'bigint AUTO_INCREMENT',
     'BinaryField': 'longblob',
     'BooleanField': 'bool',
     'CharField': 'varchar(%(max_length)s)',
     'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
     'DateField': 'date',
     'DateTimeField': 'datetime',
     'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
     'DurationField': 'bigint',
     'FileField': 'varchar(%(max_length)s)',
     'FilePathField': 'varchar(%(max_length)s)',
     'FloatField': 'double precision',
     'IntegerField': 'integer',
     'BigIntegerField': 'bigint',
     'IPAddressField': 'char(15)',
     'GenericIPAddressField': 'char(39)',
     'NullBooleanField': 'bool',
     'OneToOneField': 'integer',
     'PositiveIntegerField': 'integer UNSIGNED',
     'PositiveSmallIntegerField': 'smallint UNSIGNED',
     'SlugField': 'varchar(%(max_length)s)',
     'SmallIntegerField': 'smallint',
     'TextField': 'longtext',
     'TimeField': 'time',
     'UUIDField': 'char(32)',

 自定义无符号整数字段

自定义无符号整数字段

 1.触发Model中的验证和错误提示有两种方式：
         a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息
         b. 使用ModelForm
         c. 调用Model对象的 clean_fields 方法，如：
             # models.py
             class UserInfo(models.Model):
                 nid = models.AutoField(primary_key=True)
                 username = models.CharField(max_length=32)

                 email = models.EmailField(error_messages={'invalid': '格式错了.'})

             # views.py
             def index(request):
                 obj = models.UserInfo(username='', email='uu')
                 try:
                     print(obj.clean_fields())
                 except Exception as e:
                     print(e)
                 return HttpResponse('ok')

            # Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。

     2.Admin中修改错误提示
         # admin.py
         from django.contrib import admin
         from model_club import models
         from django import forms

         class UserInfoForm(forms.ModelForm):
             age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'})

             class Meta:
                 model = models.UserInfo
                 # fields = ('username',)
                 fields = "__all__"
                 exclude = ['title']
                 labels = { 'name':'Writer', }
                 help_texts = {'name':'some useful help text.',}
                 error_messages={ 'name':{'max_length':"this writer name is too long"} }
                 widgets={'name':Textarea(attrs={'cols':80,'rows':20})}

         class UserInfoAdmin(admin.ModelAdmin):
             form = UserInfoForm

         admin.site.register(models.UserInfo, UserInfoAdmin)

 注意事项

注意事项

字段参数

 null                数据库中字段是否可以为空
     db_column           数据库中字段的列名
     default             数据库中字段的默认值
     primary_key         数据库中字段是否为主键
     db_index            数据库中字段是否可以建立索引
     unique              数据库中字段是否可以建立唯一索引
     unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
     unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
     unique_for_year     数据库中字段【年】部分是否可以建立唯一索引

     verbose_name        Admin中显示的字段名称
     blank               Admin中是否允许用户输入为空
     editable            Admin中是否可以编辑
     help_text           Admin中该字段的提示信息
     choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
                         如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)

     error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；
                         字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
                         如：{'null': "不能为空.", 'invalid': '格式错误'}

     validators          自定义错误验证（列表类型），从而定制想要的验证规则
                         from django.core.validators import RegexValidator
                         from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
                         MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                         如：
                             test = models.CharField(
                                 max_length=32,
                                 error_messages={
                                     'c1': '优先错信息1',
                                     'c2': '优先错信息2',
                                     'c3': '优先错信息3',
                                 },
                                 validators=[
                                     RegexValidator(regex='root_\d+', message='错误了', code='c1'),
                                     RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
                                     EmailValidator(message='又错误了', code='c3'), ]
                             )

元信息

 class UserInfo(models.Model):
         nid = models.AutoField(primary_key=True)
         username = models.CharField(max_length=32)
         class Meta:
             # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
             db_table = "table_name"

             # 联合索引
             index_together = [
                 ("pub_date", "deadline"),
             ]
             # 索引的最左前缀模式：
         # select * from where name =..                    可以命中索引
         # select * from where name = .. and email=...    可以命中索引
         # select * from where email=..                    无法命中索引
             # 联合唯一索引
             unique_together = (("driver", "restaurant"),)

             # admin中显示的表名称
             verbose_name

             # verbose_name加s
             verbose_name_plural
 verbose_name = "上课记录"    ==>    admin会加s
         verbose_name_plural = "上课记录"    ==> 正常的

基本操作、外键、跨表

a.创建类和字段
		class User(models.Model):
			id = models.IntegerField()
			name = models.CharField(max_length=12)

		python manage.py makemigrations
		python manage.py migrate

		# settings.py 	注册APP

b.操作
	增	=>models.User.objects.create(id=2,name="dandy") ==>id 不是主键，不自增，不是key
		=> dic = {'name':'xx', "age":22}
		models.User.objects.create(**dic)

		obj = models.User("name":"xx", "age":22)
		obj.save()

	删	models.User.objects.filter(name='xx').delete()
	改
		models.User.objects.filter(id__gt=1).update(name='asd')
		dic = {"name":"xx", "age",22}
		models.User.objects.filter(id__gt=1).update(**dic)
	查
		models.User.objects.filter(id__gte=1)  >=
		models.User.objects.filter(id__lte=1, name='xxo')
		dic = {"name":"dandy","age__gt":22}
		models.User.objects.filter(**dic)	字典

	外键
		class UserType(models.Model):
			caption = models.CharField(max_length=22)

		class User(models.Model):
			name = models.CharField(max_length=23)
			age = models.IntegerField()
			# user_type_id = models.IntegerField()
			user_type = models.ForeignKey("UserType", to_field="id")

			choices_detail = (
				(u'M', u'Male'),
				(u'F', u'Female'),
			)
			model = models.CharField(max_length=2, choices=choices_detail)

	查询：models.User.objects.all()
		　 ==>queryset ==>[obj(id, name, age),obj(id, name, age)]   -->对象
		  models.User.objects.all().values("id","name")
	　　　　 　　==>queryset ==>[{"id":1, "name": "dandy"},{}]			 -->字典
		  models.User.objects.all().values_list("id","name")
		   ==>queryset ==>[(1,"dandy"),()]					 -->列表
		  models.Users.objects.all().values_list("name", flat=True)　　　　-->列表，限制只能取一个字段的时候
　　　　　　　　　　  ==>queryset ==>['wuzdandz', 'wuzfflen']

		  models.User.objects.get(id=1)  # 获取到一个对象，如果id不存在就报错
		  models.User.objects.filter(id=1)  # 没有拿到就是空列表
		  models.User.objects.filter(id=1).first()  # 没有拿到就是None

		# 用.进行跨表
		  v = models.User.objects.filter(id__gt=0)
		  v[0].b.caption	-->	通过.进行跨表  ==> [obj(id, name,另一个对象(....))]
		# 用__双下划线进行跨表
		  v = models.User.objects.filter(id__gt=0).values('id,name,user_type__caption')
		# 获取到的列表内部，是一个个元组，用index取值
		  v = models.User.objects.filter(id__gt=0).values_list('id,name,user_type__caption')
		  {%for row in v%}
		  row.0 - row.1
		  {%endfor%}

		{{forloop.counter}}	--> 模板语言里给表的每行加一个序号，自增，相当于数据库ID
		{{forloop.counter0}}	-->从0开始
		{{forloop.revcounter}}	-->倒序
		{{forloop.revcounter0}}	-->倒序排到0
		{{forloop.last}}		-->是否是最后一个循环
		{{forloop.first}}		-->是否是第一个循环
		{{forloop.parentloop}}	-->父循环的序列号（外层还有个循环，嵌套的在里面的用这一句，第一次输出全是1，第二次2）

多对多操作

创建多对多
		方式一：自定义创建表
		自己创建表1、表2，然后创建表1_to_表2

		方式二：Django自动生成（Django自动创建关系表）
		创建表1，创建表2并在二中加一列
			- r = models.ManyToManyField('表1')
		自动创建的表，无法对表直接做操作
                只有3个列，自增id，2张表的自增id

		绑定
		obj = 表1.objects.get(id=1)
		obj.r.add(1)==>表1的id1跟表2的id1绑定 

		也可以批量传入列表,下面2种都支持
		obj.r.add(1,2,3)
		obj.r.add([1,2,3])
		删除
		obj.r.remove(1)
		obj.r.remove(2,4)
		obj.r.remove(*[1,2,3])

		obj.r.clear()  # 清空表1 id=1的在表3里面的所有关系
		obj.set([3,5,6]) ==> 表3的数据库里面只会保留1 3；1 5；1 6这三个；
　　　　　　　　　　　　　　　　　　　　　　 清空其他所有的

		obj.r.all()		==>表1 id=1的所有的组合对象列表 queryset    

多表关系

 ForeignKey(ForeignObject) # ForeignObject(RelatedField)
         to,                         # 要进行关联的表名
         to_field=None,              # 要关联的表中的字段名称
         on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为
                                         - models.CASCADE，删除关联数据，与之关联也删除
                                         - models.DO_NOTHING，删除关联数据，引发错误IntegrityError
                                         - models.PROTECT，删除关联数据，引发错误ProtectedError
                                         - models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
                                         - models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
                                         - models.SET，删除关联数据，
                                                       a. 与之关联的值设置为指定值，设置：models.SET(值)
                                                       b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

                                                         def func():
                                                             return 10

                                                         class MyModel(models.Model):
                                                             user = models.ForeignKey(
                                                                 to="User",
                                                                 to_field="id"
                                                                 on_delete=models.SET(func),)
         related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
         related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
         limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
                                     # 如：
                                             - limit_choices_to={'nid__gt': 5}
                                             - limit_choices_to=lambda : {'nid__gt': 5}

                                             from django.db.models import Q
                                             - limit_choices_to=Q(nid__gt=10)
                                             - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                             - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
         db_constraint=True          # 是否在数据库中创建外键约束
         parent_link=False           # 在Admin中是否显示关联数据

     OneToOneField(ForeignKey)
         to,                         # 要进行关联的表名
         to_field=None               # 要关联的表中的字段名称
         on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为

                                     ###### 对于一对一 ######
                                     # 1. 一对一其实就是 一对多 + 唯一索引
                                     # 2.当两个类之间有继承关系时，默认会创建一个一对一字段
                                     # 如下会在A表中额外增加一个c_ptr_id列且唯一：
                                             class C(models.Model):
                                                 nid = models.AutoField(primary_key=True)
                                                 part = models.CharField(max_length=12)

                                             class A(C):
                                                 id = models.AutoField(primary_key=True)
                                                 code = models.CharField(max_length=1)

     ManyToManyField(RelatedField)
         to,                         # 要进行关联的表名
         related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
         related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
         limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
                                     # 如：
                                             - limit_choices_to={'nid__gt': 5}
                                             - limit_choices_to=lambda : {'nid__gt': 5}

                                             from django.db.models import Q
                                             - limit_choices_to=Q(nid__gt=10)
                                             - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                             - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
         symmetrical=None,           # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段
                                     # 做如下操作时，不同的symmetrical会有不同的可选字段
                                         models.BB.objects.filter(...)

                                         # 可选字段有：code, id, m1
                                             class BB(models.Model):

                                             code = models.CharField(max_length=12)
                                             m1 = models.ManyToManyField('self',symmetrical=True)

                                         # 可选字段有: bb, code, id, m1
                                             class BB(models.Model):

                                             code = models.CharField(max_length=12)
                                             m1 = models.ManyToManyField('self',symmetrical=False)

         through=None,               # 自定义第三张表时，使用字段用于指定关系表
         through_fields=None,        # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表
                                         from django.db import models

                                         class Person(models.Model):
                                             name = models.CharField(max_length=50)

                                         class Group(models.Model):
                                             name = models.CharField(max_length=128)
                                             members = models.ManyToManyField(
                                                 Person,
                                                 through='Membership',
                                                 through_fields=('group', 'person'),
                                             )

                                         class Membership(models.Model):
                                             group = models.ForeignKey(Group, on_delete=models.CASCADE)
                                             person = models.ForeignKey(Person, on_delete=models.CASCADE)
                                             inviter = models.ForeignKey(
                                                 Person,
                                                 on_delete=models.CASCADE,
                                                 related_name="membership_invites",
                                             )
                                             invite_reason = models.CharField(max_length=64)
         db_constraint=True,         # 是否在数据库中创建外键约束
         db_table=None,              # 默认创建第三张表时，数据库中表的名称

操作

 # 获取个数
         #
         # models.Tb1.objects.filter(name='seven').count()

         # 大于，小于
         #
         # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
         # models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值
         # models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
         # models.Tb1.objects.filter(id__lte=10)             # 获取id小于10的值
         # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值

         # in
         #
         # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
         # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in

         # isnull
         # Entry.objects.filter(pub_date__isnull=True)

         # contains
         #
         # models.Tb1.objects.filter(name__contains="ven")
         # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
         # models.Tb1.objects.exclude(name__icontains="ven")

         # range
         #
         # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and

         # 其他类似
         #
         # startswith，istartswith, endswith, iendswith,

         # order by
         #
         # models.Tb1.objects.filter(name='seven').order_by('id')    # asc
         # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc

         # group by
         #
         # from django.db.models import Count, Min, Max, Sum
         # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
         # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

         # limit 、offset
         #
         # models.Tb1.objects.all()[10:20]

         # regex正则匹配，iregex 不区分大小写
         #
         # Entry.objects.get(title__regex=r'^(An?|The) +')
         # Entry.objects.get(title__iregex=r'^(an?|the) +')

         # date
         #
         # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
         # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))

         # year
         #
         # Entry.objects.filter(pub_date__year=2005)
         # Entry.objects.filter(pub_date__year__gte=2005)

         # month
         #
         # Entry.objects.filter(pub_date__month=12)
         # Entry.objects.filter(pub_date__month__gte=6)

         # day
         #
         # Entry.objects.filter(pub_date__day=3)
         # Entry.objects.filter(pub_date__day__gte=3)

         # week_day
         #
         # Entry.objects.filter(pub_date__week_day=2)
         # Entry.objects.filter(pub_date__week_day__gte=2)

         # hour
         #
         # Event.objects.filter(timestamp__hour=23)
         # Event.objects.filter(time__hour=5)
         # Event.objects.filter(timestamp__hour__gte=12)

         # minute
         #
         # Event.objects.filter(timestamp__minute=29)
         # Event.objects.filter(time__minute=46)
         # Event.objects.filter(timestamp__minute__gte=29)

         # second
         #
         # Event.objects.filter(timestamp__second=31)
         # Event.objects.filter(time__second=2)
         # Event.objects.filter(timestamp__second__gte=31)

 进阶操作

进阶操作

 # extra
         #
         # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
         #    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
         #    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
         #    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
         #    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

         # F
         #
         # from django.db.models import F
         # models.Tb1.objects.update(num=F('num')+1)

         # Q
         #
         # 方式一：
         # Q(nid__gt=10)
         # Q(nid=8) | Q(nid__gt=10)
         # Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')

         # 方式二：
         # con = Q()
         # q1 = Q()
         # q1.connector = 'OR'
         # q1.children.append(('id', 1))
         # q1.children.append(('id', 10))
         # q1.children.append(('id', 9))
         # q2 = Q()
         # q2.connector = 'OR'
         # q2.children.append(('c1', 1))
         # q2.children.append(('c1', 10))
         # q2.children.append(('c1', 9))
         # con.add(q1, 'AND')
         # con.add(q2, 'AND')
         #
         # models.Tb1.objects.filter(con)

         # 执行原生SQL
         #
         # from django.db import connection, connections
         # cursor = connection.cursor()  # cursor = connections['default'].cursor()
         # cursor.execute("""SELECT * from auth_user where id = %s""", [1])
         # row = cursor.fetchone()

进阶操作

其他操作

 ##################################################################
 # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
 ##################################################################

 def all(self)
     # 获取所有的数据对象

 def filter(self, *args, **kwargs)
     # 条件查询
     # 条件可以是：参数，字典，Q

 def exclude(self, *args, **kwargs)
     # 条件查询
     # 条件可以是：参数，字典，Q

 def select_related(self, *fields)
      性能相关：表之间进行join连表操作，一次性获取关联的数据。
      model.tb.objects.all().select_related()
      model.tb.objects.all().select_related('外键字段')
      model.tb.objects.all().select_related('外键字段__外键字段')

 def prefetch_related(self, *lookups)
     性能相关：多表连表操作时速度会慢，使用其执行多次SQL查询在Python代码中实现连表操作。
             # 获取所有用户表
             # 获取用户类型表where id in (用户表中的查到的所有用户ID)
             models.UserInfo.objects.prefetch_related('外键字段')

             from django.db.models import Count, Case, When, IntegerField
             Article.objects.annotate(
                 numviews=Count(Case(
                     When(readership__what_time__lt=treshold, then=1),
                     output_field=CharField(),
                 ))
             )

             students = Student.objects.all().annotate(num_excused_absences=models.Sum(
                 models.Case(
                     models.When(absence__type='Excused', then=1),
                 default=0,
                 output_field=models.IntegerField()
             )))

 def annotate(self, *args, **kwargs)
     # 用于实现聚合group by查询

     from django.db.models import Count, Avg, Max, Min, Sum

     v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id'))
     # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id

     v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1)
     # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

     v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1)
     # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

 def distinct(self, *field_names)
     # 用于distinct去重
     models.UserInfo.objects.values('nid').distinct()
     # select distinct nid from userinfo

     注：只有在PostgreSQL中才能使用distinct进行去重

 def order_by(self, *field_names)
     # 用于排序
     models.UserInfo.objects.all().order_by('-id','age')

 def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
     # 构造额外的查询条件或者映射，如：子查询

     Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
     Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
     Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
     Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])

  def reverse(self):
     # 倒序
     models.UserInfo.objects.all().order_by('-nid').reverse()
     # 注：如果存在order_by，reverse则是倒序，如果多个排序则一一倒序

  def defer(self, *fields):
     models.UserInfo.objects.defer('username','id')
     或
     models.UserInfo.objects.filter(...).defer('username','id')
     #映射中排除某列数据

  def only(self, *fields):
     #仅取某个表中的数据
      models.UserInfo.objects.only('username','id')
      或
      models.UserInfo.objects.filter(...).only('username','id')

  def using(self, alias):
      指定使用的数据库，参数为别名（setting中的设置）

 ##################################################
 # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #
 ##################################################

 def raw(self, raw_query, params=None, translations=None, using=None):
     # 执行原生SQL
     models.UserInfo.objects.raw('select * from userinfo')

     # 如果SQL是其他表时，必须将名字设置为当前UserInfo对象的主键列名
     models.UserInfo.objects.raw('select id as nid from 其他表')

     # 为原生SQL设置参数
     models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,])

     # 将获取的到列名转换为指定列名
     name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}
     Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)

     # 指定数据库
     models.UserInfo.objects.raw('select * from userinfo', using="default")

     ################### 原生SQL ###################
     from django.db import connection, connections
     cursor = connection.cursor()  # cursor = connections['default'].cursor()
     cursor.execute("""SELECT * from auth_user where id = %s""", [1])
     row = cursor.fetchone() # fetchall()/fetchmany(..)

 def values(self, *fields):
     # 获取每行数据为字典格式

 def values_list(self, *fields, **kwargs):
     # 获取每行数据为元祖

 def dates(self, field_name, kind, order='ASC'):
     # 根据时间进行某一部分进行去重查找并截取指定内容
     # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
     # order只能是："ASC"  "DESC"
     # 并获取转换后的时间
         - year : 年-01-01
         - month: 年-月-01
         - day  : 年-月-日

     models.DatePlus.objects.dates('ctime','day','DESC')

 def datetimes(self, field_name, kind, order='ASC', tzinfo=None):
     # 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
     # kind只能是 "year", "month", "day", "hour", "minute", "second"
     # order只能是："ASC"  "DESC"
     # tzinfo时区对象
     models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC)
     models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai'))

     """
     pip3 install pytz
     import pytz
     pytz.all_timezones
     pytz.timezone(‘Asia/Shanghai’)
     """

 def none(self):
     # 空QuerySet对象

 ####################################
 # METHODS THAT DO DATABASE QUERIES #
 ####################################

 def aggregate(self, *args, **kwargs):
    # 聚合函数，获取字典类型聚合结果
    from django.db.models import Count, Avg, Max, Min, Sum
    result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid'))
    ===> {'k': 3, 'n': 4}

 def count(self):
    # 获取个数

 def get(self, *args, **kwargs):
    # 获取单个对象

 def create(self, **kwargs):
    # 创建对象

 def bulk_create(self, objs, batch_size=None):
     # 批量插入
     # batch_size表示一次插入的个数
     objs = [
         models.DDD(name='r11'),
         models.DDD(name='r22')
     ]
     models.DDD.objects.bulk_create(objs, 10)

 def get_or_create(self, defaults=None, **kwargs):
     # 如果存在，则获取，否则，创建
     # defaults 指定创建时，其他字段的值
     obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '','u_id': 2, 't_id': 2})

 def update_or_create(self, defaults=None, **kwargs):
     # 如果存在，则更新，否则，创建
     # defaults 指定创建时或更新时的其他字段
     obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '','u_id': 2, 't_id': 1})

 def first(self):
    # 获取第一个

 def last(self):
    # 获取最后一个

 def in_bulk(self, id_list=None):
    # 根据主键ID进行查找
    id_list = [11,21,31]
    models.DDD.objects.in_bulk(id_list)

 def delete(self):
    # 删除

 def update(self, **kwargs):
     # 更新

 def exists(self):
    # 是否有结果

 其他操作

Django原生SQL获取cursor字典

 import pymysql
     from django.db import connection, connections

     connection.connect()
     conn = connection.connection
     cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
     cursor.execute("""SELECT * from app01_userinfo""")
     row = cursor.fetchone()
     connection.close()

 Django原生SQL获取cursor字典

数字自增，字符串更新

 # 数字自增
     from django.db.models import F
     models.UserInfo.objects.update(num=F('num') + 1)

     # 字符串更新
     from django.db.models.functions import Concat
     from django.db.models import Value

     models.UserInfo.objects.update(name=Concat('name', 'pwd'))
     models.UserInfo.objects.update(name=Concat('name', Value('')))

 数字自增、字符串更新

ORM函数相关

 # ########### 基础函数 ###########

     # 1. Concat，用于做类型转换
     # v = models.UserInfo.objects.annotate(c=Cast('pwd', FloatField()))

     # 2. Coalesce，从前向后，查询第一个不为空的值
     # v = models.UserInfo.objects.annotate(c=Coalesce('name', 'pwd'))
     # v = models.UserInfo.objects.annotate(c=Coalesce(Value('666'),'name', 'pwd'))

     # 3. Concat，拼接
     # models.UserInfo.objects.update(name=Concat('name', 'pwd'))
     # models.UserInfo.objects.update(name=Concat('name', Value('666')))
     # models.UserInfo.objects.update(name=Concat('name', Value('666'),Value('999')))

     # 4.ConcatPair，拼接（仅两个参数）
     # v = models.UserInfo.objects.annotate(c=ConcatPair('name', 'pwd'))
     # v = models.UserInfo.objects.annotate(c=ConcatPair('name', Value('666')))

     # 5.Greatest，获取比较大的值;least 获取比较小的值;
     # v = models.UserInfo.objects.annotate(c=Greatest('id', 'pwd',output_field=FloatField()))

     # 6.Length，获取长度
     # v = models.UserInfo.objects.annotate(c=Length('name'))

     # 7. Lower,Upper,变大小写
     # v = models.UserInfo.objects.annotate(c=Lower('name'))
     # v = models.UserInfo.objects.annotate(c=Upper('name'))

     # 8. Now，获取当前时间
     # v = models.UserInfo.objects.annotate(c=Now())

     # 9. substr，子序列
     # v = models.UserInfo.objects.annotate(c=Substr('name',1,2))

     # ########### 时间类函数 ###########
     # 1. 时间截取，不保留其他：Extract, ExtractDay, ExtractHour, ExtractMinute, ExtractMonth,ExtractSecond, ExtractWeekDay, ExtractYear,
     # v = models.UserInfo.objects.annotate(c=functions.ExtractYear('ctime'))
     # v = models.UserInfo.objects.annotate(c=functions.ExtractMonth('ctime'))
     # v = models.UserInfo.objects.annotate(c=functions.ExtractDay('ctime'))
     #
     # v = models.UserInfo.objects.annotate(c=functions.Extract('ctime', 'year'))
     # v = models.UserInfo.objects.annotate(c=functions.Extract('ctime', 'month'))
     # v = models.UserInfo.objects.annotate(c=functions.Extract('ctime', 'year_month'))
     """
     MICROSECOND
     SECOND
     MINUTE
     HOUR
     DAY
     WEEK
     MONTH
     QUARTER
     YEAR
     SECOND_MICROSECOND
     MINUTE_MICROSECOND
     MINUTE_SECOND
     HOUR_MICROSECOND
     HOUR_SECOND
     HOUR_MINUTE
     DAY_MICROSECOND
     DAY_SECOND
     DAY_MINUTE
     DAY_HOUR
     YEAR_MONTH
     """

     # 2. 时间截图，保留其他：Trunc, TruncDate, TruncDay,TruncHour, TruncMinute, TruncMonth, TruncSecond, TruncYear
     # v = models.UserInfo.objects.annotate(c=functions.TruncHour('ctime'))
     # v = models.UserInfo.objects.annotate(c=functions.TruncDate('ctime'))
     # v = models.UserInfo.objects.annotate(c=functions.Trunc('ctime','year'))

ORM自定义函数

 from django.db.models.functions.base import Func
     class CustomeFunc(Func):
         function = 'DATE_FORMAT'
         template = '%(function)s(%(expressions)s,%(format)s)'

         def __init__(self, expression, **extra):
             expressions = [expression]
             super(CustomeFunc, self).__init__(*expressions, **extra)

     v = models.UserInfo.objects.annotate(c=CustomeFunc('ctime',format="'%%Y-%%m'"))

model的数据验证(弱)

 class UserInfo(models.Model):
     name = models.CharField(max_length=32)
     mail = models.EmailField()

     def clean(self):
         from django.core.exceptions import ValidationError
         c = UserInfo.objects.filter(name=self.name).count()
         if c:
             raise ValidationError(message='用户名已经存在', code='code1')

models.py

 obj = models.UserInfo(name='dandy', email='dandy')
 obj.full_clean()  # 数据验证
 obj.save()

执行的时候是先models的字段的正则表达式验证，然后是models的钩子方法验证(clean)，验证都通过了就执行数据的创建。但是对于这边有一点我们可以发现，我们只是做了关于一个字段的验证，如果多个的话不免有些繁琐，数据验证相对来说确实很弱。

Django中间件

https://www.cnblogs.com/wuzdandz/p/9577840.html

Django的缓存

由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。

Django中提供了6种缓存方式：

• 开发调试
• 内存
• 文件
• 数据库
• Memcache缓存（python-memcached模块）
• Memcache缓存（pylibmc模块）

配置

a、开发测试

 # 此为开始调试用，实际内部不做任何操作
     # 配置：
         CACHES = {
             'default': {
                 'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
                 'TIMEOUT': 300,                                               # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
                 'OPTIONS':{
                     'MAX_ENTRIES': 300,                                       # 最大缓存个数（默认300）
                     'CULL_FREQUENCY': 3,                                      # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
                 },
                 'KEY_PREFIX': '',                                             # 缓存key的前缀（默认空）
                 'VERSION': 1,                                                 # 缓存key的版本（默认1）
                 'KEY_FUNCTION' 函数名                                          # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
             }
         }

     # 自定义key
     def default_key_func(key, key_prefix, version):
         """
         Default function to generate keys.

         Constructs the key used by all other methods. By default it prepends
         the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
         function with custom key making behavior.
         """
         return '%s:%s:%s' % (key_prefix, version, key)

     def get_key_func(key_func):
         """
         Function to decide which key function to use.

         Defaults to ``default_key_func``.
         """
         if key_func is not None:
             if callable(key_func):
                 return key_func
             else:
                 return import_string(key_func)
         return default_key_func

b、内存

 # 此缓存将内容保存至内存的变量中
     # 配置：
         CACHES = {
             'default': {
                 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                 'LOCATION': 'unique-snowflake',
             }
         }

     # 注：其他配置同开发调试版本

c、文件

 # 此缓存将内容保存至文件
     # 配置：

         CACHES = {
             'default': {
                 'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                 'LOCATION': '/var/tmp/django_cache',
             }
         }
     # 注：其他配置同开发调试版本

d、数据库

 # 此缓存将内容保存至数据库

     # 配置：
         CACHES = {
             'default': {
                 'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                 'LOCATION': 'my_cache_table', # 数据库表
             }
         }

     # 注：执行创建表命令 python manage.py createcachetable

e、Memcache缓存（python-memcached模块）

 # 此缓存使用python-memcached模块连接memcache

     CACHES = {
         'default': {
             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
             'LOCATION': '127.0.0.1:11211',
         }
     }

     CACHES = {
         'default': {
             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
             'LOCATION': 'unix:/tmp/memcached.sock',
         }
     }   

     CACHES = {
         'default': {
             'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
             'LOCATION': [
                 '172.19.26.240:11211',
                 '172.19.26.242:11211',
             ]
         }
     }

f、Memcache缓存（pylibmc模块）

 # 此缓存使用pylibmc模块连接memcache

     CACHES = {
         'default': {
             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
             'LOCATION': '127.0.0.1:11211',
         }
     }

     CACHES = {
         'default': {
             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
             'LOCATION': '/tmp/memcached.sock',
         }
     }   

     CACHES = {
         'default': {
             'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
             'LOCATION': [
                 '172.19.26.240:11211',
                 '172.19.26.242:11211',
             ]
         }
     }

关于缓存memcache的分配。

请求来的时候会将它的key转换成数字，在看列表中的机器数量，用key转换的数字除以缓存机器数量，余数是几就存在哪台机器上（列表的第几台机器）。

加上权重的话

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': [
                ('172.19.26.240:11211',11)
                ('172.19.26.242:11211',10)
            ]
        }
    }

就是数字除以21，余数是几就存在第几台机器。（240==》11台==》0~10, 242==》10台==》11~20），这个不是django提供的，而是memcache的模块包含的。

应用

针对视图函数

 方式一：
         from django.views.decorators.cache import cache_page

         @cache_page(60 * 15)
         def my_view(request):
             ...

 方式二：
         from django.views.decorators.cache import cache_page

         urlpatterns = [
             url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
         ]

针对局部视图

 a. 引入TemplateTag

         {% load cache %}

 b. 使用缓存

         {% cache 5000 缓存key %}
             缓存内容
         {% endcache %}

全站使用

 使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

     MIDDLEWARE = [
         'django.middleware.cache.UpdateCacheMiddleware',
         # 其他中间件...
         'django.middleware.cache.FetchFromCacheMiddleware',
     ]

     CACHE_MIDDLEWARE_ALIAS = ""
     CACHE_MIDDLEWARE_SECONDS = ""
     CACHE_MIDDLEWARE_KEY_PREFIX = ""

针对于文本缓存的一个实例

新建缓存文件夹

配置路径

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': os.path.join(BASE_DIR, 'cache')
    }
}

写一个路由对应的网页

from django.views.decorators.cache import cache_page
@cache_page(10)
def cache_test(request):
    ctime = time.time()
    print(ctime)
    return render(request, 'cache.html', {"obj": ctime})

这就已经ok了，网页打开的效果就是10秒缓存。

局部视图，修改网页如下，再将刚刚的缓存装饰器注释掉。

 {% load cache %}
 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <title>Title</title>
 </head>
 <body>
     <p>{{ obj }}</p>
     {% cache 10 k1 %}
     <p>{{ obj }}</p>
     {% endcache %}
 </body>
 </html>

 def cache_test(request):
     ctime = time.time()
     print(ctime)
     return render(request, 'cache.html', {"obj": ctime})

这时候就会发现被装饰的标签不会被缓存了，一个标签刷新，另一个不刷新。这是一种更细致的缓存。

全局缓存需要用中间件来做，首先讲解下基本机制

星1的地方缓存很好理解，因为中间件可能要进行一系列认证或者其他操作；星2主要是中间件可能要对数据进行一些其他的全局修饰，所以放在最后。而且从他们的顺序我们也可以发现：为缓存自定义的两个中间件里面一个只有process_request，另一个只有process_response.可以直接把中间件拿出来用from  import然后查看最后倒入的方法的具体内容。

看着这张图我们就可以更好的说明一下缓存周期了。首先绿色的是请求经过中间件认证一系列之后进行缓存记录，然后执行视图函数，再经过中间件的response的装饰处理，最外层缓存记录，然后发给请求发起者。第二次是红色的线，接收到用户请求经过一系列验证等等，走到中间层最后一级，查看是否有缓存，有就去缓存区取数据从response发送给用户。这就是全局缓存的过程。

信号Signal

https://www.cnblogs.com/wuzdandz/p/9592116.html

强大的Form

花里胡哨的写了那么多知识点，很多人看着估计也是云里雾里的。现在这个点，配合实例讲解，大家一定会被form强大的功能惊讶到。

就按照普通的登陆业务需求，来写一个登陆页面，需要创建一个路由，一个网页，一个视图函数。

路由系统添加：

url(r'^fm/', views.fm),

html:

 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <title>Title</title>
 </head>
 <body>
     <form action="/fm/" method="POST">
         {% csrf_token %}
         <p><input type="text" name="user" /></p>
         <p><input type="text" name="pwd" /></p>
         <p><input type="text" name="email" /></p>
         <input type="submit" name="提交" />
     </form>
 </body>
 </html>

登陆界面

视图函数：

 def fm(request):
     if request.method == 'GET':
         return render(request,'form.html')
     elif request.method == 'POST':
         # 这边应该就是所有的验证信息编辑处，账号，密码，邮箱验证包括格式。大概就是账户名格式对不对，密码长短对不对，邮箱格式对不对，最后加个整体验证。

其实写到这里我们已经觉得很烦锁了，就直接导入form验证吧。首先新建一个类继承forms.Form

 class FM(forms.Form):
     user = forms.CharField()
     pwd = forms.CharField()
     email = forms.EmailField()

Form类

更改视图函数

 def fm(request):
     if request.method == 'GET':
         return render(request,'form.html')
     elif request.method == 'POST':
         obj = FM(request.POST)
         auth = obj.is_valid()  # 验证
         if auth:
             print(obj.cleaned_data)
             return redirect('/fm/')
         else:
             print(obj.errors)
             print(obj.errors.as_json())
             return render(request, 'form.html', {'obj': obj})

这里我们首先可以看下效果，auth = obj.is_valid()其实就是验证结果的返回，布尔值True or False.

如果视图函数验证成功，我们可以得到这样的obj.cleaned_data

{'user': 'dandy', 'pwd': 'password.1', 'email': 'fqoweq@fac.com'}

看到这个obj.cleaned_data是不是会回忆起通过字典对model进行操作。

如果验证失败的话，就可以得到下面的错误列表

obj.errors对应的输出
<ul class="errorlist"><li>user<ul class="errorlist"><li>This field is required.</li></ul></li><li>pwd<ul class="errorlist"><li>This field is required.</li></ul></li><li>email<ul class="errorlist"><li>This field is required.</li></ul></li></ul>

obj.errors.as_json()对应的输出结果
{"user": [{"message": "This field is required.", "code": "required"}], "pwd": [{"message": "This field is required.", "code": "required"}], "email": [{"message": "This field is required.", "code": "required"}]}

这时候我们拿到输出结果就可以做模板语言的渲染了。

 <p><input type="text" name="user" />{{ obj.errors.user.0 }}</p>
 <p><input type="text" name="pwd" />{{ obj.errors.pwd.0 }}</p>
 <p><input type="text" name="email" />{{ obj.errors.email.0 }}</p>

这样运行起来，就可以将form的验证发送给前台了。

这里其实才是最简单的验证功能，报错的信息是英文的，很官方，而且，没有自定制的验证，想必这么一说大家也知道了，肯定接下来提到的就是对于继承form的类进行改造了吧。

是的！

 class FM(forms.Form):
     user = forms.CharField(error_messages={'required':'用户名不能为空！'})  # error_messages是错误信息，对应的key对应报错内容，改造之前的报错跟自定制报错就可以完成了。
     pwd = forms.CharField(
         max_length=12,
         min_length=6,
         error_messages={'required':'密码不能为空！', 'min_length': '密码长度不能小于6.', 'max_length': '密码长度不能大于12.'}
     )
     email = forms.EmailField(error_messages={'required':'邮箱不能为空！', 'invalid': '邮箱格式错误'})

Form自定制验证

这是直接运行：

之前的报错就已经被替换了。并且自定制的功能也已经加入了。看到这肯定会很惊讶，因为不需要用if else的判断，所以很方便，很清晰。别着急，框架的魅力还有。。。

写了太多的input标签，可以有简单的方式么？=================================================》 有。

看一下这次的模板渲染。

 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <title>Title</title>
 </head>
 <body>
     <form action="/fm/" method="POST">
         {% csrf_token %}
         <p>{{ obj.user }}{{ obj.errors.user.0 }}</p>
         <p>{{ obj.pwd }}{{ obj.errors.pwd.0 }}</p>
         <p>{{ obj.email }}{{ obj.errors.email.0 }}</p>
         <input type="submit" name="提交" />
     </form>
 </body>
 </html>

同时需要修改下视图函数：

 def fm(request):
     if request.method == 'GET':
         obj = FM()
         return render(request,'form.html', {'obj': obj})

直接运行：

可以发现form帮我们封装了最简单的输入框了，当然啦，名字一定要对，因为都是通用的方法，道理都懂。并且报错其实form里面也已经封装好了，我们的obj.errors的渲染其实也不需要了（不需要是指最简单的验证，form里面提供的字段的验证）。

可以很极端的按F12去掉所有的装饰，还是可以看到我们辛辛苦苦的渲染的obj.errors的报错的。

会不会有人又说，不行，还是烦。。。能不能在简单点。。。能！！！

 <form action="/fm/" method="POST">
     {% csrf_token %}
     {{ obj.as_p }}
     {{ obj.as_ul }}
     <input type="submit" name="提交" />
 </form>

可以用obj.as_p或者ul来实现，还有种不太一样的。

 <form action="/fm/" method="POST">
         <table>{{ obj.as_table }}</table>
         <input type="submit" name="提交" />
 </form>

效果如下：

但是这样的缺点就是不太灵活,可定制新差，道理你应该也能相同，我们更推荐上面的方式。

这时候还有一个问题，方便归方便，那样式呢？form里面也可以实现样式编写。

 class FM(forms.Form):
     user = forms.CharField(
         error_messages={'required':'用户名不能为空！'},
         widget=widgets.Textarea(attrs={'class':'c1'})
     )
     pwd = forms.CharField(
         max_length=12,
         min_length=6,
         error_messages={'required':'密码不能为空！', 'min_length': '密码长度不能小于6.', 'max_length': '密码长度不能大于12.'},
         widget=widgets.PasswordInput
     )
     email = forms.EmailField(error_messages={'required':'邮箱不能为空！', 'invalid': '邮箱格式错误'})

替换标签与定制样式就可以搞定了。

既然说到了form生成标签，就讲全了吧。

生成单选框的两种方式：

     gender =fields.ChoiceField(
         choices=((1, '男'), (2, '女'),),
         initial=2,
         widget=widgets.RadioSelect
     )
     city = fields.CharField(
         initial=2,
         widget=widgets.Select(choices=((1,'上海'), (2, '北京'),))
     )

Form类

创建Form类时，主要涉及到 【字段】 和 【插件】，字段用于对用户请求数据的验证，插件用于自动生成HTML;

Django内置字段

 Field
     required=True,               是否允许为空
     widget=None,                 HTML插件
     label=None,                  用于生成Label标签或显示内容
     initial=None,                初始值
     help_text='',                帮助信息(在标签旁边显示)
     error_messages=None,         错误信息 {'required': '不能为空', 'invalid': '格式错误'}
     show_hidden_initial=False,   是否在当前插件后面再加一个隐藏的且具有默认值的插件（可用于检验两次输入是否一直）
     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类型
     ...

Django内置插件：

 TextInput(Input)
 NumberInput(TextInput)
 EmailInput(TextInput)
 URLInput(TextInput)
 PasswordInput(TextInput)
 HiddenInput(TextInput)
 Textarea(Widget)
 DateInput(DateTimeBaseInput)
 DateTimeInput(DateTimeBaseInput)
 TimeInput(DateTimeBaseInput)
 CheckboxInput
 Select
 NullBooleanSelect
 SelectMultiple
 RadioSelect
 CheckboxSelectMultiple
 FileInput
 ClearableFileInput
 MultipleHiddenInput
 SplitDateTimeWidget
 SplitHiddenDateTimeWidget
 SelectDateWidget

常用选择插件

 # 单radio，值为字符串
 # user = fields.CharField(
 #     initial=2,
 #     widget=widgets.RadioSelect(choices=((1,'上海'),(2,'北京'),))
 # )

 # 单radio，值为字符串
 # user = fields.ChoiceField(
 #     choices=((1, '上海'), (2, '北京'),),
 #     initial=2,
 #     widget=widgets.RadioSelect
 # )

 # 单select，值为字符串
 # user = fields.CharField(
 #     initial=2,
 #     widget=widgets.Select(choices=((1,'上海'),(2,'北京'),))
 # )

 # 单select，值为字符串
 # user = fields.ChoiceField(
 #     choices=((1, '上海'), (2, '北京'),),
 #     initial=2,
 #     widget=widgets.Select
 # )

 # 多选select，值为列表
 # user = fields.MultipleChoiceField(
 #     choices=((1,'上海'),(2,'北京'),),
 #     initial=[1,],
 #     widget=widgets.SelectMultiple
 # )

 # 单checkbox
 # user = fields.CharField(
 #     widget=widgets.CheckboxInput()
 # )

 # 多选checkbox,值为列表
 # user = fields.MultipleChoiceField(
 #     initial=[2, ],
 #     choices=((1, '上海'), (2, '北京'),),
 #     widget=widgets.CheckboxSelectMultiple
 # )

在使用选择标签时，需要注意choices的选项可以从数据库中获取，但是由于是静态字段 ***获取的值无法实时更新***，那么需要自定义构造方法从而达到此目的。

方式一：

 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.ChoiceField(
         # choices=((1, '上海'), (2, '北京'),),
         initial=2,
         widget=widgets.Select
     )

     def __init__(self, *args, **kwargs):
         super(MyForm,self).__init__(*args, **kwargs)
         # self.fields['user'].widget.choices = ((1, '上海'), (2, '北京'),)
         # 或
         self.fields['user'].widget.choices = models.Classes.objects.all().value_list('id','caption')

方式二：

使用django提供的ModelChoiceField和ModelMultipleChoiceField字段来实现

 from django import forms
 from django.forms import fields
 from django.forms import widgets
 from django.forms import models as form_model
 from django.core.exceptions import ValidationError
 from django.core.validators import RegexValidator

 class FInfo(forms.Form):
     authors = form_model.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())
     # authors = form_model.ModelChoiceField(queryset=models.NNewType.objects.all())

自定义验证规则

方式一：

 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'邮箱'}))

方法三：自定义方法

 from django import forms
     from django.forms import fields
     from django.forms import widgets
     from django.core.exceptions import ValidationError
     from django.core.validators import RegexValidator

     class FInfo(forms.Form):
         username = fields.CharField(max_length=5,
                                     validators=[RegexValidator(r'^[0-9]+$', 'Enter a valid extension.', 'invalid')], )
         email = fields.EmailField()

         def clean_username(self):
             """
             Form中字段中定义的格式匹配完之后，执行此方法进行验证
             :return:
             """
             value = self.cleaned_data['username']
             if "" in value:
                 raise ValidationError('666已经被玩烂了...', 'invalid')
             return value

方式四：同时生成多个标签进行验证

 from django.forms import Form
 from django.forms import widgets
 from django.forms import fields

 from django.core.validators import RegexValidator

 ############## 自定义字段 ##############
 class PhoneField(fields.MultiValueField):
     def __init__(self, *args, **kwargs):
         # Define one message for all fields.
         error_messages = {
             'incomplete': 'Enter a country calling code and a phone number.',
         }
         # Or define a different message for each field.
         f = (
             fields.CharField(
                 error_messages={'incomplete': 'Enter a country calling code.'},
                 validators=[
                     RegexValidator(r'^[0-9]+$', 'Enter a valid country calling code.'),
                 ],
             ),
             fields.CharField(
                 error_messages={'incomplete': 'Enter a phone number.'},
                 validators=[RegexValidator(r'^[0-9]+$', 'Enter a valid phone number.')],
             ),
             fields.CharField(
                 validators=[RegexValidator(r'^[0-9]+$', 'Enter a valid extension.')],
                 required=False,
             ),
         )
         super(PhoneField, self).__init__(error_messages=error_messages, fields=f, require_all_fields=False, *args,
                                          **kwargs)

     def compress(self, data_list):
         """
         当用户验证都通过后，该值返回给用户
         :param data_list:
         :return:
         """
         return data_list

 ############## 自定义插件 ##############
 class SplitPhoneWidget(widgets.MultiWidget):
     def __init__(self):
         ws = (
             widgets.TextInput(),
             widgets.TextInput(),
             widgets.TextInput(),
         )
         super(SplitPhoneWidget, self).__init__(ws)

     def decompress(self, value):
         """
         处理初始值，当初始值initial不是列表时，调用该方法
         :param value:
         :return:
         """
         if value:
             return value.split(',')
         return [None, None, None]

初始化数据

在Web应用程序中开发编写功能时，时常用到获取数据库中的数据并将值初始化在HTML中的标签上。

1、Form

 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()

     city = fields.ChoiceField(
         choices=((1, '上海'), (2, '北京'),),
         widget=widgets.Select
     )

2、Views

 from django.shortcuts import render, redirect
 from .forms import MyForm

 def index(request):
     if request.method == "GET":
         values = {'user': 'root', 'city': 2}
         obj = MyForm(values)

         return render(request, 'index.html', {'form': obj})
     elif request.method == "POST":
         return redirect('http://www.google.com')
     else:
         return redirect('http://www.google.com')

3、HTML

 <form method="POST" enctype="multipart/form-data">
     {% csrf_token %}
     <p>{{ form.user }} {{ form.user.errors }}</p>
     <p>{{ form.city }} {{ form.city.errors }}</p>

     <input type="submit"/>
 </form>

select实例

 class FM(forms.Form):
     user = forms.CharField(
         error_messages={'required':'用户名不能为空！'},
         widget=widgets.Textarea(attrs={'class':'c1'})
     )
     pwd = forms.CharField(
         max_length=12,
         min_length=6,
         error_messages={'required':'密码不能为空！', 'min_length': '密码长度不能小于6.', 'max_length': '密码长度不能大于12.'},
         widget=widgets.PasswordInput(render_value=True)
     )
     email = forms.EmailField(error_messages={'required':'邮箱不能为空！', 'invalid': '邮箱格式错误'})
     gender =fields.ChoiceField(
         choices=((1, '男'), (2, '女'),),
         initial=2,
         widget=widgets.RadioSelect
     )
     city = fields.CharField(
         initial=2,
         widget=widgets.Select(choices=((1,'上海'), (2, '北京'),))
     )
     usertype = fields.ChoiceField(
         choices=[],
         widget= widgets.Select
     )
     usertype1 = fields.CharField(
         widget=widgets.Select()
     )
     usertype2 = ModelChoiceField(
         queryset= models.UserType.objects.all()
     )

     def  __init__(self, *args, **kwargs):
         super(FM, self).__init__(*args, **kwargs)
         # self.fields['usertype'].choices = models.UserType.objects.values_list('id','user_type')
         self.fields['usertype1'].widget.choices = models.UserType.objects.values_list('id', 'user_type')

自定制form类

 def fm(request):
     if request.method == 'GET':
         obj = FM()
         obj.fields['usertype'].choices = models.UserType.objects.values_list('id', 'user_type')
         return render(request,'form.html', {'obj': obj})

view.py

 <form action="/fm/" method="POST">
         {% csrf_token %}
         <table>{{ obj.as_table }}</table>
         <input type="submit" name="提交" />
 </form>

html

这里需要详细说明下的是，后面我们定义了三种形式的usertype，通过fields里面的ChoiceField,CharField标签和（from django.forms.models import ModelChoiceField）的ModelChoiceField标签。usertype是通过ChoiceField来做的，所以我们需要配置它的choices选项，并且把标签设置为select；usertype1是通过CharField来实现的，同样需要通过widget配置其select标签，不过选项应该是配置在Select()里面的widget=widgets.Select(choices=[]).当然，到现在为止我们都没有给标签赋值，因为现在赋值是有问题的，首先，我们看一下这个class的结构，就会发现，所有的标签对象都是类变量，在程序启动时就会执行，类的实例化对象不会重新执行。所以这里需要重新赋值给这个类变量标签。

方法一，就是在view视图函数里面，因为实例化完FM类需要传给前台，而控制标签的函数就是obj.fields['对应的标签类变量名'].choices，需要重新去数据库获取数据赋值。

方法二，FM类继承forms.Form类，对其构造函数继承并重构，跟方法一的思想是一样的，因为__init__是类的实例化过程的一部分，所以在这里我们可以直接给标签的choices重新赋值。

以上2中原理上都是一样的，只是一个通过类的继承与重构实现的，一个是在视图函数实现的，当然了，这里当然是推荐大家使用继承与重构的方法，毕竟当需要在很多个网页做这样的效果实现的时候，不需要再所有视图函数就行赋值，直接做到了一步到位。

usertype 和 usertype1的区别则在于，一个是使用ChoiceField另一个是使用CharField实现的。ChoiceField需要将参数配置的其内部，而CharField则需要配置在其内部的widget里面。而最后的usertype2则又是一种完全不同的方法，它是django提供给我们的一个控件，已经实现了对于绑定数据的重写。但是需要在models内部写一个__str__返回一下self.名称才能看到其选项名称。

Form的钩子（强大的验证功能）

前面我们说到了form的生成标签的简单验证，现在我们来具体提及一下form提供给我的验证钩子。

obj = FM(request.POST)
auth = obj.is_valid()

这里其实我们是知道的，is_valid是对于form的类的验证，所以既然提到了钩子验证，那当然是在这个is_valid内部预留的方法位置。根据is_valid往内部翻,会找到not self.errors,然后找到full_clean方法,下面有三个方法

self._clean_fields()
self._clean_form()
self._post_clean() 

这三个函数对应了3种钩子，我们一一下钻看一下。首先是_clean_fields()

 for name, field in self.fields.items():
             if field.disabled:
                 value = self.get_initial_for_field(field, name)
             else:
                 value = field.widget.value_from_datadict(self.data, self.files, self.add_prefix(name))
             try:
                 if isinstance(field, FileField):
                     initial = self.get_initial_for_field(field, name)
                     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 as e:
                 self.add_error(name, e)

从代码可以发现里面有一个映射hasattr(self, 'clean_%s' % name), getattr(self, 'clean_%s' % name)()，看到这应该就懂了，其实这边是最基础的各个标签对应的验证钩子，form会去找，有没有对应的标签钩子，比如定义了一个标签user，对应的user标签的验证就是clean_user。所以需要在继承forms类里面定义这个函数。

     def clean_user(self):
         c = models.User.objects.filter(user=self.cleaned_data['user']).count()
         if c:
             return self.cleaned_data['user']
         else:
             raise ValidationError('用户名不存在111', code='invalid')

可是各个标签单独的验证并不能解决一个很简单的问题，就比如登陆，需要考虑到账户名跟密码的组合，那就不再属于单个标签的钩子了。此时需要提到下面一个钩子，_clean_form()里面有一个clean()方法。这就是预留给组合标签使用的一个方法。同样的

     def clean(self):
         cp = models.User.objects.filter(user=self.cleaned_data.get('user'), pwd=self.cleaned_data['pwd']).count()
         if cp:
             return self.cleaned_data
         else:
             raise ValidationError('用户名或者密码错误！')

这里楼主遇到一个坑，就是在标签跟组合标签验证的时候，就比如上面的用户名，我们可能验证到用户名不存在的问题，django的clean_data的原理就是清理出通过验证的数据，所以这个时候，可以发现，clean_user执行完不通过的时候，就已经没有clean_data['user']这个数据了，所以组合验证的时候就不可以用clean_data['user']来去user标签的值了，这样会直接报错，需要些try catch，明显很麻烦，只需要改成get就会返回None，这时候models的数据库查询不受影响，就可以完美避开这个坑。所以需要理解django forms的执行顺序跟验证数据clean_data的关系。

最后一个钩子是留下来做其他验证的，其实我也不是很清楚作用

     def _post_clean(self):
         pass

概述一下form里面的验证，1、标签的基本验证，（CharField之类的正则表达式验证）；2、标签的自定制功能验证（CharField内部的钩子）；3、标签对应的钩子函数clean_func；4、整体的自定制钩子方法；5、其他的预留钩子_post_clean

errors的结构

         obj.errors
         {
             '__all__': [],
             'user': [{'code':'xxx', 'message':'xxxxx'}],
             'pwd': [{'code':'xxx', 'message': 'xxxxq'}]
         }

其中__all__是指向全局的报错，也可能叫做NON_FIELD_ERRORS（from django.core.exceptions import NON_FIELD_ERRORS）

Form内置错误信息的序列化

上面已经说到了errors的结构了。首先我们打印一下errors的类型，发现是django.forms.utils.ErrorDict，导入一下这个ErrorDict，可以下钻到这个方法内部

其内部封装了如下的方法，as_json指的是转换成json字符串；as_data则是转换成字典。其他的可以自行打印一下看看是什么格式。

假设有这样一个自定制的字典：

{'status':True, 'errors':None, 'data':None}

errors的信息加入

ret = obj.errors.as_json()

这时候序列化,以ajax请求为例子的

return HttpResponse(json.dumps(ret))

此时前台取到数据需要做2部反序列化操作。就。。。不写了。

另外一种是as_data():前面说这个是返回的一个字典，此时对于字典打印一下，发现里面的value是ValidationError('This field is required').

下面稍微深入的补充一下序列化

从json.dumps下钻，找到其参数cls，会发现

再来看看JSONEncoder是什么

这里已经引出来了这个default方法，打开看一下

    def default(self, o):
        """Implement this method in a subclass such that it returns
        a serializable object for ``o``, or calls the base implementation
        (to raise a ``TypeError``).

        For example, to support arbitrary iterators, you could
        implement default like this::

            def default(self, o):
                try:
                    iterable = iter(o)
                except TypeError:
                    pass
                else:
                    return list(iterable)
                # Let the base class default method raise the TypeError
                return JSONEncoder.default(self, o)

        """
        raise TypeError("Object of type '%s' is not JSON serializable" %
                        o.__class__.__name__)

有没有发现，其实这一块也是预留了一个钩子一样的方法给我们自定制，如果不满足，序列化报错。

我们重写这个方法

 class JsonCustomEncoder(json.JSONEncoder):
     def default(self, field):
         if isinstance(field, ValidationError):
             return {'code': field.code, 'messages': field.messages}
         else:
             return json.JSONEncoder.default(self, field)

调用

         ret['errors'] = obj.errors.as_data()
         result = json.dumps(ret, cls=JsonCustomEncoder)
 return HttpResponse(result)

这样前台ajax请求就可以接收到并一次解决。是不是高大上很多，屌丝都看不懂的。

序列化

既然说到序列化操作，就一起讲完。关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的Ajax请求一般返回的为Json格式。

1、serializers

from django.core import serializers

ret = models.BookType.objects.all()

data = serializers.serialize("json", ret)

2、json.dumps

import json

ret = models.BookType.objects.all().values('id', 'caption')

ret=list(ret)

result = json.dumps(ret)

由于json.dumps时无法处理datetime日期，所以可以通过自定义处理器来做扩展,大家是不是知道是什么了？没错就是上面的errors的自定制序列化

 import json
 from datetime import date
 from datetime import datetime 

 class JsonCustomEncoder(json.JSONEncoder): 

     def default(self, field): 

         if isinstance(field, datetime):
             return field.strftime('%Y-%m-%d %H:%M:%S')
         elif isinstance(field, date):
             return field.strftime('%Y-%m-%d')
         else:
             return json.JSONEncoder.default(self, field) 

ModelForm

前面讲解完model和form，现在终于可以说modelform了。ModelForm是什么呢？其实可以这样理解，model跟form都需要对字段进行定义并指定类型，而通过ModelForm则可以省去form中的定义。可以看做是一种轻量级的更简化的工具。既然是model和form的结合，大概可以想到是不是结合了model和form的功能呢？带着这个疑问，开启这一段。

一个简单的modelform

 class UserModelForm(forms.ModelForm):
     class Meta:
         model = models.User  # 指向类
         fields = '__all__'  # 指向参数标签
         # fields = {'user', 'email'}  选择网页产生标签的字段
         # exclude = {'pwd'}  选择网页不产生标签的字段(排除掉)

然后view里面

 def mf(request):
     if request.method == 'GET':
         obj = UserModelForm()
         return render(request, 'mf.html', {"obj": obj})

model

 class UserType(models.Model):
     user_type = models.CharField(max_length=32)
     def __str__(self):
         return self.user_type

 class User(models.Model):
     user = models.CharField(max_length=32)
     pwd = models.CharField(max_length=32)
     email = models.EmailField(max_length=32)
     ut = models.ForeignKey(to='UserType', to_field='id')

模板

 <body>
     <form action="mf.html" method="post">
         {% csrf_token %}
         {{ obj.as_table }}
         <input type="submit" />
     </form>

 </body>

效果：

这样相比于之前，又方便了很多。大家不免好奇，modelform跟form到底是怎么组成的，下面我们下钻来看一下

Form验证
UserInfoForm	==> Form	==>	BaseForm(is_valid...)

ModelForm验证
UserInfoModelForm	==>	ModelForm	==>	BaseModelForm	==>	BaseForm

此时你一定会疑惑，关于标签的定制化修饰，跟数据验证呢？

ModelForm组件

 ModelForm
     a.  class Meta:
             model,                           # 对应Model的
             fields=None,                     # 字段
             exclude=None,                    # 排除字段
             labels=None,                     # 提示信息
             help_texts=None,                 # 帮助提示信息
             widgets=None,                    # 自定义插件
             error_messages=None,             # 自定义错误信息（整体错误信息from django.core.exceptions import NON_FIELD_ERRORS）
             field_classes=None               # 自定义字段类 （也可以自定义字段）
             localized_fields=('birth_date',) # 本地化，如：根据不同时区显示数据
             如：
                 数据库中
                     2016-12-27 04:10:57
                 setting中的配置
                     TIME_ZONE = 'Asia/Shanghai'
                     USE_TZ = True
                 则显示：
                     2016-12-27 12:10:57
     b. 验证执行过程
         is_valid -> full_clean -> 钩子 -> 整体错误

     c. 字典字段验证
         def clean_字段名(self):
             # 可以抛出异常
             # from django.core.exceptions import ValidationError
             return "新值"
     d. 用于验证
         model_form_obj = XXOOModelForm()
         model_form_obj.is_valid()
         model_form_obj.errors.as_json()
         model_form_obj.clean()
         model_form_obj.cleaned_data
     e. 用于创建
         model_form_obj = XXOOModelForm(request.POST)
         #### 页面显示，并提交 #####
         # 默认保存多对多
             obj = form.save(commit=True)
         # 不做任何操作，内部定义 save_m2m（用于保存多对多）
             obj = form.save(commit=False)
             obj.save()      # 保存单表信息
             obj.save_m2m()  # 保存关联多对多信息

     f. 用于更新和初始化
         obj = model.tb.objects.get(id=1)
         model_form_obj = XXOOModelForm(request.POST,instance=obj)
         ...

         PS: 单纯初始化
             model_form_obj = XXOOModelForm(initial={...})

给个简单的例子

 class UserModelForm(forms.ModelForm):
     class Meta:
         model = models.User  # 指向类
         fields = '__all__'  # 指向参数标签
         # fields = {'user', 'email'}  选择产生标签的字段
         # exclude = {'pwd'}  选择排除开不产生标签的字段
         # labels = {
         #     'user': '用户名',
         #     'pwd': '密码',
         # }
         # help_texts = {
         #     'user': '....',
         # }
         # widgets = {
         #     'user': widgets.Textarea(attrs={'class':'c1'}),
         # }
         # error_messages = {
         #     '__all__': {},  # 整体错误信息
         #     'email': {
         #         'required': '邮箱不能为空',
         #         'invalid': '邮箱不合法'
         #     }
         # }
         # field_classes = {
         #     # 'email': fields.URLField,
         # }

加入多对多的实例

 class UserType(models.Model):
     user_type = models.CharField(max_length=32)
     def __str__(self):
         return self.user_type

 class UserGroup(models.Model):
     group_name = models.CharField(max_length=32)
     def __str__(self):
         return self.group_name

 class User(models.Model):
     user = models.CharField(max_length=32)
     pwd = models.CharField(max_length=32)
     email = models.EmailField(max_length=32)
     ut = models.ForeignKey(to='UserType', to_field='id')
     u2g = models.ManyToManyField(UserGroup)

执行数据库语句,重构数据库

python manage.py makemigrations
python manage.py migrate

做点不一样的，修改了下view视图函数

 def mf(request):
     if request.method == 'GET':
         obj = UserModelForm()
         return render(request, 'mf.html', {"obj": obj})
     if request.method == 'POST':
         obj = UserModelForm(request.POST)
         if obj.is_valid():
             obj.save()
         else:
             print(obj.errors)
         return render(request, 'mf.html', {"obj": obj})

运行页面，输入数据：

因为通过了验证，所以可以发现数据库保存了此次输入。就是这么简单粗暴。。

浅浅的看一下obj.save()内部

     def save(self, commit=True):
         """
         Save this form's self.instance object if commit=True. Otherwise, add
         a save_m2m() method to the form which can be called after the instance
         is saved manually at a later time. Return the model instance.
         """
         if self.errors:
             raise ValueError(
                 "The %s could not be %s because the data didn't validate." % (
                     self.instance._meta.object_name,
                     'created' if self.instance._state.adding else 'changed',
                 )
             )
         if commit:
             # If committing, save the instance and the m2m data immediately.
             self.instance.save()
             self._save_m2m()
         else:
             # If not committing, add a method to the form to allow deferred
             # saving of m2m data.
             self.save_m2m = self._save_m2m
         return self.instance

值得关注的三个地方，首先是参数申明的时候的commit = True，所以obj.save()会默认提交数据，执行

if commit:
    # If committing, save the instance and the m2m data immediately.
    self.instance.save()  # 执行数据库的操作，基本表跟外键（不执行ManyToMany）
    self._save_m2m()  # 执行ManyToMany

如果设置为false呢？

else:
    # If not committing, add a method to the form to allow deferred
    # saving of m2m data.
    self.save_m2m = self._save_m2m

这里的_save_m2m赋值给了sace_m2m，并且下面还有一个return self.instance.。所以自己重新提交的时候，

 def mf(request):
     if request.method == 'GET':
         obj = UserModelForm()
         return render(request, 'mf.html', {"obj": obj})
     if request.method == 'POST':
         obj = UserModelForm(request.POST)
         if obj.is_valid():
             instance = obj.save(False)
             instance.save()
             obj.save_m2m()
         else:
             print(obj.errors)
         return render(request, 'mf.html', {"obj": obj})

其实ModelForm更强大的功能在于能够在用于新url产生网页这方面，比如修改用户信息。

一个用户列表网页

 def user_list(request):
     obj = models.User.objects.values('user','id')
     return render(request, 'user_list.html', {'obj': obj})

用户列表view

 <body>
     <ul>
         {% for row in obj %}
         <li>{{ row.user }} - <a href="/edit-{{ row.id }}">编辑</a></li>
         {% endfor %}
     </ul>
 </body>

用户列表html

一个编辑用户网页

 def user_edit(request, nid):
     if request.method == 'GET':
         obj = models.User.objects.filter(id=nid).first()
         mf = UserModelForm(instance=obj)
         return render(request, 'user_edit.html', {'mf': mf, 'nid': nid})
     elif request.method == 'POST':

         obj = models.User.objects.filter(id=nid).first()
         mf = UserModelForm(request.POST, instance=obj)
         if mf.is_valid():
             mf.save()
         else:
             print(mf.errors.as_json())
         return HttpResponse('ok')

编辑用户view

 <body>
     <form method="post" action="/edit-{{ nid }}">
         {% csrf_token %}
         {{ mf.as_p }}
         <input type="submit" />
     </form>
 </body>

编辑用户html

对于新url页面的跟赋值应该先通过id获取对象然后把对象传给modelform里面的instance。而更新数据的时候则需要先获取旧的对象，传给modelform的instance来告诉它需要更新的对象是谁，最后是save，中间是一系列的验证之类。可见ModelForm对面上面这种情况书写起来真的是一气呵成，很便利。

最后补充下ModelForm里面如何数据库之外的标签，比如登陆的时候的记住密码的选择。

class UserModelForm(forms.ModelForm):
    is_rem = fields.CharField(
        widget=widgets.CheckboxInput
    )
    class Meta:
        model = models.User  # 指向类
        fields = '__all__'  # 指向参数标签

讨论点一

　　对于ajax请求，我们可以返回HttpResponse，或者Render，存在即是有原因的，那么如何运用这两种呢？

首先，HttpResponse是我们所推荐的方法，一个自定义的序列化字典，前段接收到这个字符串进行反序列化，就可以从json数组中随意的选取自己的值，灵活性更高，自定制效果更好。

当然我们也可以用Render来返回一个Html，当然这里的html并不是常规意义上的html，比如是这样一个html
    <p>{{obj.name}}</p>
然后函数或者类里面返回
    render(request,'index.html',{'obj':obj})
根据django的请求生命周期，很容易我们就可以看出，我们首先执行函数或者类，然后得到这个obj对象，再加上这个html，其次对这个渲染的html进行解释，最后得到的其实就是一个<p>dandy</p>
这样的标签的字符串，通常我们会用这种方式返回给ajax一些标签。但是对于这类字符串，是无法进行修改的，或者说很难，灵活性跟直接返回序列化字典对比就能看出来差很多。 

所以还是那句话，在绝大多数情况下，更推荐使用HttpResponse来返回序列化字典给前端的ajax。
另外，切记，redirect返回是无效的。

讨论点二

　　ORM的性能分析

假设models里面有一个user类，里面有基础信息(name, age, mail)，还有个外键ut对应usertype这张表。

首先是基本的models操作。
users = models.User.objects.all()
for row in users:
    row.name
    row.ut.name    # 这一步django会重新执行一次sql连接查询操作。所以如果有10条数据就一共需要执行11次sql查询。性能肯定很差

# select_related
users = models.User.objects.all().select_related('外键1')
for row in users:
    row.user, row.ut.name  # select_related 表之间进行join连表操作，一次性获取关联的数据。

# profetch_related
users = models.User.objects.filter(id__gt=30).prefetch_related('ut', '外键2')  # 会发起2次sql请求
# select * from Users where id > 30
# 获取上一步中所有的ut_id = [1, 2]
# select * from user_type where id in [1, 2]
# select * from user_type where id in [1, 2]	如果2个外键，再发一个请求就好了
for row in user:
	print(...)	==>	django会直接到内存里面去抓取而不会去再去进行sql请求了

　　

扩展：自定义分页

a、XSS恶意攻击：防止写script之类循环让网页一直输出弹框（最简单的实例）恶意攻击：防止写script之类循环让网页一直输出弹框（最简单的实例）
  前端：{{name|safe}}==>告诉网页这个返回的字符串是安全的。不屏蔽成字符串

b、from django.utils.safestring import mark_safe
　 page_str = "<a href='index'>name</a>"
　 page_str = mark_safe(page_str)

逻辑：

divmod 除 余数
active
逻辑：
	当前页：current_page
	总页数：total_count
	每页显示10条数据：page_per_count
	页码：11

	如果：总页数<11
		start_index = 0
		end_index = 总页数

	else：
		当前页<=6 显示1~11
		当前页小于6 显示当前页-5，当前页+5+1
		如果当前页+5>总页数：
		end_index = total_count + 1

自定义类Page：

#!/user/bin/env python
# -*-coding: utf-8-*-
from django.utils.safestring import mark_safe
class Page:
    def __init__(self, data_total_count, current_index, show_data_count=10, show_tag_count=11, ):
        self.data_total_count = data_total_count
        self.current_index = current_index
        self.show_data_count = show_data_count
        self.show_tag_count = show_tag_count
    @property
    def start(self):
        return (self.current_index - 1) * self.show_data_count
    @property
    def end(self):
        return self.current_index * self.show_data_count
    @property
    def all_count(self):
        v, y = divmod(self.data_total_count, self.show_data_count)
        if y:
            v += 1
        return v

    def page_str(self, base_url):
        if self.all_count < self.show_tag_count:
            start_index =1
            end_index = self.all_count + 1
        else:
            if self.current_index <= (self.show_tag_count+1)/2:
                start_index = 1
                end_index = self.show_tag_count + 1
            else:
                start_index = self.current_index - (self.show_tag_count - 1)/2
                end_index = self.current_index + (self.show_tag_count + 1)/2
                if (self.current_index + 5) > self.all_count:
                    start_index = self.all_count - self.show_tag_count + 1
                    end_index = self.all_count + 1
        page_list = []
        if self.current_index == 1:
            prev = "<a class='page' href='javascript:void(0)'>上一页</a>"
        else:
            prev = "<a class='page' href='%s?p=%s'>上一页</a>" %(base_url, self.current_index - 1)
        page_list.append(prev)
        for i in range(int(start_index), int(end_index)):
            if i == self.current_index:
                temp = "<a class='page active' href='%s?p=%s'>%s</a>" %(base_url, i, i)
            else:
                temp = "<a class='page' href='%s?p=%s'>%s</a>" % (base_url, i, i)
            page_list.append(temp)
        if self.current_index == self.all_count:
            nex = "<a class='page' href='javascript:void(0)'>下一页</a>"
        else:
            nex = "<a class='page' href='%s?p=%s'>下一页</a>" % (base_url, self.current_index + 1)
        page_list.append(nex)
        dest = """
        <input type='text' value=1 /><a onclick="jumpTo(this,"%s?p=");">GO</a>
        <script>
            function jumpTo(ths, base){
                var val = ths.previousSibling.value;
                location.href = base + val;
            }
        </script>
        """ % base_url
        page_list.append(dest)
        page_str = mark_safe("".join(page_list))
        return page_str

外部调用

from utils import paging
def temp3(request):
    if request.method == "GET":
        page_count = int(request.COOKIES.get("page_count", 10))

        current_index = request.GET.get('p', 1)
        current_index = int(current_index)  # 当前的页数
        page_obj = paging.Page(len(li), current_index, page_count)
        data_list = li[int(page_obj.start):int(page_obj.end)]

        page_str = page_obj.page_str("/app01/temp3/")

        return render(request, 'temp3.html', {"list": data_list, "str": page_str})

模板语言

    <ul>
        {% for row in list %}
            <li>{{ row }}</li>
        {% endfor %}
    </ul>
    <select id="slt" onchange="page_count(this)">
        <option value="5">5</option>
        <option value="10">10</option>
        <option value="20">20</option>
        <option value="30">30</option>
    </select>
    <div class="page_index">
        {{ str|safe }}
    </div>
    <script src="/static/jquery-3.2.1.js"></script>
    <script src="/static/jquery.cookie.js"></script>
    <script>
        $(function() {
            var v = $.cookie("page_count");
{#            var v = $.cookie("page_count", {'path': "/app01/temp3/"});#}
            $("#slt").val(v)
        });
        function page_count(ths) {
            val = $(ths).val();
            $.cookie("page_count", val)
        }
    </script>

　　

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'邮箱'}))