web框架-Django

时间 2019-11-09

标签 web 框架 django 栏目 HTML 繁體版

原文原文链接

Django简介css

pip安装，配置环境变量 ……python\script django-admin

建立、操做django项目：html

建立工程项目
- 方式一：cmd命令行 django-admin startproject 项目名
- 方式二：IDE，pycharm中建立django项目
  - 在使用pycharm过程当中，须要设置django server：
    - 名字是项目名字
    - 默认ip，端口
    - environment variable: DJANGO_SETTINGS_MODULE 工程项目名.settings PYTHONUNBUFFERED : 1
    - python解释器
- 运行：
  - 命令行中，　　python manage.py runserver 指定host：端口 host和端口可省略，使用默认
  - pycharm中完成配置。在“select run /debug configuration” 中选定配置好的django ，点击运行　　
django项目目录结构：
- 与项目同名的文件夹：完成程序的总体配置
- init
- settings ：配置文件
  - TEMPLATES 进行模板文件配置，设置模板文件的查找路径等。
  - STATIC_DIR 　　静态路径
  - STATICFILES_DIRS 静态文件路径配置，设置css，js等静态文件路径信息
- urls ：url对应关系
- wsji　　：wsgi规范
- manage.py ：管理django程序
  - python manage.py 运行
  - python manage.py startapp 程序名
  - python manage.py makemigrations
  - python manage.py migrate
建立app
- 在cmd命令行中，进入工程项目目录， python manage.py startapp 指定app名
- windows python中可经过 Teminal 运行上面的命令
- 常见app ：cmdb templates openstack……
- app内部结构文件功能（cmdb）：
  - migrations：数据修改表结构
    - 内部有django自动建立的数据库修改表结构的操做记录，注意，仅记录了对表结构的修改，数据库中的记录的操做，不记录。
  - __init__ 把文件夹转成包
  - admin django为咱们提供的后台管理
    - 包括了登陆、添加、删除、权限管理等基本功能。
  - apps 配置当前app
  - models： ORM，写入指定的类，经过命令建立和修改数据库结构
  - tests：单元测试
  - views：和cmdb相关的全部业务，业务逻辑代码
- 不一样文件、模块间的调用过程当中，注意核实settings中环境的配置
- 配置模板的路径
  - 在settings中，DIRS:[os.path.join（BASE_DIR,"模板包名字"）] 通常的是templates
- 配置静态文件的路径
  - 在settings中，STATIC_DIR后面，加上STATICFILES_DIRS = (os.path.join（BASE_DIR,"静态文件名字"），) 通常地静态文件名为static
django项目建立步骤
- 1 建立django工程 django-admin startproject 工程项目名
- 2 建立app cd工程文件夹 python manage.py startapp app名
- 3 静态文件配置
  - 静态网页，静态网页是相对于动态网页而言，是指没有后台数据库、不含程序和不可交互的网页。
    - 静态网页优点：能够公开（即副本能够证实给任何人）。托管没得任何特殊的要求。（不须要特殊的中间软件好比超文本预处理器、公共网关接口）没得网络服务器或应用服务器，好比直接从CD-ROM（激光唱片-只读存储器）或USB闪存驱动器读取内容，能够经过网络浏览器直接访问。网站更安全，HTML页面不会受Asp相关漏洞的影响；并且能够减小攻击，防SQL注入。数据库出错时，不影响网站正常访问。不须要编译，因此速度快，节省服务器资源。网址格式友好，搜索引擎容易识别。内容是固定的，交互性差，内容更新维护复杂。没有自动化的工具，维护大量的静态页面文件是不现实的。没法充分支持用户/客户的需求（外观选择，浏览器的支持，Cookie）。
  - 静态文件，通常是指css,js,img等相似的，让html直接引用的，能够直接暴露给用户的文件即归为静态文件．
  - 静态文件配置方式：
    - 方式一：
      - 在settings文件下，配置文件中已经有了静态文件的别名，STATIC_URL='/static/' 　在这以后添加　　STATICFILES_DIRS=[os.path.join(BASE_DIR,' ')] ．使用的时候，用别名static．

- 4 模板配置
- 5 csrf
- 6 定义路由规则 urls.py 请求字段——》响应函数名（视图函数、）
  - ```
  urlpatterns＝［　］　　
```
- 7 定义视图函数 app 下 views 判断数据发送方式，经过request拿数据，数据处理，数据返回
  - 　　HttpResponse-传字符串、 HttpResposnse(" 字符串 ")
  - 　　render-传HTML模板路径、 render（request ，"abc.html"，{ 替换形式字典 }）
  - 　　redirect-传 /URL） redirect(' /abc/ddd ')

django请求前端

- 请求通常状况下，GET方式用来获取数据，POST用于提交数据。其余的提交方式还有PUT/DELET等
- 路由关系映射
- 视图函数
- 数据 html模板
- 渲染之后返回给用户

路由系统（urls）python

- 常见的url匹配规则：
  - 1 一一对应静态匹配，url('index/',views.index) url('home/',views.Home.as_view()) 在设置路由关系时字段内容最后要加上$终止符，不然在匹配过程当中，会因为不是截止的精确匹配，于是先后优先级致使匹配错乱。例如，url('index/$',views.index)
  - 2 利用正则实现动态匹配(相似传递位置参数) url(r'detail-(\d+).html',views.detail)
    - 正则当中使用分组的状况下，会有二次匹配的状况，传递的参数会将全部的结果都传到视图函数中．
  - 3 利用正则表达式的分组实现（在函数调用时，参数以关键字形式传递） url（r“detail-(?p<nid>\d+)-(?p<uid>\d+).html”,views.detail）此url路由匹配规则在传递获取的参数时，会以nid=***,uid=***进行传递　　为了方便，在views定义视图函数的时候，直接用不定长参数*args，**kwargs定义。
  - 注意
    - 要想从路径中捕获某些信息，只须要在对应的正则内容上面加分组，进行二次匹配
    - 使用正则的时候，前面开始的反斜杠不用加，会自动添加
    - 正则表达式前面的ｒ虽然是可选项，但通常状况下最好是加上．
    - 因为路由系统的匹配顺序是自上而下的顺序匹配，因此，在正常的匹配规则最后，最好是加上 ‘$’ 终止符，作精准匹配，防止出现上面的url匹配规则把某类的匹配所有截获，下面的匹配规则得不到有效执行。
- 获取当前url信息，request.path_info
- 路由分发，主要的目的是实现不一样app之间进行解耦．当请求到顶级（项目同名）url的时候，经过include，根据请求的关键字，对请求进行一个分发，同时在不一样的app中创建局部的urls文件，避免不一样app之间urls放在一块儿，加强系统的易读易维护性。顶级url负责分发，例如， url（"monitor/",include("app003.urls")）,url("cmdb/",include("app06.urls"))
  - 首先 from urls import include
  - 前面的匹配规则能够用正则，也能够为空，当为空的时候，会直接到各个app中进行进一步匹配．
