choices参数的使用、MTV和MVC概念、多对多的三种创建方式、Ajax技术简介

choices参数的使用

choices：是ORM中常用字段中的参数

作用：类似于一些字段：性别、学历、客户来源、是否上学、是否结合等字段

针对于一些字段它的情况能够被列举完，像这样的字段，我们在表中存储的时候一般使用choices参数

案例：

models文件中：

class UserInfo(models.Model):
    username = models.CharField(max_length=64)
    # 增加一个性别字段：不要存字符串类型，可以存数字类型，用数字去代表具体的信息：1 2 3
    gender_choices = (
        (1, '男'),
        (2, '女'),
        (3, '未知'),
    )  # 还可以是列表套元组，是可变类型
    '''gender字段所存储的范围大小取决于上面的gender_choices的元组范围，但是超出范围不会报错，是什么就会输出什么'''
    gender = models.SmallIntegerField(choices=gender_choices)  # 存的是int类型
    """我们想实现的效果是：存的时候是数字，读出来是对应的文本内容"""
    # 定义一个分数的字段：A：优秀 B:良好 C:及格 D:不及格
    score_choices = (
        ('A', '优秀'),
        ('B', '良好'),
        ('C', '及格'),
        ('D', '不及格'),
    )
    # 字段类型如何选择：就选择跟('A', '优秀')第一个参数错存得类型一致就行
    score = models.CharField(max_length=64, choices=score_choices, default='A')

 test文件中：

# 在test.py中
# 搭建Django测试环境：
import os
import sys

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "d9_dj.settings")
    import django
    django.setup()
    from app01 import models
    #往表里增加数据
    # models.UserInfo.objects.create(username='jerry1', gender=1)
    # models.UserInfo.objects.create(username='jerry2', gender=2)
    # models.UserInfo.objects.create(username='jerry3', gender=3)
    # models.UserInfo.objects.create(username='jerry4', gender=4)

    # 读取数据
    res = models.UserInfo.objects.filter(pk=4).first()
    # res = models.UserInfo.objects.get(pk=1) # get方式也能获取数据，但是如果没有这个数据就会报错
    print(res)  # UserInfo object
    print(res.gender) # 4，超出存储范围，是什么就输出什么，不会报错
    res1 = models.UserInfo.objects.filter(pk=2).first()
    if res1.gender == 1:
        gender = '男'
    elif res1.gender == 2:
        gender = '女'
    # get_gender_display()---------》get_字段名_display()：获取数字对应的信息
    print(res1.get_gender_display()) #  女

    res = models.UserInfo.objects.filter(pk=2).first()
    print(res.get_score_display()) # F

结果：

MTV和MVC的概念

把Django框架的执行流程做分层：

　　在Django中分的是MTV

　　在其他语言中分的是MVC

这两个本上都是一样的：

　　Web服务器开发领域里著名的MVC模式，所谓MVC就是把Web应用分为模型(M)，控制器(C)和视图(V)三层，

　　Web服务器开发领域里著名的MTV模式，所谓MVC就是把Web应用分为模型(M)，控制器(V)和视图(T)三层

Java、PHP文件名的命名是：
　　Login.Controller.java
　　Login.Controller.php

● M 代表模型（Model）： 负责业务对象和数据库的关系映射(ORM)。
● T 代表模板 (Template)：负责如何把页面展示给用户(html)。
● V 代表视图（View）： 负责业务逻辑，并在适当时候调用Model和Template。
● S 代表视图（Services）： 只有在业务逻辑相当复杂的时候，才分这一层，服务层，专门用来写业务逻辑

多对多的三种创建方式

多对多的关系是借助于第三张表实现的

方式一：

　　通过一个虚拟字段创建的第三张表: 

authors =  models.ManyToManyFeild(to='表名')   #  全自动

案例：

# 方式一：全自动创建
class Book(models.Model):
    title = models.CharField(max_length=64)
    authors = models.ManyToManyField(to='Author') # 全自动

class Author(models.Model):
    name = models.CharField(max_length=64)
    '''
       全自动的优点：
            第三张表不需要我们自己来创建，通过这个虚拟字段自动创建出来第三张表 
            authors字段不会再表中创建出来字段
            在查询的时候，可以使用正反向查询和那四个方法 add set remove clear
        缺点：第三张关系表的扩展性极差(没有办法额外添加字段...)    
    '''

方式二：纯手动

# 方式二：纯手动
'''
    优势：扩展性非常好
    劣势：需要写的代码多，不能使用四个方法 add set remove clear，不建议用该方式
'''
class Book(models.Model):
    title = models.CharField(max_length=64)

class Author(models.Model):
    name = models.CharField(max_length=64)

#  第三张表需要我们自己手动创建，不会在自动创建了
class Book2Author(models.Model):
    book = models.For

方式三：半自动：支持正反向查询，但是不支持：add、set、remove、clear这四种方法

# 方式三：半自动
# 半自动:支持正反向查询的，但是不支持那四个方法
class Book(models.Model):
    title = models.CharField(max_length=64)
    authors = models.ManyToManyField(to='Author', through='Book2Author', through_fields=('book1', 'author1'))

