Django详解

Django
一、Django简介
1.什么是Django
Django是一个开源框架,2005年发布,采用Python语言编写的早期主要是做新闻和内容管理的
Django本身提供了非常强大的后台管理系统
Django版本:2.1.4
使用:1.11.8
官网:http://www.djangoproject.com
中文文档:http://www.djangobook.py3k.cn
http://djangobook.py3k.cn/2.0/
2.框架模式
MTV
M: Models
T: Template
V: Views
3.Django的安装
1.查看已安装的Django版本
1.进入到终端以及Python交互模式
交互模式:python3 / ipython3
2.交互模式中输入:import django
1.如果未报错:当前环境中已经安装django
2.如果报错:没有django
3.查看版本
1.交互模式中:django.VERSION
4.安装django
1.在线安装:
pip3 : 安装到python3
pip : 安装到python2下

        sudo pip3 install django(默认安装DJango的最先版本)
        sudo pip3 install django==1.11.8(指定按照Django的1.11.8)
      2.离线安装
        1.下载安装包
        2.sudo pip3 install Django-1.11.8.tar.gz
4.Django框架的使用
  1.创建Django项目
    使用django-admin创建django项目
    语法:django-admin startproject 项目名
  2.项目的结构介绍
    1.manage.py
      包含执行django中的各项操作的指令(子命令)
        如: 
          启动服务: runserver
          创建应用:
          创建后台管理员:
          ... ...
    2.主目录(与项目名称一致的目录)
      1.__init__.py
        初始化文件,服务启动时自动运行
      2.urls.py
        项目的基础url配置文件(基础的路由配置)
      3.wsgi.py
        Web Server Gateway Interface
        Web  服务    网关      接口
      4.settings.py
        项目的主配置文件,启动服务时自动运行
        1.BASE_DTR : 获取当前项目的绝对路径
        2.DEBUG :是否启用调试
           True    : 启动调试模式(开发环境中使用)
           False   : 不启用调试(生产环境使用)
    3.ALLOWED_HOSTS
        设置允许访问到本项目的地址列表
        如果为空的话,表示只有本机(127.0.0.1/localhost)才能访问

        如果允许在局域网内被其他机器访问的话:推荐写['*'],表示任何能够表示该机器的地址都能够访问到当前项目
        如果允许被其他机器访问的话,启动服务时必须使用以下方式:
        ./manage.py runserver 0.0.0.0:端口号
    4.INSTALLED_APPS
        指定已安装的应用，如果有自定义应用的话，必须要再此注册
    5.NIDDLEWARE
        指定中间件信息
    6.TEMPLATES
        指定模板配置
    7.DATABASES
        指定数据库
    8.LANGUAGE_CODE
        语言设置，如果需要中文的话，允许更改为zh-Hans
    9.TIME_ZONE
        指定时区，如果指定中国时区的话，允许更改为"Asia/Shanghai‘
 二、django基本结构
 	1.url的使用
1.urls.py
    1.主路由配置文件，默认会在主目录中包含最基本的地址映射
    作用、：通过urls中定义好的地址找到对应的视图处理函数

    from django.conf.urls import url 
    from django.contrib import admin


    urlpartterns = [
        url(r'^admin/',admin.site.urls),
    ]
    2.url()的语法规范
        作用：匹配用户的访问路径，交给对应的视图处理程序
        语法：
            from django.conf.urls import url
            url(regex,views,kwargs=None,name=None)
                1.regex：允许是正则表达式，匹配请求的url
                2.views：对应的视图处理函数名
                3.kwargs:字典，用来向views传参
                4.name：为url起别名，在地址反向解析时使用
    3.通过url函数向视图传参的
        http://localhost:8000/show/2018
        http://localhost:8000/show/2015
        http://localhost:8000/show/2017

        1.使用正则表达式传参
            使用正则表达式的子组传参 -(),一个子组就是一个参数，多个参数的话要使用多个子组表示，并且中间使用/隔开

            url(r'^show/(\d{4}/$)',show1_views),
            练习：
                访问地址：/show/思维数字/两位数字/两位数字
                在网页中输出：生气为xxxx年xx月xx日
        2.通过 kwargs 参数传参
            dic={
                'name':'wangwc',
                'age':18,
            }
            url(r"^show/$",show3_views,dic)

            def show3_views(request,name,age):
                pass