- 路由的反向解析
  - 目的是不在代码中把url写死，而是经过反向查询动态获取。　
  - 主要应用方式：
    - 在模板中，利用{%url '路由中给匹配规则起得别名' %}
    - 在视图函数中，reverse的应用，利用reverse函数，能够根据路由名称(别名)，返回具体的路径。注意当路由中有正则表达式时，须要把代替填充的内容一并传递过去。
- url默认值，在路由系统中，能够给视图函数传递默认值，此时，须要保证视图函数有对应的形参用于接收默认值。例如 url("index/",views.index,{"name":"root"}) ,这时候，index视图函数的name参数会接收路由调用时自动传递过来的默认值root。
- url命名空间。使用反向解析的时候，在路由分发的状况中，若是出现不一样的url指向相同函数而且url所定义的别名相同等状况（例如不一样app定义的url匹配规则，虽然在不一样的app中，但定义别名一致时命名相同），单纯使用url的name没有办法获得确切的url路径，这时须要同时利用url的name，和定义路由时所一并定义命名空间。定义命名空间的基本语法 url（“a/”,include("app01.urls",namespace="a1")） url(“b/”,include("app01.urls",namespace="b1")) 经过reverse（ ‘ 命名空间namespace:路由name ’ ）能够肯定url路径
- url， re_path， path
  - re_path实际上就是以前的版本中的url方法，通常是结合正则表达式使用
  - 通常状况下，使用url、repath进行匹配后，若是规则中有正则而且分组的话，匹配出来的分组内容其实是以字符串形式，传递给视图函数的。另外，若是正则表达式中出现有名分组，须要对捕获到的内容进行类型强转。上述状况在django2.0以上的版本适合用path方法
  - path方法，与转化器
    - 转化器基本使用语法 path(' 包含转换器的url规则 '，视图函数，别名) 注意转换器是用尖括号包裹的<匹配转换器类型：分组名称>,一样的，url规则不须要前导斜杠。
    - 当前内置的转换器，有int，str，uuid, slug, path
    - 自定义转化器
      1. 定义转换器类
        
        regex 类属性，字符串类型
        
        to_python(self, value) 方法，value是由类属性 regex 所匹配到的字符串，返回具体的Python变量值，以供Django传递到对应的视图函数中。
        
        to_url(self, value) 方法，和 to_python 相反，value是一个具体的Python变量值，返回其字符串，一般用于url反向引用。
        
        1 # 新建py文件 2 class FourDigitYearConverter: 3 regex = '[0-9]{4}' 4 def to_python(self, value): 5 return int(value) 6 def to_url(self, value): 7 return '%04d' % value
        
        View Code
      2. 进行url配置注册
        
        使用register_converter 将其注册到URL配置中
        
        1 from django.urls import register_converter, path 2 from . import converters, views 3 register_converter(converters.FourDigitYearConverter, 'yyyy') 4 urlpatterns = [ 5 path('articles/2003/', views.special_case_2003), 6 path('articles/<yyyy:year>/', views.year_archive), 7 ... 8 ]
        
        View Code

视图函数 mysql

- 本质上就是一个python函数，但必须有返回值，也就是必须有return，返回内容是按规定的格式。通常是存放在views.py文件中。
- 视图函数操做的对象，能够简单的分为请求对象、响应对象两部分，其中request就是请求对象，封装了前端发过来的请求信息。响应对象有HTTPResponse、render方法本质上是对响应内容的封装并以HTTPresponse对象形式返回、
- 后台数据获取
  - request是前端数据的打包
  - 经常使用的request的属性
    - request.body 用户发起请求的请求体
    - request.GET存储get请求信息 request.POST存储post请求信息 request.FILES ……
    - 通常状况下，GET方式用来获取数据，POST用于提交数据。其余的提交方式还有PUT/DELET等
    - request.POST.get()
    - request.GET.get()
    - request.POST.getlist()　当提交的数据包含复选框等并列内容时，用getlist能够统一接收。
    - request.FILES.get()　
      - 要上传文件，须要在form标签中，须要作设置，enctype='multipart/form-data'
      - 上传文件时，FILES.get()获取上传的文件对象的属性信息。
    - request.FILES.size()
    - request.FILES.chunks()
      - 分段获取的，上传的文件内容。须要读取文件内容的话，须要对FILES.chunks()进行循环。
    - request.path_info 获取当前url中的【路径信息】
  - 经常使用的request的方法
    - request.Meta()
    - request.method()
    - request.get_full_path() 得到当前url中的【路径信息】和【请求参数信息】
  - request中封装了url请求的全部原生信息，其实是以类的形式存在的
    - 要查看请求体的详细信息，须要导入WSGIRequest ， from django.core.handlers.wsgi import WSGIRequest
    - request.environ 能够拿到请求体的完整信息，字典形式存放的
    - request.environ[ ] 能够拿到指定的信息内容，例如，request.environ['HTTP_USER_AGENT']
- reverse函数，能够根据路由的名称，反向解析出完整的路由信息。
  - 导入，from django.urls import reverse
  - 对于未指明namespace的， reverse(路由name)；对于指明namespace的， reverse(命名空间namespace:路由name)
- 返回内容
  - 包含django的模板标签的html文件，并不是真正的html文件（浏览器是不能对这种文件直接进行解析的），render方法是在传输响应信息前对模板文件进行了数据渲染，替换掉了模板标签。
  - return HttpResponse（）返回简单字符串 return render(request," html文件",{ 替换内容 })返回取到数据渲染后的html文件内容 return redirect( ' 重定向 url ' )
  - 数据返回的时候，cookie的设置内容是经过响应头传递回去的
- FBV（function base views）与 CBV（class base views）
  - FBV 由url直接对应（映射）函数名， CBV 由url直接对应（映射）到指定的类。
  - CBV 本质上，经过dispatch反射，实现根据数据请求的发送方式选择不一样方法执行
  - CBV方式，能够经过重写dispatch，实现自定制功能
- 装饰器（定义方式是同样的，调用方式不一致）
  - 基于FBV的
    - 1 #---------基于FBV的装饰器实现COOKIE登陆验证----------- 2 3 def auth(func): 4 def inner(request,*args,**kwargs): 5 v = request.COOKIES.get("user111") 6 if not v: 7 return redirect('/login/') 8 return func(request,*args,**kwargs) 9 return inner 10 11 @auth 12 def func01(request): 13 return HttpResponse("hello world")
      
      View Code
  - 基于CBV的
    - 基于CBV的视图函数，加装饰器时，须要导入模块 from django.utils.decorators import method_decorator 而后经过@method_decorator(auth)加装饰器
    - 具体调用方式：
      - 方式一，能够直接对类函数进行装饰
      - 方式二：对类里的方法全都装饰的状况下，能够利用dispatch函数。重写dispath函数，并加上装饰器，用super（类，self).dispatch(request,*args,**kwargs)进行正常的方法执行，在此执行的先后，能够自定义部分功能，实现装饰器的功能。
      - 方式三：直接在类名上面加装饰器，本质上，方式三是对方式二的简化
        
        1 #---------基于CBV的装饰器实现COOKIE登陆验证----------- 2 3 def auth(func): 4 def inner(request,*args,**kwargs): 5 v = request.COOKIES.get("user111") 6 if not v: 7 return redirect('/login/') 8 return func(request,*args,**kwargs) 9 return inner 10 11 @method_decorator(auth,name="dispatch") #方式三 12 class Order(views.View): 13 14 @method_decorator(auth) #方式二 15 def dispatch(self,request,*args,**kwargs): 16 return super(Order,self).dispatch(request,*args,**kwargs) 17 18 @method_decorator(auth) #方式一 19 def func1(self,request): 20 return HttpResponse("hello world普通函数")
        
        View Code

