django 视图

对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。

ORM的操作：

类     —— 》   表
对象   —— 》   数据（记录）
属性   —— 》   字段

models.User.objects.all()  # 所有数据   对象列表
models.User.objects.get(username='alex')  # 获取一个满足条件的对象  没有数据 或者 多条数据就报错
models.User.objects.filter(username='alex1')  # 获取满足条件的所有对象  对象列表1) 对应关系

class Student(models.Model)
models.CharField (max_length=32)  # varchar(32)
models.AutoField (primary_key=True)  #自增字段 pk主键 
    models.ForeignKey (‘Publisher’,on_delete=models.CASCADE)  #publisher是所管连的表的类名(可以是字符串的形式)

models.CASCADE 是级联删除
default=’男’
on_delete=models.SET_DEFAULT 是设置默认值
SET_NULL是设置为空
SET(value)
on_delete:所关联的表删除后,对这个表所做的操作
django1.11版本之前的不用填写 默认是on_delete=models.CASCADE
django2.0版本之后就是必填项

1.ORM字段 对象关系映射

常用的字段
?????????AutoField :自增字段 自增的整形字段，必填参数primary_key=True，则成为数据库的主键。无该字段时，django自动创建。
一个model不能有两个AutoField字段。
?????????AutoFieldIntegerField: 一个整数类型。数值的范围是?-2147483648 ~ 2147483647。
?????????AutoFieldCharField: 字符类型
?????????AutoFieldDateField ; 日期类型
参数：
auto_now：每次修改时修改为当前日期时间。
auto_now_add：新创建对象时自动添加当前日期时间。每次修改时,时间不变
auto_now和auto_now_add和default参数是互斥的，不能同时设置。
?????????AutoFieldDatetimeField : 日期时间字
????????AutoFieldBooleanField : - 布尔值类型
????????AutoFieldNullBooleanField 可以为空
????????AutoFieldTextField- 文本类型
????????AutoFieldFloatField:浮点型
????????AutoFieldDecimalField 10进制小数

2.参数

1). null = Ture 数据库中可以为空
2). blank = Ture 表单中可以为空
3). db_column 修改数据库中字段的列名

4). default 默认值
5) unique=True 唯一
6) verbose_name=’名字’ ?Admin中显示的字段名称中文提示
7) choices Admin中显示选择框的内容可供选择的值 gender=models.BooleanField(‘性别‘,default=False,choices=((0,‘男‘),(1,‘女‘)))
8) help_text=‘请输入正确年龄‘ ?Admin中该字段的提示信息

3.自定义一个char类型字段：

 class MyCharField(models.Field):
    """
    自定义的char类型的字段类
    """

    def __init__(self, max_length, *args, **kwargs):
        self.max_length = max_length
        super(MyCharField, self).__init__(max_length=max_length, *args, **kwargs)

    def db_type(self, connection):
        """
        限定生成数据库表的字段类型为char，长度为max_length指定的值
        """
        return 'char(%s)' % self.max_length

使用:用自定义的类名 phone = MyCharField(max_length=11,)

4. 表的参数

Class Mate类是固定写法,是给上边的类做的标配

class Person(models.Model):
    pid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32, db_column='username', unique=True, verbose_name='姓名')  # varchar(32)


class Meta:
    # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
    db_table = "person"
    # 排序
    ordering = ('pk',)


# 联合索引 
index_together = [
    ("name", "age"),
]
# 联合唯一索引
unique_together = (("name", "age"),)

下图是该名字，改变后,名字变了,内容不变

import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
import django
django.setup()
from app01 import models

返回的是对象列表 (8)