2.django中的应用
1.什么是应用
应用就是网站中的一个独立的程序模块
在Django中，主目录一般不处理用户的具体请求，主目录主要做项目的初始化配置以及请求的分发(分布式请求处理),具体请求
是由哥哥应用去处理的
2.创建应用
1.manage.py指令创建
./manage.py startapp 应用名称

        例：
            ./manage.py startapp news
    2.在 settings.py 中进行注册
        在 INSTALLED_APPS中追加应用名称即可
        INSTALLED_APPS = [
            ... .....
            '应用名称',
        ]
3.应用结构组成
    1.migraions文件夹
        存放数据库中间的文件
        与模型相关
    2.__init__
        应用的初始化文件
    3.admin
        应用的后台管理配置文件
    4.app 
        应用额属性配置文件
    5.models
        模型的映射文件
    6.tests
        应用的单元测试文件
    7.views 
        定义视图处理函数的文件
4.分布式路由器系统（请求地址分发）
    在每个应用中都创建一个 urls.py结构参考主目录的urls.py
    当访问路径时 http://localhost:8000/music/xxx
    交给music的urls做进一步处理

    当访问路径是 http://localhost:8000/sport/xxx
    则交给sport的urls做进一步处理

练习：
    1.访问路径 http://localhost:8000 /login
        交给 index 应用中的 login_views 视图去处理
    2.访问路径 http://localhost:8000/register
        交给 index 应用中的 register_views 视图去处理
    3.访问路径http://localhost:8000/
        交给 index 应用中的index_views视图去处理

3.django中的模板(templates)
1.什么事模板
模板就是要动态呈现给用户的网页-前后端结合的网页
Django的模板引擎是由django自己提供的，并不是jinjia2，
所以django的模板语法与Flask(jinja2)的语法会有一些不同
2.模板的设置
在setting.py中，有一个人TEMPLATES 变量
1.BACKEND:指定要使用的模板引擎
2.DIRS：指定模板的存放目录们
1.什么都不写：Django会自动的到每个应用总中搜索一个叫做templates的目录来作为模板的存放目录
2.如果写东西，则按照写好的路径去搜索
3.APP_DIR:是否要自动搜索应用中的templates目录
True：表示要搜索
False：表示不搜索
3.模板的加载方式
1.通过loader的对象获取模板，再通过HttpResponse进行响应
from django.templates import loader
#1.通过loader加载模板
t = loader.get_template(‘模板名称’)
#2.将模板渲染成字符串
html = t.render()
#3.将字符串通过HttpResponse响应给客户端
return HttpResponse(‘html’)
2.通过render()加载并响应模板
from django.shortcuts import render

        return render(request,'模板名称')
4.模板中的语法规范
    1.变量
        1.作用:将后端的数据传递给模板显示
        2.在Django中允许作为变量传递给模板的数据类型
            字符串，整数，列表。元组，字典，对象
        3.变量的语法
            1.变量们必须要封装到字典中才能传递给模板
                dic = {
                    'name':'wangwc',
                    'age':30,
                    'gender':'男'
                }
                1.loader加载模板
                    t = loader.get_template('xxx.html')
                    html = t.render(dic)
                    return HttpResponse(html)
                2.使用render加载模板
                    return render(request,"xxx.html",dic)
            2.在模板中使用变量
                {{变量名}}
      1.模板