class Author(models.Model):
    name = models.CharField(max_length=64)
    book = models.ManyToManyField(to='Book',through='Book2Author',through_fields=('author1','book1'))

'''
    through:后面写第三张表名
    through_fields:后面所跟的字段先后顺序
    判断的本质：
        通过第三张表查询对应的表 需要用到哪个字段就把哪个字段（第三张表里的字段）放前面
    你也可以简化判断
        当前表是谁 就把对应的关联字段放前面
'''
class Book2Author(models.Model):
    book1 = models.ForeignKey(to='Book')
    author1 = models.ForeignKey(to='Author')

总结:

　　你需要掌握的是全自动和半自动 为了扩展性更高 一般我们都会采用半自动(写代码要给自己留一条后路)

 

Ajax技术简介

　　他属于是前端的内容，不属于Python范围的，但是它必须结合后端来使用，否则也没有太大的意义，因为它是把前端的数据提交到后端的。

　　form表单来提交数据到后端，但是，它每次提交数据都需要刷新页面，如果都刷新页面体验就不好。

Ajax技术：

　　局部刷新，异步提交，不需要刷新整个页面，只要刷新局部的，主要就是舒心的时候是无感知的

Ajax的特点：局部刷新，异步提交

案例：github注册

　　动态获取用户实时的和后端确认并实时展示的前端（局部刷新）

朝发送请求的方式：

　　1.浏览器地址栏直接输入url回车　　GET请求

　　2.a标签href属性　　　　　　　　　GET请求

　　3.form表单　　　　　　　　　　　GET请求/POST请求　　　

　　4.ajax　　　　　　　　　　　　　GET请求/POST请求

# AJAX 不是新的编程语言，而是一种使用现有标准的新方法(比较装饰器)

Ajax最大的优点是在不重新加载整个页面的情况下，可以与服务器交换数据并更新部分网页内容。（这一特点给用户的感受是在不知不觉中完成请求和响应过程）

Ajax我们只学习jQuery封装之后的版本(不学原生的 原生的复杂并且在实际项目中也一般不用)
所以我们在前端页面使用ajax的时候需要确保导入了jQuery
ps:并不只有jQuery能够实现ajax，其他的框架也可以 但是换汤不换药 原理是一样的

Ajax写个小案例

 做一个加法运算:

html文件：

<body>
<input type="text" id="d1">+
<input type="text" id="d2">=
<input type="text" id="d3">
<button class="btn btn-info">计算</button>
<script>
{#    找到btn类的属性绑定click事件#}
    $(".btn").click(function () {
        // 获取输入框中的两个值
        var d1 =$("#d1").val()
        var d2 = $("#d2").val()

        // 将前端页面输入的值提交到后端进行加法计算
        // 通过Ajax提交数据，朝后端发送ajax请求
        $.ajax({
            // 1。指定参数提交到哪个后端地址
            url:'', //不写就是向当前地址提交

            // 2。指定以get/post请求方式提交
            type:'post', //不指定默认就是get

            // 3. 指定要传递的数据
            //方式一：
            data:{'d1':d1,'d2':d2},//contentType:'application/json',编码格式变成json
            dataType:'json', // 当后端是return HttpResponse(res)时，指定参数：dataType:'json'，后面接受后端返回的数据时不需要再反序列化
            //4.回调函数，接收后端返回的数据
            success:function (res){
                {#$('#d3').val(res)  // 通过DOM操作动态渲染到第三个input里面#}  //res是后端返回给前端的数据
                {#console.log(args) // object#}


                //进行反序列化
                {#res = JSON.parse(res) //将字符串反序列化为对象 ,res是后端返回给前端的数据#}
                console.log(res)
                console.log(res.code)
            }
        })
    })
</script>
</body>

views文件：

from django.shortcuts import render, HttpResponse
from django.http import JsonResponse

# Create your views here.
def index(request):
    if request.method == 'POST':
        print(request.POST)  # <QueryDict: {'d1': ['1'], 'd2': ['3']}>
        # # 接受前端传来的参数
        # d1 = request.POST.get('d1')  # d1是str类型
        # d2 = request.POST.get('d2')  # d2是str类型
        # # 进行运算
        # d3 = int(d1) + int(d2) # 所以要先将d1、d2转换为整型才能实现加法计算
        # return HttpResponse(d3)  # 返回结果是字符串类型

        d = {'code':200,'msg':'请求成功','data':{'username':'hua'}}
        # 进行序列化，然后再返回给前端
        import json
        res = json.dumps(d,ensure_ascii=False) # 序列化之后,字典d变成了字符串类型
        return HttpResponse(res)
        # return JsonResponse(d)  #前端不用反序列化，直接当成对象使用
    return render(request, 'index.html')

 

结果如图：

 

总结：

　　1. 后端如果使用return JsonResponse(d)， 前端不用反序列化，直接当成对象使用

　　2. 后端使用return HttpResponse(res)，前端需要自己反序列化:res= JSON.parse(res)

　　3. 后端使用return HttpResponse(res)，前端不反序列化，但是在前端的html文件中需要指定参数：dataType:'json'                  

​