all   获取表中所有的数据    ——》 对象列表  QuerySet
filter  #  获取表中满足条件的所有数据   ——》 对象列表  QuerySet
exclude  获取表中不满足条件的所有数据    ——》 对象列表  QuerySet
order_by  对已经排好序的结果进行倒序      ——》 对象列表  QuerySet
排序    默认升序   字段加- 降序     多个字段   ——》 对象列表  QuerySet
models.Person.objects.all().order_by('-age', 'pk'),先按第一个字段排,要是有两个一样的,按第二个排
reverse  翻转
ret = models.Person.objects.all().order_by('pk').reverse()
values   获取数据的字段名和对应的值    ——》 对象列表  QuerySet   [{} ,{}]字典
#  不填写参数    获取所有字段名字和值  obj=models.Person.objects.values()
#  填写参数      获取指定字段名字和值   obj=models.Person.objects.values('name',’age’)
values_list 
获取数据的字段对应的值    ——》 对象列表  QuerySet   [() ,()] 元祖
#  不填写参数    获取所有字段值
#  填写参数      获取指定字段值   有顺序
distinct  去重  所有字段都一样才去重

返回的是对象 (3)

get  # 获取一条数据    ——》 对象     获取不到或者多条就报错
first  取第一个元素   没有元素  None
last    取最后一个元素   没有元素  None

返回布尔值 （1）

exists  判断是否存在 models.Person.objects.filter(name='alex').exists()

返回数字 （1）

count  计数

单表的双下划线

ret = models.Person.objects.filter(pk=1)
ret = models.Person.objects.filter(pk__gt=1)  # greater than   大于
ret = models.Person.objects.filter(pk__lt=3)  # less than    小于
ret = models.Person.objects.filter(pk__gte=1)  # greater than equal   大于等于
ret = models.Person.objects.filter(pk__lte=3)  # less than  equal     小于等于

ret = models.Person.objects.filter(pk__range=[1, 3])  # 范围   左右都包含
ret = models.Person.objects.filter(pk__in=[1, 5])  # in  只要1和5

ret = models.Person.objects.filter(name__contains='alex')  #  like  完全包含
ret = models.Person.objects.filter(name__icontains='ale')  #  like   忽略大小写  ignore

ret = models.Person.objects.filter(name__startswith='a')  #  以a开头
ret = models.Person.objects.filter(name__istartswith='a')  #  以a开头忽略大小写


ret = models.Person.objects.filter(name__endswith='a')  #  以a开头
ret = models.Person.objects.filter(name__iendswith='g')  #  以a开头忽略大小写

ret = models.Person.objects.filter(phone__isnull=True)  #  phone字段为空
ret = models.Person.objects.filter(phone__isnull=False)  #  phone字段不为空


ret = models.Person.objects.filter(birth__year=2019)  
ret = models.Person.objects.filter(birth__contains='2019-04-09')  包含，相当于like
# ret = models.Person.objects.filter(birth__month=4) 

外键的操作

1）基于对象的查询
正向查询

  book_obj = models.Book.objects.get(pk=1)
# print(book_obj.publisher)          # 书籍所关联的对象
# print(book_obj.publisher.name)   # 书籍所关联的对象的名字
# print(book_obj.publisher_id)     # 书籍所关联的对象的ID

反向查询

pub_obj = models.Publisher.objects.get(pk=1)

# 外键中 不指定related_name     pub_obj.表名小写_set   关系管理对象
# print(pub_obj.book_set,type(pub_obj.book_set))    #  表名小写_set   关系管理对象  
# print(pub_obj.book_set.all())

# 外键中 指定related_name='books'    pub_obj.books  关系管理对象
# print(pub_obj.books,type(pub_obj.books))    #  表名小写_set   关系管理对象

**2）基于字段的查询 外键名__name=’ ’ 跨表查询**

查询人民出版社出版的所有书籍

ret = models.Book.objects.filter(publisher__name='人民出版社')

查询丰乳肥臀的出版社

不指定 related_name      跨表时使用  表名小写__字段
# ret = models.Publisher.objects.filter(book__title='丰乳肥臀')
# 指定 related_name='books'   跨表时使用books__字段
# ret = models.Publisher.objects.filter(books__title='丰乳肥臀')
# 指定 related_name='books'  related_query_name='book'  跨表时使用book__字段
ret = models.Publisher.objects.filter(book__title='丰乳肥臀')
# print(ret)
print(pub_obj.books.all())

多对多

基于对象的查询

author_obj.books ——》 关系管理对象
author_obj.books.all() ——》 关系管理对象