Templates 模板jquery

- 模板基础语法只有 {{ }} 和 {% %} 两种。前者是用于传递渲染变量用的，后者是用于渲染标签的。
- 能够直接定义html，而后实如今视图函数中进行调用
- 变量的渲染与使用
  - 变量的渲染是经过 {{ }} 实现的。
  - 使用方式：
    - 模板中用 {{ }} 定义好变量的位置
    - 在视图函数中，使用render方法进行变量传递，若是是传递单个变量，能够直接以字典形式在render方法中用第三个参数传递过去，若是是变量比较多，便可以一个个的传递，也能够经过locals（）方法，把视图函数中的变量打包成指定格式传递到模板中。
  - 深度查询
    - 在传递的变量是列表、字典、对象等类型的数据时，直接在模板中用 “ 。 ” 对须要的内容进行深度查询，从而拿到相应的内容。
  - 过滤器，即函数的使用
- 标签的渲染和使用
  - {% %} 渲染控制语句，基本的逻辑控制语法以下：
    - for循环基本语法：
      - {%for 条件 %} 循环体 {% endfor %}
      - {%for 条件 %} 循环体 {%empty%}当遍历到的内容为空时的执行语句 {% endfor %}
      - {{forloop}}能够拿到当前循环的次数，即循环的序列号。使用时直接 forloop.count，另外还有forloop.count0从0开始计数，forloop.revcounter ，forloop.revcounter0 ，forloop.last是否最后一个，forloop.first是否第一次循环。当出现嵌套循环的时候， forloop.parentloop将每次循环过程当中，父循环的上述6个参数打包。
    - 条件语句基本语法
      - {%if 条件%} 函数体 {%else 条件 %} 函数体
  - 继承、过滤器、csrf_token
- 继承，在布局重复的状况下，可使用html母版，经过继承母版的设置，提升程序的可读性、易维护性，下降维护成本
  - 使用方式：
    - 1 定义布局母版html ，在母版中用{%block 模块名字%}{%endblock%}定义能够替换的模块及其位置。
    - 2 在引用html文件中，声明引用的母版 {%extends “布局母版html文件名字”% }
    - 3 定义好当前html文件用于替换布局母版的内容。 {%block 模块名字%}自定义的内容{%endblock%}
    - 4 在具体页面中还有特有的css，js的状况，在母版中留出自定制css，js的位置，通常能够在模板的style位置后加入css的block，在js包括jquery位置加js的block，在具体页面中用自定义替换便可
  - 使用继承的注意事项：
    - extends标签必须在引用文件的首行
    - 在带引用的母版文件中，{%block 模块名字%}{%endblock%}越多越好，能够理解为越多状况下的可改造程度越高。
    - 通常状况下，子版中写入内容后，会直接把母版中的{%block 模块名字%}默认内容{%endblock%}，其中的默认内容直接用子版定义的内容替换掉。若是想在母版内容保留的前提下，添加内容，能够在定义子版内容的时候，加一个{{ block.super }} 的标签。
  - 一个html页面，只能继承一个母版。能够理解为电脑的主板，页面的总体框架，能够从母版中继承过来。
- 组件，对于页面中的重复布局，可使用组件，提升程序的可读性、易维护性，下降维护成本
  - 1 定义组件html文件
  - 2 在具体html文件中，用include对组件进行引用基本语法，{%include ' 引用组件的html文件名称 '%}
  - 组件能够理解为电脑的，鼠标键盘等中可插拔设备。
- 对于继承的母版、页面引用的组件，django会在进行渲染以前，先把这些内容都拿过来，生成一个完成的模板文件，而后再融入数据库替换的数据，最后在进行渲染。　　
- 函数（过滤器）与标签自定义，simple_tag
  - 1调用python内置函数（过滤器）
    - {{ 变量 | 内置函数：参数 }}　　
    - 经常使用的内置函数（内置过滤器）
      - data 定制时间显示格式
      - default 定制默认显示内容，当没有接收到变量的时候，若是没有默认内容，变量的位置直接为空
      - filesizeformat 格式化输出文件大小
      - truncatechars 按字节进行内容截断
      - truncatewords 按单词截断
      - safe 安全解析标志，在正常状况下，若是是传递包括<>的内容时，django会先经过html特殊符号对照表，对内容进行编译再传递，目的是防止不安全代码注入。
        
        经过safe过滤器，把传递的内容标注为安全的，django会把这部份内容正常写入html文件，交给客户端浏览器解析。
      - add,
      - upper　　
  - 2自定义函数（过滤器）或标签
    - a. app下建立templatetags目录
    - b. 建立py文件
    - c. 自定义标签，导入模块 from django import template from django.utils.safestring import mark_safe 建立template对象，register 继承自template.Library。名字必须是register不能用其余的。
    - d. 建立自定义函数，加装饰器 @register.simple_tag
    - e. settings中注册当前app
    - f.在引用文件顶部导入函数文件 { % load 函数所在的py文件名 % }，
    - g. 执行自定义函数 { % 函数名参数1 参数2 …… % } 　　
    - 在建立函数上面的加的装饰器，还能够是@register.filter 此时，调用函数的时候格式相似调用python内置函数，{{参数|函数名：数字参数}} 当传的参数较多时，用字符串， {{参数 | 函数名：“参数二，参数三，”}}。这种方式的缺点是，参数数量有限制，函数名后最多放两个参数，而且元素之间不能有空格。优势是能做为if判断条件使用，放在 template 模板流程控制中
- 当模板html文件中，既有extend继承，又有load时，必须将load放在extend以后，主要缘由是extend继承过来的是模板文件的总体框架。

CSRF简介及中间件设置介绍git

CSRF与跨站请求伪造简介
- csrf原理
- 跨站请求伪造
- 无csrf时存在的隐患（csrf存在的意义）
- 通常状况下，当request.mehtod是get，head，options，trace等方式的时候，能够不加csrf_token
- form表单提交与csrf，正常状况下，直接用form发post请求，django会把请求拦截下来。
  - 在form表单代码中，起始位置，添加标签{%csrf_token%} 本质上，是在作渲染时，django把这个标签渲染成了一个隐藏的input标签。
  - 执行流程，是在第一次打开带有form表单的页面的时候发动的是get请求，视图函数给的响应是返回登陆页面，此时django会先拿到模板文件对内容渲染后传递到客户端，再提交post请求的额时候，是带着这个隐藏的input标签进行提交的，这相似于拿着取到的门卡去提交。