1.模板中的语法：
    1.语法：
    2.标签
        1.作用：
            将服务器端功能嵌入到模板中
        2.语法：
            {% 标签内容 %}
        3。常用标签
            1.for 
                语法：
                    {% for 变量 in元组|列表|字典 %}
                    {% endfor %}

                内置变量：forloop
                    允许通过forloop得到本次循环的一些信息
                    for.counter :当前循环遍历的次数
                    for.first :判断是否为第一次循环
                    forloop/last:判断是否为最后一次循环
            2.if 
                语法：  
                    1.
                    {% if xxx %}
                    {% endif %}
                    2.
                    {% if xxx %}
                    {% else %}
                    {% endif %}
                    3
                    {% if xxx %}
                    {% elif xxx%}
                    {% else %}
                    {% endif %  }

                练习：
                在模板中循环遍历，第一项的内容北京颜色为红色
                最后意向的内容为
        3.过滤器
            1.什么是过滤器
                在变量输出显示之前，要对变量进行筛选和过滤
            2.语法： 
                {{变量|过滤器：参数}}
        4.静态文件的处理
            1.静态文件
                不能被解释器动态解析的文件就是静态文件
            2.Django中的静态文件的处理
                (Django中必须要设置讲台文件相关信息之后才能使用)
                在settings.py中设置静态文件相关信息
                1.设置静态文件的访问路径
                    STATIC_URL = '/static/'
                    如果访问路径是http://localhost:8000/static/xxx的时候,那么就到静态文件的存储目录中去查找静态文件而不走路由的解析
                2.设置静态文件的存储路径
                    指定静态文件保存在服务器上的哪个文件夹中
                    STATICFILES_DIRS=(os.path.join(BASE_DIR,'static'))
                    静态文件目录存放位置
                    1.在项目的根据目录出创建一个static目录，用于保存静态文件
                    2.每个应用中也可以创建一个static目录，用于保存静态文件的继承
                3.访问静态文件
                    1.通过静态文件访问路径去访问
                        /static/images/naruto.jpg

                    2.使用{% static %}访问静态资源
                        {% static%}表示的就是静态文件资源的访问路径
                        1.在模板的最顶层增加
                            {% load static %}
                        2.在使用静态资源时
                            <img src="{% static 'images/naruto.jpg'%}
                练习：  
                    1.创建项目-Fruitday，并创建应用index
                    2.搭建模板和静态文件
                    3.搭建首页末班 - index.html
                    4.设置静态文件的相关配置
                    5.将index.html的静态文件改成Django版本
        5.模板的继承
            1.在父模板中
                标识出那些内容在子模板中允许被重写
                {% block 块名 %}
                        xxxxxx
                {% endblock %}
                block作用：
                    1.在父模板中正常显示
                    2.在子模板中，允许被修改
                        如果不修改的话，则按照父模板的内容来显示
            2.在子模板中
                1.指定继承自哪个父模板
                    {% extends '父模板名称'%}
                2.覆盖父模板中的内容
                    {% block 块名%}
                    {% endblock %}
        6.url()的name参数
            1.url(regex,views,kwargs,name)
                name:为了给当前的url起别名，在反向解析地址时使用
            2.反向解析
                通过url()的别名生成对应的访问地址
                1.在模板上做反向解析
                    1.基本解析
                        {% url "别名 "%}
                    2.带参数的解析
                        {% url "别名" "参数1" ....%}
                2.在视图上做反向解析
                    1.基本解析
                        url = reverse('别名')
                        url 就是通过别名解析出来的地址
                    2.带参解析
                        url = reverse('别名'，args=('参数1','参数2'))

什么是模型
根据数据库表结构而创建出来的class
ORM:（ORM框架是不同的，但是类－表-字段之间的关系原理相似）
三大特征：
数据表到编程类的映射
数据类型的姓社
关系映射
3.创建 和 配置数据库
1.创建数据库
create database webdb default charset utf8 collate utf8_general_ci;
2.Django中的数据库配置
settings.py 中 DATABASES 变量负责数据库配置数据库信息
DATABASES = {
‘default’: {
‘ENGINE’: ‘django.db.backends.sqlite3’,
‘NAME’: ‘webdb’,
}
}
1.ENGINE：指定连接到的数据库的引擎
‘django.db.backends.mysql’,
2.NAME：指定要连接的数据的名称
‘webdb’
3.USER:指定进入到的数据库的用户名
取值：‘root’
4.PASSWORD:指定进入到数据库的密码
取值：‘123456’
5.HOST：指定要连接的主机地址
取值：‘localhost’ 或者 ‘127.0.0.1’
6.PORT :指定主机上开放的端口
取值：3306
注意：Django中的ORM依赖于muysqldb在初始化项目的时候
import pymysql
pymysql.install_as_mysqldb()
三、
1.Models - 模型
1.数据库的同步操作
1. ./manage.py makemigrations
作用：将每个应用下的models.py文件生成一个数据库中间文件，并将中间文件保存在migrations的目录中
1.models.py中必须有内容
2.较上一次的执行必须有改动
满足以上两个条件，则可以生成中间文件
2. ./manage.py migrate
作用：将每个应用中的migrate目录中的中间文件同步回数据库