不指定related_name 
book_obj.author_set ——》 关系管理对象
book_obj.author_set.all() ——》 作者写过所有的书籍对象 

指定related_name=’authors‘
book_obj.authors——》 关系管理对象
book_obj.authors.all() ——》 作者写过所有的书籍对象 

管理对象的方法

all 获取所有的对象
set 设置关系 多对多 [ id,id ] [对象，对象] 一对多 [对象] 
add 添加关系 多对多 id,id 对象，对象 一对多 对象 
remove 删除关系 一对多：必须设置外键可为空，才有remove clear方法
clear 清空所有的关系
create 创建一个对象并且添加关系
        `book_obj.authors.create(name='xxxx') `

pub_obj.books.set(models.Book.objects.filter(pk__in=[3]))  # 设置关系  【对象 】
pub_obj.books.add(*models.Book.objects.filter(pk__in=[4]))    # 添加关系   对象
pub_obj.books.remove(*models.Book.objects.filter(pk__in=[3]))   # 删除关系   对象    外键 null=True
pub_obj.books.clear()   # 删除关系   对象    外键 null=True

分组 注释: annotate
所获取的是对象列表[{ },{ }]
例：

import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_practice.settings")
import django
django.setup()
from app01 import models
from django.db.models import Max, Min, Count, Avg, Sum

方式一：
ret = models.Publisher.objects.annotate(min=Min('book__price')).values()
方式二
ret = models.Book.objects.values('publisher__name').annotate(min=Min('price'))  #对象列表{}
for i in ret:
    print(i)

from django.db.models import F, Q
F查询 比较两个字段

ret=models.Book.objects.filter(sale__gt=F('kucun'))   update(sale=F(‘sale’)*2)

Q 查询 |或 ;& 与 ;~ 非

Filter(Q(pk_gt=5))  ==  Q((‘ss’,kk))

事务

cookie

定义：cookie就是保存在浏览器本地的一组组键值对
特性：

• 服务器让浏览器进行设置的


• 保存在浏览器本地的，浏览器也可以不保存


• 下次访问时自动携带相应的cookie

1. 登录 (保存状态)
2. 保存用户的浏览习惯
3. 投票

为什么要有cookie?

HTTP协议是无状态的,每次请求都是没关系的,没办法保存,状态,使用cookie保存状态

django的操作：

1. 设置 本质: 响应头 set-cookie

   ret = redirect(‘/home/‘) #响应对象
   ret.set_cookie(‘is_login‘, ‘1‘) # 普通的cookie max_age=5设置时间 path domain
   #ret.set_signed_cookie(key=‘is_login‘,value= ‘1‘, salt=‘day62‘) # 加密的cookie
   参数：
   max_age=5设置时间，
   path=‘/‘, Cookie生效的路径，/ 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问domain=None, Cookie生效的域名

2. 获取 本质:请求头cookie

   request.COOKIES[key] {} # 普通的cookie
   或者
   request.COOKIES.get(key)
   #request.get_signed_cookie(‘is_login‘,salt=‘day62‘,default=‘‘) # 加密的cookie

3. 删除

   ret = redirect(‘/login/‘)
   ret.delete_cookie(‘is_login‘)

session

session 当做字典使用

定义: 保存在服务器上一组组键值对，必须依赖于cookie。

为什么要使用session？（特性）

1. cookie保存在浏览器本地，不安全
2. cookie的大小受到限制

django中操作session

1. 设置

   request.session[key] = value
   或者
   request.session.setdefault(key,value)

2. 获取

   request.session[key]
   或者
   request.session.get(key)

3. 删除

   del request.session[‘k1‘]
   request.session.delete() ＃　删除所有的session数据 不删除cookie
   request.session.flush() ＃　删除所有的session数据 删除cookie
   request.session.exists("session_key") #检查会话session的key在数据库中是否存在

其他:

request.session.set_expiry(10)  #设置超时时间,但是数据库的session不会删   
通过request.session.clear_expired() # 清除已过期的数据

配置: 了解

from django.conf import global_settings

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