- csrf设置
  - 全局设置 settings中，找中间件 MIDLEWARE[
```
'django.middleware.csrf.CsrfViewMiddleware'
```
    ]
  - 局部设置用装饰器对视图函数进行设置单独加加csrf设置 @csrf_protect 单独取消csrf设置 @csrf_exempt
- ajax提交与csrf
  - 单个ajax请求时，设置
  - 对页面中全部ajax请求统一设置

Models，数据库操做（ORM） web

- 主流ORM能够分红 db first (须要先本身登录数据库创建表结构，此后通过执行会自动建立相应的类，对表结构进行操做的时候，能够直接对这些类进行操做来完成)，code first（先写代码，建立须要的各类类，而后经过执行语句，利用建立的类建立数据库表）两类。主流的orm是code first类型。
- 当前django提供的ORM，只能完成对数据库中的表进行操做，数据库层面上的操做，还须要在数据库层面上进行布局。　
- 另外须要注意的是，py3.x 的解释器进行数据库操做的时候，django默认的数据库驱动接口是mysqldb，而py3.x 用的数据库驱动接口是pymysql，因此须要使用前对驱动接口进行设置，在项目名文件目录下的init文件中，写入以下内容：
  - ```
  import pymysql
  pymysql.install_as_MySQLdb()
```
- 建立类
  - 根据类建立数据表
    - 在app下，models.py中，建立类，继承models.Model。注意，models.py命名不能改，不然会报错
      - 经过类建立表
      - 在类中，经过models的方法，定义字段，其中可选属性null=True，定义能够为空。例如 username=models.CharField(max_length=32)
      - 建立字段的方法，分为三大类，字符串、数字、时间、二进制，经常使用的有：CharField定义通常的字符串 IntegerField定义数字 DateField定义日期 DateTimeField定义时间 EmailField 定义邮箱格式 GenericIPAddressField定义IP类型 URLField定义URL AutoField定义自增列，必须加属性primary_key=True
        
        须要注意的是，EmailField、URLField、GenericlPAddressField等类型，基本上是在使用django提供的admin时才能用得上，通常状况下，就用CharField定义通常的字符串 IntegerField定义数字 DateField定义日期 AutoField定义自增列，必须加属性primary_key=True
      - 字段的经常使用参数有： null——》是否为空，default——》默认值，primary_key——》主键，db_column列名，db_index——》索引，uique——》惟一索引，unique_for_date，unique_for_mounth，unique_for_year，auto_now——》建立时，自动获取时间，auto_now_add——》更新时，自动获取当前时间，须要注意的是，使用update对数据进行更新的时候，这种操做的时间不会记录更新，只有用 ‘=’ 从新赋值，而后save的操做才会记录更新时间。choices——》元组形式定义分组，把内容放在内存中，运行的时候admin中显示的下拉框，实现了连表查询的显示效果，而且避免了连表查询的低效率。 blank——》在admin中，定义是否为空 verbose_name——》在admin中设置是否为中文 editable——》设置admin中是否可编辑 error_messages——》错误提示 help_text——》在admin中提示信息 validators——》自定义错误信息 protocol用于GenericIPAddressField设置ip协议类型
    - settings中，INSTALLED_APPS中，注册app
    - 经过manage建立表结构， python manage.py makemigrations 注意，在建立以前，须要把在settings中，把当前app名加入INSTALLED_APPS
    - 用django默认的数据库是sqlite，若是用mysql，须要，1 在settings中，把数据库引擎设置修改，
```
#DATABASES = {
#     'default': {
#         'ENGINE': 'django.db.backends.mysql',
#         'NAME': 'dbname',
#         'USER':'root',
#         'PASSWORD':'mysql',
#         'HOST':'',
#         'PORT':'',
#     }
# }
```
    - 另外，须要注意的是，利用django使用mysql时引擎默认是用的mysqldb，可是，当前python3.x中，尚未mysqldb。须要在和【项目同名】的文件夹下，__init__文件中，设置