2.编写models
    1.举个例子
        在index应用中的models.py中
        # 创建一个实体类 - Publisher 表示"出版社"
        1.name：出版社名称 - varchar 
        2.address：表示出版社地址  - varchar
        3.city：出版社所在城市 - varchar
        4.country：出版社所在国家   - varchar
        5.website：出版社网址 - varchar
    2.创建models的语法规范
        属性 = models。字段类型(字段选项)
        字段类型：映射到数据库表中的数据类型
            CharField() - varchar(允许自定义长度)
            URLField() - varchar(长度默认为200)
            字段选项：指定生成的字段的说明信息
                max_length = 30
        AutoField                           自增长的数据类型
        BigAutoField                        大数组自增长
        BigIntegerField                     大整型
        BinaryField                         二进制
        BooleanField                        布尔
        CharField                           varchar
        DateField                           
        DateTimeField                       
        DecimalField
        DurationField
        EmailField
        FileField
        FileField and FieldFile
        FilePathField
        FloatField
        ImageField
        IntegerField
        GenericIPAddressField               ip地址
        NullBooleanField
        PositiveIntegerField
        PositiveSmallIntegerField
        SlugField
        SmallIntegerField
        TextField
        TimeField
        URLField
        UUIDField
        常用的字段类型：
        1.BooleanField()
            编程语言中使用True or False
            在数据库中用0和1来表示
            数据库中的类型为：tinyint
        2.CharField()
            编程-----》字符串
            数据库---》varchar
        3,。dateField()
            编程-----》字符串或date
            数据库---》date
        4.DateTimeField()
            编程-----》同上
            数据库---》DateTime
        5.DecimalField()
            编程 ----》数字表示该列的值
            数据库---》decimal 
            money = models.DecimalField(max_digits = 7,decimal=2)
           
        6.FloatField()
            数据库---》float
        7.IntegerField()
            数据库---》int
        8.EmailField()
            编程---》字符串
            数据库---》varchar
        9.URLField()
            编程：字符串
            数据库：varchar
        10.ImageField()
            作用：存储的是图片的路径
            数据库中使用：varchar


    字段选项
        1.null 
            作用：指定当前字段是否允许为空，默认为False，不能为空
        2.default
            作用：指定当前字段的默认值
        3.db_column
            作用：指定当前字段映射得到数据库中列的名字，如果不指定的话则采用当前属性名为列表
        4.db_index
            作用：指定当前字段创建索引，True则添加索引
        5.verbose_name
            作用：为当前字段指定后台显示的别名
    练习
        在index应用中的models.py中追加两个class
        1.Author - 作者
            1.name 
            2.age
            3email(允许为空)
        2.Book 
            1.title
            2.Publicate——date
        3.模型中的CRUD
            1.增加数据
                1.使用Entry.objects.create(属性=值，属性=值)
                    Entry：可以表示任意一个实体类
                    返回值：将创建好的实体对象进行返回
                2.创建Entry对象，并通过对象.save()进行保存
                    obj = Entry(属性=值，属性=值)
                    obj.属性=值
                    obj.save()
                    注意：该方法无返回值，obj会被重新复制
                3.使用字典创建对象，并通过save()进行保存
                    dic = {
                        '属性'：'值'，
                        '属性'：'值'，
                    }
                    obj.Entry(**dic)
                    obj.save()