#缓存Session
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎 
 
#文件Session
SESSION_ENGINE = 'django.contrib.sessions.backends.file'
SESSION_COOKIE_AGE = 1209600 设置失效时间的
SESSION_COOKIE_PATH ＝ "/"      # Session的cookie保存的路径（默认）
SESSION_COOKIE_DOMAIN = None            # Session的cookie保存的域名（默认）
SESSION_COOKIE_SECURE = False           # 是否Https传输cookie（默认）
SESSION_COOKIE_HTTPONLY = True            # 是否Session的cookie只支持http传输（默认）

中间件

本质上就是python中的类

使用:
在app01下新建一个middlewares文件夹,在里面新建一个py文件

from django.utils.deprecation import MiddlewareMixin

在setting里添加配置

1)官方的说法：中间件是在全局范围内一个用来处理Django的请求和响应的框架级别的钩子
2) 五种方法：（执行时间、执行顺序、参数、返回值）

• process_request(self,request)
• process_view(self, request, view_func, view_args, view_kwargs)
• process_exception(self, request, exception)
  
• process_template_response(self,request,response)
• process_response(self, request, response)

process_request(self,request)

执行时间：
?视图函数执行之前(请求到来后,路由匹配前)
执行顺序：
?按照注册的顺序 顺序执行
参数：
?request - 和视图中的request对象是同一个
返回值：
?None: 正常流程
?HttpResponse对象： 后面的中间件的process_request方法、视图都不执行，直接执行当前中间件的process_response方法，再返回给浏览器

process_response(self, request, response)

执行时间：
?视图函数执行之后
执行顺序：
?按照注册的顺序 倒序执行
参数：
?request - 和视图中的request对象是同一个
?response - 视图函数返回的响应对象
返回值：
HttpResponse对象： 必须返回

process_view(self, request, view_func, view_args, view_kwargs)

执行时间：
?在process_request方法后，路由匹配之后,视图函数执行之前
执行顺序：
?按照注册的顺序 顺序执行
参数：
?request - 和视图中的request对象是同一个
?view_func - 视图函数
?view_args - 给视图使用的位置参数
?view_kwargs - 给视图使用的关键字参数
返回值：
?None: 正常流程
?HttpResponse对象： 后面的中间件的process_view方法、视图都不执行，直接执行最后一个中间件的process_response方法，再返回给浏览器

process_exception(self, request, exception)

执行时间(触发的条件)：
? 视图函数执行之后，视图有异常时才执行
执行顺序：
? 按照注册的顺序 倒序执行
参数：
? request - 和视图中的request对象是同一个
? exception - 错误的对象
返回值：
? None: 正常流程 ，交给下一个中间件处理异常，都返回的是None，交给django处理异常（大黄页）
? HttpResponse对象： 后面的中间件的process_exception方法不执行，直接执行最后一个中间件的process_response方法，再返回给浏览器

process_template_response(self,request,response)

执行时间(触发条件)：
? 视图函数执行之后，要求视图函数返回的对象是TemplateResponse对象
执行顺序：
? 按照注册的顺序 倒序执行
参数：
? request - 和视图中的request对象是同一个
? response - 视图函数返回的响应对象
返回值：
? HttpResponse对象： 必须返回

csrf相关的装饰器

csrf_exempt # 当前的视图不需要CSRF校验
csrf_protect # 当前的视图需要CSRF校验

from django.views.decorators.csrf import csrf_exempt, csrf_protect
from django.views.decorators.csrf import ensure_csrf_cookie
@ csrf_exempt   
def  login(request) 普通函数直接加

CBV中 csrf_exempt只能加在dispatch上或是类上

@method_decorator(csrf_exempt,name='dispatch')

csrf中间件步骤

1. 请求到来时执行process_request方法：
   从cookie中获取csrftoken的值 —— 》 赋值给 request.META[‘CSRF_COOKIE‘]