```
#import pymysql
# pymysql.install_as_MySQLdb()
```
    - 当使用py3.x解释器，跑django2.0版本的时候，会报错，django.core.exceptions.ImproperlyConfigured，即版本错误。这时，须要在解释器程序中Python\Python36-32\Lib\site-packages\Django-2.0-py3.6.egg\django\db\backends\mysql 这个目录下对下面的内容注释掉
      - if version < (1, 3, 3): raise ImproperlyConfigured("mysqlclient 1.3.3 or newer is required; you have %s" % Database.__version__)
    - 执行migrate命令，在数据库中建立表，相似于数据库的确认操做， python manage.py migrage
    - 若是要查看orm执行的sql语句，能够进行settigns中设置后打印，
      - 1 LOGGING = { 2 'version': 1, 3 'disable_existing_loggers': False, 4 'handlers': { 5 'console':{ 6 'level':'DEBUG', 7 'class':'logging.StreamHandler', 8 }, 9 }, 10 'loggers': { 11 'django.db.backends': { 12 'handlers': ['console'], 13 'propagate': True, 14 'level':'DEBUG', 15 }, 16 } 17 }
        
        View Code
    - 对数据库的表单结构修改（字段内容）后，即对定义表的类进行修改之后，用manage.py 执行makemigrations，migrate命令进行确认操做。
  - 数据库单表操做与多表操做（外键），增删改查
  - 根据类对数据库表中的数据进行各类操做，注意：增长、更新、查询传递参数时，均可以经过 ** 传递字典进行操做
    - 增长：
      - 方式一，直接建立　　models . 表名 .objects.create（字段1：数值，字段2……）当字段较多，能够先建一个存储信息的字典，而后把字典穿进去，当传递字典时，须要在字典名前加 ** models . 表名 .objects.create（**字典名）执行的时候是有返回值的，返回的是建立的记录对象。
      - 方式二，经过建立一个对象信息，而后把保存对象 obj=models . 表名（字段1：数值，字段2……） obj.save() 执行的时候是有返回值的，返回的是建立的记录对象。
      - 当定义字段时，使用models.EmailField() models.GenericIPAddressField()等特殊格式时，若是用 create建立，或者用update更新，都不会有格式验证。只有在执行django admin时会有格式验证。
    - 查询：
      - models.表名.objects 拿到的是一个能够对表进行操做的句柄。
      - all（）拿到的是对象形式存储信息的QuerySet（形式上相似于列表） models.数据表名.objects.all()
        
        对于查询的结果，能够经过 .order_by()进行排序 models.数据表名.objects.all().order_by() models.UserInfo.objects.filter(id__gt=1).order_by()
        
        .first() 结果中的第一个 .count()对结果进行计数 .last() 结果中的最后一个
      - 利用filter添加where查询条件，结果也是以QuerySet存储 models.数据表名.objects.filter(筛选条件)，能够经过“__”实现逻辑模糊查询。
        
        models.UserInfo.objects.filter(id=1)
        
        models.UserInfo.objects.filter(id__gt=1)
        
        models.UserInfo.objects.filter(id__lt=1)
        
        models.UserInfo.objects.filter(id__gte=1)
        
        models.UserInfo.objects.filter(id__lte=1)
        
        models.UserInfo.objects.filter(name__contains='H')
        
        models.UserInfo.objects.filter(name__icontains='H')
        
        筛选条件中，多条件并列时，能够直接用“，”对多条件进行链接。
      - 另外，用models.数据表名.objects.get(筛选条件）能取到单条数据，取不到内容或者是取到的结果是有多条时，报错！须要try一下。须要注意的是，大部分的查询结果是queryset存储的结果，但get方法是获取的单个的对象。
      - models.数据表名.objects.exclude(筛选条件) 能够实现反向查询，即选出不知足筛选条件的记录，并把结果存入queryset中存储。
      - 通常状况下，查询的结果，不管是all（）或者是经过fiter（）取到的都是queryset形式储存的对象的序列，再链一个values() 拿到的是queryset形式存储的字典的序列能够指定取出的字段例如models.UserInfo.objects.filter(id__gt=1).values(‘id’,'name')，若是链一个values_list() 拿到的则是queryset形式存储的元组的序列，能够经过索引值，拿到指定的字段
      - queryset能够调用的其余经常使用方法
        
        order_by()方法，对queryset结果，按指定规则进行排序，返回值仍然是queryset。排序规则支持多条件，能够直接用“，”对条件进行链接。
        
        reverse() 方法，也是queryset进行反向操做时进行调用，返回值仍然是queryset。
        
        values（指定键值）方法，能够从queryset的对象列表中，拿到每一个对象的指定键值对即字典形式，返回结果以queryset形式存储的字典键值对。
        
        values_list(指定键值) ，功能相似于values，但不一样的是，返回的结果是queryset形式存储的元祖，不含键只有值。在取值的时候，用索引值。
        
        distinct() ，主要功能是进行去重。
        
        first（）当queryset中有对象时，取到的是第一个对象，没有对象时，取到的是none。用起来比get方法更方便。
    - 删除：
      - 方式一，能够在queryset直接调用delete方法
        
        models.数据表名.objects.filter（筛选条件）.delete()
      - 方式二，能够在queryset中利用first，last等取到记录对象后，直接调用delete
        
        models.数据表名.objects.filter（筛选条件）.first().delete()
    - 修改（更新）：
      - 只能由queryset进行方法调用
        
        models.数据表名.objects.filter（筛选条件）.update(字段=修改的数值）　　
  - 外键
    - 定义数据表结构的类中，定义外键对应关系。外键关系名 = models.ForeignKey(to=关联表名，to_field=关联字段，default=指定默认值， on_delete=models.CASCADE) 外键关系名_id ——》外键字段（自动） on_delete=models.CASCSDE 是在django2.x之后版本加入的，最明显的一个做用，是避免两个表之间的数据不一致。models.CASCADE是默认状况下的取值，另外的取值分别为：
      - CASCADE：此值设置，是级联删除。
        PROTECT：此值设置，是会报完整性错误。
        SET_NULL：此值设置，会把外键设置为null，前提是容许为null。
        SET_DEFAULT：此值设置，会把设置为外键的默认值。
        SET()：此值设置，会调用外面的值，能够是一个函数。
    - 调用执行过程当中，外键关系名指向关联表的对象
    - 当用all（），filter（）等方法直接拿到结果的时候，跨表拿内容，直接用 “ queryset存储的表对象 . 外键关系名 . 字段名 ” 来获取例如item.group_foreignkey.name。此时的外键关系可理解为封装在queryset对象中的子级对象，指向关联表。
    - 当用values()，或者values_list() 拿到结果的时候，跨表拿内容，不能用 “ . ” 须要改为双下划綫“ __ ” 例如：item.group_foreignkey__name。而且，在用values，或者values_list() 须在视图函数中完成，
    - 反向查询外键关联关系表。
    - 一对一关系，其实是对一张字节比较多的表，进行的拆分。创建方式能够是经过惟一的外键，也能够经过
  - 一对多关系，经过创建外键，能够实现表之间的一对多的关系建立
    - 用创建外键关系后，经过 ‘ .外键关系_id ’ 能够获取从属表中，保存的外键值，利用 ‘ . 外键关系 ’ 则能够直接取得对应的对象，直接用链接符 ‘ . ’ 可进一步经过跨表查询获取具体的属性。
    - 一对多关系常见的查询方式：
      - 若是经过 ‘ . ’ 跨表查询得到的是外键连接的对象，当这个对象中仍然包含其余的外键关系时，能够依次用 ‘ . ’ 跨表查询得到
      - 双下划綫，实现跨表查询，当跨表查询的结果做为参数使用时，利用 __。例如在，value()中传递参数的时候。
  - 多对多关系创建
    - 方式一，经过手动创建第三张表做为关系表，分别经过外键和另外的两张表创建外键关联，最终实现两张关联表之间的多对多
    - 方式二，利用r=models.ManyToManyField() ，在建立原始的关联表的时候，由django自动建立多对多的第三张关系表。r做为操做句柄能够实现对第三张关系表的操做。
      - 利用r操做对应关系的时候，先获取一张关联表（建立r的表）中的对象，例如， obj=models.关联表名.get(id=1)
      - 而后经过r对关联关系进行操做。 obj.r.add(2) obj.r.add(1,2,3) obj.r.add(*[3,4,5,6]) obj.r.remove(2,3) obj.r.clear() obj.r.set([1,2,3]) 用set设定更新关系时，传列表不用加* 。 obj.r.all() 拿到的是一个另外一张表的对象， obj.r.filter()
    - 方式二默认的只能够建立两张表之间的关系。若是须要多张表之间创建关系，须要用方式一。
  - 验证功能

jquery中的Ajax基本操做
- 本质上是对提交动做进行了拆解，通常状况下，浏览器发送数据是有页面刷新动做伴随发生的，为了不页面刷新直接将页面上原有的数据直接刷掉，利用ajax能够将这两步动做进行拆解，并在中间部署一次后台交互动做。
- 1 设置绑定ajax的标签，例如， <a id="ajax_test">我是ajax构造提交</a>
- 2 在视图中构建ajax后台函数，
- 3，在路由urls中绑定url ，指向后台ajax函数
- 4，在html中给设置的ajax标签，绑定动做事件，及url，type，data，datatype，sucess等，例如
  - 1 $('#ajax_test').click(function(){ 2 $.ajax({ 3 url:"/ajaxTest/", 4 type:'POST', 5 data:{'hostname':$("#hostname").val(),"ip":$("#ip").val(),"port":$("#port").val(),"b_id":$("#b_id").val()}, 6 dataType:"JSON", 7 success:function(redata){ 8 if(redata=='ok'){ 9 location.reload(); 10 }else{ 11 alert(redata) 12 } 13 } 14 }) 15 })
    View Code
  - url 便是提交的目标url地址
  - 其中提交的type，有GET，POST，JSON等类型
  - data的数据能够用serialize打包发送。例如： data：$(经过class或id等找到form标签).serialize() ；若是只是发送部分form的部份内容，只须要获取标签的内容，而后以键值对的形式进行发送。例如 : data:{'username':$( 'form input[name="username"]' ) }
  - 若是发送的数据中，有多选的，例如select（multiple）、checkbox等，或者data的键值对的内容包含列表，须要在ajax参数中设置 traditional：true ，这样，多选的数据会打包成列表发送至后台，后台函数取这类打包成列表的值得时候，须要用getlist。
  - ajax操做，后台若是是return redirect，没法接收到数据。若是是return HttpResponse 能够顺利的经过JSON序列化与反序列化进行功能对接，当return render时，后台返回的页面内容也是字符串形式，不能自动执行，须要进一步处理。
    - 通常状况下，一般是让后台返回的数据利用json以字典形式的字符串进行发送。 return HttpResponse(Json.dumps(字典)) ，前段接收后利用 var obj=json.parse( data ) 进行解析。
  - 当使用ajax时，须要跳转的状况下，能够在接收完后台数据后，利用，location reload（）进行页面刷新、location.href=" "跳转至下一级页面，或者location.replace() 完成页面跳转
- 除了$.ajax ，jquery还支持 $.get , $.port , $.getjson 等方法来提交ajax请求，本质上，其余方法内部是调用了 $.ajax方法，对其中参数进行修改来完成的。

分页操做
- 方式一，直接在视图函数中，对内容进行切分。
  - 1 获取内容列表及其长度
  - 2 设定每页显示的信息的数量，页码显示数量等
  - 3 根据设定的信息数量，切片出显示在当前页的信息
  - 4 根据页码显示的设置，配置显示页码起始，造成标签文本
  - 5 给页码的文本内容，贴上safe， views函数中给文本 mark_safe处理或者在html 用{ |safe} 默认的是不容许传输内容中包括html代码的，防止XSS攻击
    - xss攻击：XSS是一种常常出如今web应用中的计算机安全漏洞，它容许恶意web用户将代码植入到提供给其它用户使用的页面中。好比这些代码包括HTML代码和客户端脚本。攻击者利用XSS漏洞旁路掉访问控制——例如同源策略(same origin policy)。这种类型的漏洞因为被骇客用来编写危害性更大的网络钓鱼(Phishing)攻击而变得广为人知。对于跨站脚本攻击，骇客界共识是：跨站脚本攻击是新型的“缓冲区溢出攻击“，而JavaScript是新型的“ShellCode”。
  - 返回内容设置 renturn render（）
- 方式二，将函数中的处理步骤，封装到模块的类中，实例化后，基于实例化的分页对象作处理。

cookie与session
- cookie 本质上是保存在客户端浏览器上的键值对形式存储的一个文件，明显地下降了服务器端的信息存储压力。注意的是，若是一些敏感信息放在cookie中，那内容会容易被看见
  - 常见应用及方法
    - 在服务端经过用户请求，利用request.COOKIES 获得的是一个字典。能够用 request.COOKIES.get() 或者 request.COOKIES[ ] 取值
    - 给用户返回信息的时候，能够进行cookie设置，例如给用户返回的信息是 response=redirect('/index/') 设置cookie response.set_cookie("key","value") 提交返回信息 return response
  - cookie经常使用参数
    - key 键
    - value 值
    - max_age 设置超时时间（以秒为单位），默认是None 例如， res.set_cookie("user111",'val', max_age=10)
    - expires 超时时间（是datetime类型）例如，设置保持登陆到具体时间点 exp_date = datetime.datetime.utcnow() + datetime.timedelta(seconds= **) res.set_cookie("user111","value",expires=exp_date)
    - path 设置cookie生效路径，默认是“/” 表示根路径，根路径的cookie能够被任何url页面访问
    - domain 默认是None，能够设置cookie生效的域名
    - secure 默认是False，管理https传输
    - httponly 只能http协议传输，没法被JavaScript获取（除非是底层抓包等特殊处理）
    - salt 用于给cookie加密，加密和解密的salt必须一致
  - 利用jquery.cookie插件能够对cookie进行进一步操做
- session是保存在服务器端的键值对文件。
  - session的建立细节，其实是由django自动完成的，由1 生成随机字符串 2 给客户浏览器写入cookie 3 把字符串存到session中 4在随机字符串对应的字典中完成相关内容的设置
  - session是依赖于cookie的
  - session建立，在request中，直接设置。 request.session['username']=user**
  - 在使用session以前，必需要执行一遍migarate。在django中，默认状况下，session是保存在数据库中的
  - 调取session的时候 request.session['username']
  - session经常使用操做和方法
    - request.session['user'] 获取session，键为‘user’的值，不存在，则报错
    - request.session.get('user',None) 获取session，键为‘user’的值，不存在时，返回默认值，这里是None
    - request.session['user']='abc111' session中‘user’ 若是存在，则改，不存在则建立
    - request.session.setdefault('user','abc222') 单纯新建，若是有‘user’，不操做
    - del request.session['user'] 删除键值对‘user’
    - reques.session.clear() 删除当前登陆的session全部信息，注销用
    - request.session.keys()
    - request.session.values()
    - request.session.items()
    - request.session.iterkeys()
    - request.session.itervalues()
    - request.session.iteriterms()
    - request.session.session_key 获取用户的session中随机字符串
    - request.session.clear_expired() 清除session中失效日期小于指定日期的数据，默认是当前时间
    - request.session.exists('session_key') 检查用户session随机字符串，在数据库中是否存在（是否注销）
    - request.session.delete('session_key') 删除当前用户的全部session数据，注销
    - request.session.set_expiry(value) 设置超时时间，默认django的session超时时间是2周
      - 若是value是整数，表示超时时间是读秒
      - 若是是detetime或timedelta，表示具体的超市时间点
      - 若是是0，用户关闭当前浏览器，session失效
      - 若是是None，当前的session的有效期依赖于全局session
  - 配置settings.py引擎配置和通用配置，设置或修改一些默认操做。
    - SESSION_ENGINE='django.contrib.sessions.backends.db' 配置session的引擎，默认即数据库
      - 修改session引擎，至缓存。设置引擎为cache SESSION_ENGINE='django.contrib.sessions.backends.cache' 设置要连接的cache SESSION_CACHE_ALIAS='default' 设置cache的连接 CACHE={ ‘default’：{‘BACKED’:'django.core.cache.backends.memcached.MemcachedCache' 'LOCATION':[IP地址列表] } ‘db1’：{‘BACKED’:'django.core.cache.backends.memcached.MemcachedCache' 'LOCATION':[IP地址列表] } }
      - 修改session引擎，至文件。设置引擎为file SESSION_ENGINE='django.contrib.sessions.backends.file' 设置要保存的文件路径，不设置的话会建立一个临时目录 SESSION_FILE_PATH=os.path.join(BASE_DIR,'cache')
      - 引擎能够设置为数据库+缓存引擎配置为 SESSION_ENGINE='django.contrib.sessions.backends.cache_db' 缓存相关设置连接 + cache设置
      - 能够设置为加密cookie_Session，此时session信息加密保存在客户端引擎配置：SESSION_ENGINE='django.contrib.sessions.backends.signed_cookies'
    - 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失效日期，默认两周即1209600秒
    - SESSION_COOKIE_BROWSER_CLOSE=False 是否关闭浏览器即便得session失效
    - SESSION_COOKIE_REQUEST=False 是否每次请求都从新保存session，默认是不保存
- 中间件 MIDDLEWARE　　　
  - 中间件，也称管道或handler，在settings文件中，本质上是一个继承自 django.utils.deprecation 中的MiddlewareMixin类的　类的集合
  - 中间件的执行过程自上而下，逐一执行每一个中间件的类函数process_request ，若是中间都能经过的话，最终调用views视图函数，收到视图函数的反馈信息之后，再反向逐一执行process_response　若是中间都能经过的话，最后将信息反馈给发起请求的客户。若是在某一步的process_requestt或process_response 中出现异常，或不能经过，会按照不一样版本的具体要求（有的版本会在本层次直接返回，有的版本会跳转到最后一层中间件的process_response而后返回），逐层逐层反馈最后将信息发回请求发起端。　　　　　　　　　
  - 中间件的实用性极高，通常用于对整个函数系统的同一设置或限制
  - 使用自定义中间件，过程
    - 首先，建立包，构建中间件的py文件
    - 在py文件中，从django.utils.deprecation 中导入MiddlewareMixin，而后根据须要继承MiddlewareMixin构建自定义中间件的类和函数
    - 最后，在settings的MIDDLEWARE中注册自定义的中间件
  - 中间件中经常使用的基本方法有　
    - process_request(sef,request) *****
    - process_view(self,request,callback,callback_args,callback_kwargs) *****
    - process_template_response(self,request,response) *
    - process_exception(self,request,exception) ***
    - process_response(self,request,response)　 *****
缓存
- 实际上大部分web框架中是没有缓存的。但django支持缓存，因为django是动态web框架，每次请求都会去进行相应操做，当程序访问量大时压力明显，最简单的方式就是利用缓存。在django中支持的缓存方式包括测试缓存、内存缓存、文件缓存、数据库缓存以及经过memcache使用远程机器缓存。不一样的缓存形式的配置，基本上是以修改缓存引擎为主。
- 缓存的5中配置方式：
  - 测试缓存
  - 内存缓存
  - 文件缓存
  - 数据库缓存
  - memcache缓存
  - 缓存的其余配置（通用配置）
- 缓存的3中常见应用，使用的优先级能够经过请求生命周期来理解，全站缓存优于视图函数缓存优于局部缓存，
  - 全局缓存
  - 视图函数缓存
  - 模板中局部缓存
- 缓存参考：www.cnblogs.com/wupeiqi/articles/5246483.html
信号　　　　
- 信号的功能及应用场景
- 内置信号
  - 内置信号类型
  - 内置信号的使用
    - 建立py文件，导入内置信号，信号触发动做、函数构造及设置，py文件导入__init__文件自动加载
- 自定义信号　　　　　
  - 1 定义信号
    - 引入 django.dispatch
    - 实例化自定义信号信号名=dijango.dispatch.Signal(providing_args=["toppings","size"]) 括号中为必要的触发参数，能够自定义
  - 2 注册触发信号设置
    - 定义触发动做、函数
    - 在视图函数views中，从py文件里导入自定义的信号
    - 手动触发信号，信号名.send(sender=" ",toppings=参数1，size=参数2)
  - 3在信号中注册函数（定义、优化触发动做、函数）

django中的 Form 组件

form组件参考 https://www.cnblogs.com/wupeiqi/articles/6144178.html
django的form组件，使用时，是以继承forms.Form类，来自定义form类。

其中，类里面能够定义字段（主要功能，建立前端输入区域、输入内容格式验证），基本语法，字段=fields.字段类型（参数设置，插件设置，错误提示）

经常使用字字段有： Charfield,RegexField,IntegerField,EmailField
经常使用参数有：required=True/False 设置是否能够为空； max_length最大长度； min_length 最短长度； label 设置label ； disabeld=False/True 设置是否可编辑； label_suffix 设置label内容后缀； help_text 帮助提示信息

主要内置字段和经常使用参数：

  1 Field
  2     required=True,               是否容许为空
  3     widget=None,                 HTML插件
  4     label=None,                  用于生成Label标签或显示内容
  5     initial=None,                初始值
  6     help_text='',                帮助信息(在标签旁边显示)
  7     error_messages=None,         错误信息 {'required': '不能为空', 'invalid': '格式错误'}
  8     show_hidden_initial=False,   是否在当前插件后面再加一个隐藏的且具备默认值的插件（可用于检验两次输入是否一直）
  9     validators=[],               自定义验证规则
 10     localize=False,              是否支持本地化
 11     disabled=False,              是否能够编辑
 12     label_suffix=None            Label内容后缀
 13  
 14  
 15 CharField(Field)
 16     max_length=None,             最大长度
 17     min_length=None,             最小长度
 18     strip=True                   是否移除用户输入空白
 19  
 20 IntegerField(Field)
 21     max_value=None,              最大值
 22     min_value=None,              最小值
 23  
 24 FloatField(IntegerField)
 25     ...
 26  
 27 DecimalField(IntegerField)
 28     max_value=None,              最大值
 29     min_value=None,              最小值
 30     max_digits=None,             总长度
 31     decimal_places=None,         小数位长度
 32  
 33 BaseTemporalField(Field)
 34     input_formats=None          时间格式化   
 35  
 36 DateField(BaseTemporalField)    格式：2015-09-01
 37 TimeField(BaseTemporalField)    格式：11:12
 38 DateTimeField(BaseTemporalField)格式：2015-09-01 11:12
 39  
 40 DurationField(Field)            时间间隔：%d %H:%M:%S.%f
 41     ...
 42  
 43 RegexField(CharField)
 44     regex,                      自定制正则表达式
 45     max_length=None,            最大长度
 46     min_length=None,            最小长度
 47     error_message=None,         忽略，错误信息使用 error_messages={'invalid': '...'}
 48  
 49 EmailField(CharField)      
 50     ...
 51  
 52 FileField(Field)
 53     allow_empty_file=False     是否容许空文件
 54  
 55 ImageField(FileField)      
 56     ...
 57     注：须要PIL模块，pip3 install Pillow
 58     以上两个字典使用时，须要注意两点：
 59         - form表单中 enctype="multipart/form-data"
 60         - view函数中 obj = MyForm(request.POST, request.FILES)
 61  
 62 URLField(Field)
 63     ...
 64  
 65  
 66 BooleanField(Field)  
 67     ...
 68  
 69 NullBooleanField(BooleanField)
 70     ...
 71  
 72 ChoiceField(Field)
 73     ...
 74     choices=(),                选项，如：choices = ((0,'上海'),(1,'北京'),)
 75     required=True,             是否必填
 76     widget=None,               插件，默认select插件
 77     label=None,                Label内容
 78     initial=None,              初始值
 79     help_text='',              帮助提示
 80  
 81  
 82 ModelChoiceField(ChoiceField)
 83     ...                        django.forms.models.ModelChoiceField
 84     queryset,                  # 查询数据库中的数据
 85     empty_label="---------",   # 默认空显示内容
 86     to_field_name=None,        # HTML中value的值对应的字段
 87     limit_choices_to=None      # ModelForm中对queryset二次筛选
 88      
 89 ModelMultipleChoiceField(ModelChoiceField)
 90     ...                        django.forms.models.ModelMultipleChoiceField
 91  
 92  
 93      
 94 TypedChoiceField(ChoiceField)
 95     coerce = lambda val: val   对选中的值进行一次转换
 96     empty_value= ''            空值的默认值
 97  
 98 MultipleChoiceField(ChoiceField)
 99     ...
100  
101 TypedMultipleChoiceField(MultipleChoiceField)
102     coerce = lambda val: val   对选中的每个值进行一次转换
103     empty_value= ''            空值的默认值
104  
105 ComboField(Field)
106     fields=()                  使用多个验证，以下：即验证最大长度20，又验证邮箱格式
107                                fields.ComboField(fields=[fields.CharField(max_length=20), fields.EmailField(),])
108  
109 MultiValueField(Field)
110     PS: 抽象类，子类中能够实现聚合多个字典去匹配一个值，要配合MultiWidget使用
111  
112 SplitDateTimeField(MultiValueField)
113     input_date_formats=None,   格式列表：['%Y--%m--%d', '%m%d/%Y', '%m/%d/%y']
114     input_time_formats=None    格式列表：['%H:%M:%S', '%H:%M:%S.%f', '%H:%M']
115  
116 FilePathField(ChoiceField)     文件选项，目录下文件显示在页面中
117     path,                      文件夹路径
118     match=None,                正则匹配
119     recursive=False,           递归下面的文件夹
120     allow_files=True,          容许文件
121     allow_folders=False,       容许文件夹
122     required=True,
123     widget=None,
124     label=None,
125     initial=None,
126     help_text=''
127  
128 GenericIPAddressField
129     protocol='both',           both,ipv4,ipv6支持的IP格式
130     unpack_ipv4=False          解析ipv4地址，若是是::ffff:192.0.2.1时候，可解析为192.0.2.1， PS：protocol必须为both才能启用
131  
132 SlugField(CharField)           数字，字母，下划线，减号（连字符）
133     ...
134  
135 UUIDField(CharField)           uuid类型
136     ...

View Code

插件设置，经常使用格式例如，widget=widgets. PasswordInput(attrs={'class':'c01'}) widget=widgets.Textarea(attrs={'class:c002'}) widget=widgets.Select(choices=models.Classes.objects.values_list('id','title'))ajax

主要插件

 1 TextInput(Input)
 2 NumberInput(TextInput)
 3 EmailInput(TextInput)
 4 URLInput(TextInput)
 5 PasswordInput(TextInput)
 6 HiddenInput(TextInput)
 7 Textarea(Widget)
 8 DateInput(DateTimeBaseInput)
 9 DateTimeInput(DateTimeBaseInput)
10 TimeInput(DateTimeBaseInput)
11 CheckboxInput
12 Select
13 NullBooleanSelect
14 SelectMultiple
15 RadioSelect
16 CheckboxSelectMultiple
17 FileInput
18 ClearableFileInput
19 MultipleHiddenInput
20 SplitDateTimeWidget
21 SplitHiddenDateTimeWidget
22 SelectDateWidget

View Code

经常使用选择插件设置距离

 1 # 单radio，值为字符串
 2 # user = fields.CharField(
 3 #     initial=2,
 4 #     widget=widgets.RadioSelect(choices=((1,'上海'),(2,'北京'),))
 5 # )
 6  
 7 # 单radio，值为字符串
 8 # user = fields.ChoiceField(
 9 #     choices=((1, '上海'), (2, '北京'),),
10 #     initial=2,
11 #     widget=widgets.RadioSelect
12 # )
13  
14 # 单select，值为字符串
15 # user = fields.CharField(
16 #     initial=2,
17 #     widget=widgets.Select(choices=((1,'上海'),(2,'北京'),))
18 # )
19  
20 # 单select，值为字符串
21 # user = fields.ChoiceField(
22 #     choices=((1, '上海'), (2, '北京'),),
23 #     initial=2,
24 #     widget=widgets.Select
25 # )
26  
27 # 多选select，值为列表
28 # user = fields.MultipleChoiceField(
29 #     choices=((1,'上海'),(2,'北京'),),
30 #     initial=[1,],
31 #     widget=widgets.SelectMultiple
32 # )
33  
34  
35 # 单checkbox
36 # user = fields.CharField(
37 #     widget=widgets.CheckboxInput()
38 # )
39  
40  
41 # 多选checkbox,值为列表
42 # user = fields.MultipleChoiceField(
43 #     initial=[2, ],
44 #     choices=((1, '上海'), (2, '北京'),),
45 #     widget=widgets.CheckboxSelectMultiple
46 # )
47 在使用选择标签时，须要注意choices的选项能够从数据库中获取，可是因为是静态字段 ***获取的值没法实时更新***，那么须要自定义构造方法从而达到此目的。

View Code

异常信息设置， error_message={异常信息:反馈内容} 例如，error_message={'required':'信息不能为空'，‘min_length’:'不能小于长度** '，‘max_length’:' 长度不能超过** '}
在定义的视图函数中，实例化定义的form类
- 把实例化的form对象obj（能够不传任何参数进去，此时新建空表，也能够先定义一个字典，键取自定义的form类值为设定的初始化值，而后把字典用initial实例化对象的时候传进去，这样创建的表单里会有初始化的默认值），render回前端，可生成form表单
  - 前端的html中，能够经过替换obj中的字段，生成表单内容，能够把出错的提示信息放一块，例如， <p> {{obj.user}} {{obj.errors.user.0}} </p>
  - 也能够进一步简化，不单独替换具体字段，而是用obj对象的方法 {{obj.as_p}} 、 {{obj.as_ul}} 或者 <table> {{obj.as_table}}</table>
- 实例化对象，把request.POST 传进去，可用对象验证输入信息、接收验证信息，并返回对应的错误信息
  - 此时 obj.is_valid() 可验证数据是否全都有效合法， obj.clean_data 可接收前端传过来的信息，以字典形式存储 obj.errors 可搜集错误信息，总体以字典形式存储，字段为键，对应的错误信息以列表形式存储做为字典的值
  - 若是， obj.is_valid() 数据经过验证即为True，根据须要选择反馈内容；若是是False，则render的时候，把obj直接传回去，这时，obj中既有前端以前的输入信息，也有错误信息和对应的提示内容

验证重要节点，
- is_valid——》每一个字段的内置正则+clean_字段——》clean（__all__）——》_post_clean　　
- clean_data
- errors

ModelForm
- model+form，能够实现验证也同时能够数据操做　　
- 基本功能
  - 生成html标签：class Meta：
  - 页面显示，生成时带默认值。在建立时， mf = ***ModelForm(instance=ModelObj)
  - 加额外的标签或定制字段， is_rmb = Ffields.CharField(widget=Fwidgets.CheckboxInput())
  - 各类验证 is_valid() …… ，相似于form中的验证节点
  - 保存，直接 mf.save() ，或者 instance = mf.save(False) instance.save() my.save_m2m()