2查询数据(重点)
    查询通过Entry.objects.all()属性调用查询接口

    所有的查询接口后面，都可以通过一个query属性来得到对应的sql语句
    1。基本的查询结果
        语法：all()
        用法：Entry.objects.all()
        返回：QuerySet
    2.查询返回指定列
        语法：values() | values('列1','列2')
        用法：
        Entry.objects.values('列1','列2')
        Entry.objects.all().values('列1','列2')
        返回：QuerySet，会将查询出来的部分列封装到字典中在封装到列表中
    3.查询返回指定列    
        语法：values_list('列1'，'列2')
        用法：同上
        返回：QuerySet,会将查询出来的部分列封装到元组中再封装到列表中
    4.只查询一条数据
        语法：get(条件)
        作用：查询只能返回一条数据
        用法：Entry.objects.get('条件')
        注意：
            该方法只能返回一条数据
            查询结果多余一条或没有查询结果的话都会抛出异常
    5.根据条件查询部分行数据
        语法：filter(条件)
        用法：Entry.objects.filter()
        返回：QuerySet
        1.查询id为1的book的信息
            list = Book.objects.filter(id=1)
        2.查询publicate_date为2015-10-12的book  
            list = Book.objects.filter(publicate_date='2015-10-12')
        3.查询id为1并且publicate_date为2015-10-12的book的信息
            Book.objects.filter(id=1,publicate_date='2015-10-12')
        如果需要非等值条件查询，可以使用Django提供的查询谓词来实现
        Entry.objects.filter(属性_谓词=值)
    6.做不等条件筛选
        语法：exclude(条件)
        用法：Entry.objects.exclude(条件)
    7.排序查询
        语法：order_by()
        用法：Entry.objects.order_by('列','-列')
            默认是升序排列，如果想要降序则在列名前添加 - 号即可
    8.聚合查询(不带分组)
        语法：aggregate()
        用法：Entry.objects.aggregate(名=聚合函数('列'))
            聚合函数：
                avg sum min max count
    9.聚合查询(带分组聚合)
        语法: annotate()
        用法:Entry.objects.values('分组列名').annotate(列=聚合函数()).values('查询列名')

四、
1.ORM 操作 CRUD
1.增加
2.查询
3.修改
1.查询
得到查询实体对象/QuerySet

    2.改
        通过对象的属性修改对象的值
    3.保存
        实体对象：调用 save()
        QuerySet 的 update(属性 = 值，属性 = 值) 能实现批量修改  
        改+保存
4.删除
    1.删除单个对象
        au = Author.objects.get(id=1)
        au.delete()
    2.批量删除对象
        list = Author.objects.all()
        list.delete()
5.F 查询和 Q 查询
    1.F查询
        Author表中所有人的年历+10岁
        1.作用：
            在执行过程中获取某列的值
        2.语法
            from django.db.models import F 
            Django:
                Author.objects.all().update(age = F('age')+10)
    2.Q查询
        1.查询id=1 并且 isActive=True de isActive为True的Author们的信息
            Author.objects.filter(id=1,isActive=True)
        2.查询id=1 或者 isActive=True de isActive为True的Author们的信息
            1.作用：
                在条件中充当或(or)的实现方式
            2.语法
                from django.db.models import Q
                Q(条件1)|Q(条件2)
                Author.objects.filter(Q(id=1)|Q(isActive=True))
6.原生的数据库操作办法
    1.查询id
        函数：raw()
        语法：Entry.objects.raw(sql)
        返回：QuerySet

    2.增删改
        from django.db import connection

        def doSQL(request):
            with connection.cursor() as cursor
            sql = 'update/insert/delete...'
            cursor.execute(sql)
            return ...