2. 执行process_view方法：
   1. 查看视图是否加了csrf_exempt装饰器：
      1. 有 不需要csrf 校验 返回none
      2. 没有 需要csrf 校验
         
   2. 请求方式的判断：
      1. 如果是 ‘GET‘, ‘HEAD‘, ‘OPTIONS‘, ‘TRACE‘ 不需要csrf 校验 返回none
      2. 其他方式需要csrf 校验
         
   3. 进行CSRF校验：
      1. 从request.META获取到csrftoken的值
      2. 尝试从表单中获取csrfmiddlewaretoken的值：
         1. 能获取到
            csrfmiddlewaretoken的值和cookie中的csrftoken值做对比
            1. 对比成功 通过csrf校验
            2. 对比不成功 不通过csrf校验 拒绝请求
         2. 获取不到 尝试从请求头中获取x-csrftoken的值
            x-csrftoken的值和cookie中的csrftoken值做对比
            1. 对比成功 通过csrf校验
            2. 对比不成功 不通过csrf校验 拒绝请求

json 和XML对比

JSON 简单的语法格式和清晰的层次结构明显要比 XML 容易阅读，并且在数据交换方面，由于 JSON 所使用的字符要比 XML 少得多，可以大大得节约传输数据所占用得带宽。

ajax

（Asynchronous Javascript And XML）翻译成中文就是“异步的Javascript和XML”,
AJAX 不是新的编程语言，而是一种使用现有标准的新方法

定义: 是一个js的技术，发送请求的一种途径。
特点：

1. 异步 2. 局部刷新 3. 传输的数据量小（xml json）

发请求的途径：

• 地址栏上输入地址 GET
• a标签 GET
• form表单 GET/POST

简单实例 固定格式

$.ajax({
    url:'/calc/',
    type:'post',
    data:{
        i1:$('[name="i1"]').val(),
        i2:$('[name="i2"]').val(),
    },
    success:function (res) {
        $('[name="i3"]').val(res)
    }
})

参数

 $.ajax({
    url: '/ajax_test/',   ＃　请求的地址
    type: 'post',       ＃　请求的方式
    data: {             ＃　请求的数据
        name: 'alex',
        age: 73,
        hobby: JSON.stringify(['装逼', '作死', '卖烧饼'])  #将对象转成字符串
    },
success: function (res) {　＃　成功后执行的函数
location.href=地址  重定向　　　#返回时不要redirect了
    },
    error: function (res) {         ＃　失败后执行的函数
        console.log(res)
    },
})

ret=json.loads(ret)
print(ret,type(ret)) #<class ‘list‘>

ajax上传文件

ajax通过django的csrf校验

1. 确保csrftoken的cookie
   1. 一个加 {% csrf_tokne%}
   2. 给视图函数加装饰器
2. 提供参数
   1. 给data添加数据
      data: {
      csrfmiddlewaretoken:隐藏标签或是cookie
      csrfmiddlewaretoken: $(‘[name="csrfmiddlewaretoken"]‘).val(),
      i1: $(‘[name="i1"]‘).val(),
      i2: $(‘[name="i2"]‘).val(),
      },
      ? 2. 加x-csrftoken的请求头
      headers: {
      ‘x-csrftoken‘: 隐藏标签或是cookie
      ‘x-csrftoken‘: $(‘[name="csrfmiddlewaretoken"]‘).val(),
      },
      3.文件导入

   <script src="/static/ajax_setup.js"></script> 

   总结：json

                    数据交换的格式
               Python
               ?   数据类型： 数字 字符串 列表 字典  布尔值  None
               ?   转化：
               ?       序列化   Python的类型  ——》 json的字符串
               ?       json.dumps(Python的类型)
               ?       json.dump(Python的类型, f )
               ?       反序列化     json的字符串   ——》   Python的类型
               ?       json.loads( json的字符串)
               ?       json.load(f )
               js
               ?   数据类型： 数字 字符串 列表 字典 布尔值  null
               ?   转化：
               ?       序列化  js的类型  ——》 json的字符串
               ?       JSON.stringify( js的类型  )
               ?       反序列化     json的字符串   ——》   JS的类型
               ?       JSON.parse( json的字符串 )
               JsonResponse({})      #  contentType  :application/json
               JsonResponse([],safe=False)