2.使用后台管理models models
1.后台配置
登陆地址:http://localhost:8000/admin
创建后台管理员：
./manage.py createsuperuser
username:输入用户名，如果为空，则采用系统账户登录名
Email Address ：电子邮件，允许为空
Password:密码
Password(agian):
2.基本的后台管理
1.在应用中的admin.py中注册要管理的实体类
1.admin.py
作用：注册需要管理的Models类，只有在此注册的Models类才允许被管理
2.注册models
from .models import *
admin.site.register(Entry)
2.通过Models类的内部类Meta来定义其展现形式
class Author(models.Model):
…
class Meta:
1.db_table
指定该实体类映射到表的名字
(该属性设置完成后需要同步回数据库)
2.verbose_name
定义实体类在 admin 中显示的名字(单数)
3.verbose_name_plural
定义实体类在 admin 中显示的名字(复数)
4.ordering
指定数据在后台管理界面中的排序方式
取值是一个列表，将排序的列表显示在列表中
默认是升序，降序使用 - 号
3.高级管理
1.在 admin.py中创建高级管理类并注册
1.定义 EntryAdmin 类 继承自 admin.ModelAdmin
class AuthorAdmin(admin.ModelAdmin):
pass
2.注册高级管理类
admin.site.register(Entry,EntryAdmin)
2.在EntryAdmin中增加的属性
1.list_display
作用：定义在列表页上要显示的字段们
取值：由属性名组成的列表或元组
2.list_display_links
作用：定义在 列表页上点击也能够跳转到详情页上的字段们
取值：同上
3.list_editable
作用：定义在列表页上就允许被编辑的字段们
取值：同上
注意：list_editable取值必须要出现在
list_display中，但不能出现在list_display_links
4.search_fields
作用：添加允许被搜索的字段们
取值：同上
5.list_filter
作用：在列表页的右侧增加过滤器，实现快速筛选
取值：同上
6.date_hierarchy
作用：在列表页的顶部增加时间选择器，取值必须为
DateField / DateTimeField
7.fields
作用：在详情页中指定显示那些字段以及他们的顺序
取值：由属性名组成的元组或列表
8.fieldsets
作用：在详情页中对字段进行分组显示
取值：
fieldsets = (
# 分组1，
(‘分组名称’,{
‘fields’?‘属性1’,‘属性2’)
‘classes’?‘collapse’,)
})
# 分组2，
)
注意：不能和fields同时声明
3.关系映射
1.一对一映射
1.语法：
关联的两个类中的任意一个类中：
属性 = models.oneToOneField(Entry)

    class Author(Models.Model):
        .... ....
    class Wife(models.Model):
        ... ...
        # 增加对 Author 一对一的引用
        author = models.oneToOneField(Author)

    在数据库中：
        生成一个外键列(author_id)在Wife表中，并且会应用在Athor表中的主键
    在Author实体中
        会增加一个隐式属性 - wife，用来表示 author 所对应的wife
2.查询
    1.正向查询：直接通过关联属性查询
        通过wife 找 author
        wife = Wife.objects.get(id=1)
        author = wife.author
    2.反向查询：通过隐式属性查找
        通过author 查找wife
        author=Author.objects.get(id=1)
        wife = author.wife 

五、
1.关系映射
2.一对多映射
1.数据库中实现
在“多”表中增加外键表示对“一”表的主键引用
2.Django中体现
在"多"实体类中增加对‘一’实体类引用

    语法：
        entry = models.ForeignKey(Entry)

    class Publisher(models.Model):
        xxxx xxxx

    class Book(models.Model):
        XXXX XXXX
        Publisher = models.ForeignKey(Publisher)
    注意：
        在Publisher中会增加一个隐式属性 - book_set,表示的是对Book的一个查询(等同于Book.objects)
        1.查询 id 为 1 的Publisher对应的所有数据
            publisher = publisher.objects.get(id=1)
            publisher.book_set.all()
        2.查询id为1的publisher对应的id为1的数据
            publisher = publisher.objects.get(id=1)
            publisher.book_set.filter(id=1)

3.多对多
1.数据库中体现
通过第三张表去关联多堆多两张表
2.语法：
在关联的两个类中的任意一个类，增加：
属性 = models。ManyToManyField(Entry)
class Author(models.Model):
XXX XXX
class Book(models.model):
xxx xxx
author_set = models.models.ManyToManyField(Author)

在Book中，通过author_set 舒缓型鸟事对应所有的Author的查询

在Author中，程序会增加一个隐式属性book_set，表示对应的所有的Book的查询

2.HttpRequest - 请求
1.什么是HttpRequest
HttpRequest。在Django中就是对请求对象的封装体现，里面封装了所有和请求相关的信息，在Django中，
HttpRequest被封装成了request对象，并封装到视图处理函数作为参数，在调用视图的时候会自动转入
2.HttpRequest中的主要内容
1.resquest.scheme:请求协议
2.resquest.body:请求体
3.resquest.path:请求路径
4.resquest.get_host():请求主机地址/域名
5.resquest.method:获取请求方法
6.resquest.GET:封装了get请求方式所提交的数据
7.resquest.POST:封装了post请求方式所提交的数据
8.resquest.COOKIES:封装了cookies中所有的数据
9.resquest.META:封装了请求的元数据
resquest.META.HTTP_REFERER:封装了请求地址
3.获取请求提交的数据
1.get请求方式
resquest.GET[‘名称’]
resquest.GET.get(‘名称’)
resquest.GET.getlist(‘名称’)

        1.使用表单提交
            <form method='get'>
                <input type='text'>
                <input type='submit'>
            </form>
        2.地址栏访问都是get方式提交
            1.<a href="/xxxx/?uname=xxxx"></a>
            2.JS地址栏提交
                location.href="/xxx/?uname=xxxx"
        url(r'^get_process/(\d{4}/)',xxx_views)
        http://localhost:8000/get_process/2018

        注意：以上方式不能是由request.GET进行接收，以为以上方式属于Django的标准而并非HTTP标准

        练习：
            1.访问/02-login/
            2.如果是get请求的话，使用表单表示以下内容
                用户名   文本框
                密码     密码框
                提交按钮
    2.post请求方式
        使用request.POST['名称']
        request.POST.get()
        request.POST.getlist()

        CSRF: Cross Site Request Forgery
              跨     站点   请求    伪装
        解决方案
            1.取消csrf验证
                删除settings.py中MIDDLEWARE中的'django.middleware.csrf.CsrfViewMiddleware',
            2.在处理函数上增加一个装饰器
            @csrf_protect
            3.在表单中增加一个标签，
                {% csrf_token %}

3.使用forms模块处理表单
1.forms模块的作用
允许将表单与class相结合，并通过class生成表单控件
2.使用forms模块
1.创建forms.py 文件
2.导入django的forms

        from django import forms
    3.创建class，一个class对应生成一个表单
        class ClassName(forms.Form):
            pass
    4.在class创建属性
        一个属性对应到表单中生成一个控件
3.在模板中解析form对象
    1.注意：
        1.需要自定义<form>
        2.需要自定义 按钮
    2.处理方法
        在视图中创建Form的对象，并发送到模板中等待解析
        例：
            form = RemarkForm()
            return render(request,'xx.html',locals())
        在末班中解析form对象的方法
        1.手动解析
            在模板中
                原理：循环form对象，得到里面的每一个属性，每一个属性就是一个独立到的表单控件
                {% for field in form%}
                {{field}}:表示的就是控件
                {{field.label}}:表示的就是label属性值
                {% endfor %}
        2.自动解析
            1.{{form.as_p}}
                将form对象的每个属性使用p标记包裹起来再输出
            2.{{form.as_ul}}
                将form对象的每个属性使用li标记包裹起来再输出在网页上
                注意：必须手动提供<ol></ol>或<ul></ul>
        3.{{form.as_table}}
            将form对象的每个属性使用tr标记包裹起来再输出在网页上
            注意：必须寿佛那个提供<table></table>
4.通过Form类自动获取表单数据
    1.通过forms.Form的子类的构造器接受表单数据
        form = RemarkForm(request.POST)
    2.必须使用form通过验证之后在取值
        form.is_valid()
        返回True：提交的数据已通过所有验证，允许取值
        返回False：提交的数据未通过验证，无法取值
    3.获取表单的数据
         通过 form.cleaned_data 来表示提交的数据
5.forms模块的高级处理
    将Models 和 Forms 结合到一起使用
    1.在forms.py中创建class,继承自
    forms.ModelForm
    2.创建内部类Meta，用于关联Model
        1.model：指定要关联的实体类
        2.fields：指定要从Model中去那些属性生成控件
            1.取值为"__all__"
                全部属性都要生成控件
            2.取值 为一个列表
                将先允许生成控件的属性名放在列表中
                ["","",""]
        3.labels:指定每个属性所关联的label
            取值为字典
            labels = {
                "属性名":"label文本",
                "属性名":"label文本",
            }