• day61

    今日内容概要

    • 前后端数据传输的编码格式

    • Ajax提交json格式的数据

    • Ajax提交文件数据

    • Ajax实现弹窗的二次确认

    • 批量增加数据

    • 分页的原理及推导

    • 分页类的使用

    • cookie和session的介绍

    • Django操作cookie、session

    前后端数据传输的编码格式

    我们只研究post请求方式的编码格式
    """
        get请求方式没有编码格式
        index?useranme=&password=
        参数直接在url地址的后面拼接着
        get请求方式没有请求体
    """

    有哪些方式可以提交post请求
    form表单
    Ajax
    api工具

    研究form表单的post请求
    默认的编码格式：urlencoded
    数据传输的形式：title=dasdas&price=2312&date=&publish=2&authors=3
    对于Django后端是如何接收数据的：
    把提交过来的数据都封装到了request.POST中

    还可以提交form-data格式的
    enctype:form-data # 提交文件数据
    数据传输的形式：
    title=dasdas&price=2312&date=&publish=2&authors=3
    --------------binary-----------------------------
    文件数据

    # 对于Django后端如何接收数据的
    普通数据还是在request.POST中
    文件数据呢还是在request.FILES中
    """之所以你能够在POST和FILES中接收数据，是因为Django给你封装了，提交过来的数据并不是queryDICT"""

    # ajax提交post请求
    默认情况下，Ajax提交的数据后端还是在request.POST中接收的
    默认的编码格式：urlencoded
    需要修改contentType类型：json格式的

    """对于符合urlencoded格式的数据后端都是在request.POST中接收数据的"""

     Ajax提交json格式的数据

    前后端传输数据的时候一定要保证编码格式数据与真正的数据格式是一致的

    引入

    后端

    1. def ab_json(request):
    2.     if request.method == 'POST':
    3.         print(request.POST) #
    4.     return render(request, 'ab_json.html')

    前端

    2.

    请求标头携带的数据格式
    已成功转换为JSON格式

    {"username":"dream","password":521521}

    后端

    接收到的数据为空

    1. def ab_json(request):
    2.     if request.method == 'POST':
    3.         print(request.POST) #
    4.     return render(request, 'ab_json.html')

     Django针对JSON格式的数据不会做任何的处理
    针对JSON格式的数据需要自己手动处理
    解决办法

    1. def ab_json(request):
    2.     print(request.is_ajax())  # True
    3.     if request.method == 'POST':
    4.         print(request.POST)  # 
    5.  
    6.     print(request.body)  # 返回的是二进制数据 ：b'{"username":"dream","password":521521}'
    7.     # 针对JSON格式的数据需要自己手动处理
    8.     json_bytes = request.body
    9.  
    10.     # （1）方式一：先解码 再转换数据格式
    11.     json_str = json_bytes.decode('utf-8')
    12.     json_dict = json.loads(json_str)
    13.     print(json_dict, type(json_dict))  # {'username': 'dream', 'password': 521521} 
    14.  
    15.     # （2）方式二：json.loads(二进制数据) 内部可以自动解码再反序列化
    16.     json_dict_loads = json.loads(json_bytes)
    17.     print(json_dict_loads, type(json_dict_loads))  # {'username': 'dream', 'password': 521521} 
    18.  
    19.  
    20.     return render(request, 'ab_json.html')

    reques方法判断Ajax

    request.is_ajax()

    返回当前请求是否是Ajax请求，返回布尔值

    print(request.is_ajax()) 正常浏览器网址回车提交的是 GET 请求 - 结果是False 当我们发送ajax请求后 - 结果是True

     总结

    前端在通过Ajax请求发送数据的时候，一定要注参数修改

    1. // 不指定参数，默认就是 urlencoded
    2. contentType: 'application/json',

    数据是真正的JSON格式数据
    发送的数据一定要符合JSON格式或经过JSON序列化再传输

    Django后端不会帮我们处理JSON格式数据，需要自己手动处理request.body中的数据

    通过Ajax传过来的数据是二进制数据
    在reques.body中，要经过自己的反序列化才能拿到我们想要的数据

    Ajax发送文件数据

    Ajax发送文件数据需要借助js内置对象formdata
    前端

    1. username: <input type="text" name="username" id="d1">
    2. password: <input type="password" name="password" id="d2">
    3. file: <input type="file" id="d3">
    4.  
    6.  
    7.

    后端

    1. def ab_file(request):
    2.     if request.is_ajax():
    3.         if request.method == 'POST':
    4.             print('POST::>>', request.POST)
    5.             # 普通键值对放在了  request.POST   中
    6.             # POST::>> 
    7.             print('FILES::>>', request.FILES)
    8.             # 文件数据放在了  request.FILES   中
    9.             # FILES::>> ]}>
    10.  
    11.     return render(request, 'ab_file.html')

    发送文件数据格式

    1. // 点击按钮向后端发送普通键值对数据和文件数据
    2. $("#btn").on('click', function () {
    3. // （1）先生成一个内置对象
    4. let formDataObj = new FormData();
    5.  
    6. // （2）支持添加普通的键值对
    7. formDataObj.append('username', $("#d1").val());
    8. formDataObj.append('password', $("#d2").val());
    9.  
    10. // （3）支持添加文件对象 ---> 先拿到标签对象 ----> 再拿到文件对象
    11. formDataObj.append('myfile', $("#d3")[0].files[0]);
    12.  
    13. // （4）基于Ajax，将文件对象发送给后端
    14. $.ajax({
    15. url: '',
    16. type: 'post',
    17. // 直接将对象放到data里面即可
    18. data: formDataObj,
    19.  
    20. // Ajax发送文件必须添加的两个参数
    21. // 不需要使用任何编码 -  Django后端能自动识别 formdata 对象
    22. contentType: false,
    23. // 告诉浏览器不要对我的数据进行任何处理
    24. processData: false,
    25.  
    26. success: function (args) {
    27.  
    28. }
    29. })

    结论

    Ajax发送文件数据需要利用内置对象FormData

    1. // （1）先生成一个内置对象
    2. let formDataObj = new FormData();
    3.  
    4. // （2）支持添加普通的键值对
    5. formDataObj.append('username', $("#d1").val());
    6. formDataObj.append('password', $("#d2").val());
    7.  
    8. // （3）支持添加文件对象 ---> 先拿到标签对象 ----> 再拿到文件对象
    9. formDataObj.append('myfile', $("#d3")[0].files[0]);

    需要指定两个关键性的参数

    1. // Ajax发送文件必须添加的两个参数
    2. // 不需要使用任何编码 -  Django后端能自动识别 formdata 对象
    3. contentType: false,
    4. // 告诉浏览器不要对我的数据进行任何处理
    5. processData: false,

    Django后端能直接自动识别FormData对象
    将内部的普通键值对自动解析并封装到request.POST中
    将内部的文件自动解析并封装到request.FILES中

    1. print('POST::>>', request.POST)
    2. # 普通键值对放在了  request.POST   中
    3. # POST::>> 
    4.  
    5. print('FILES::>>', request.FILES)
    6. # 文件数据放在了  request.FILES   中
    7. # FILES::>> ]}>

    批量插入数据

    1.  
    2.     bulk_list = []
    3.     for i in range(10000):
    4.         user_obj=models.UserInfo(username='kevin%s' %i)
    5.         bulk_list.append(user_obj)
    6.     # 循环之后得到了一个列表，10000个对象
    7.     # 数据库的优化， 同样的功能，不同的sql执行的效率差距很大
    8.     # 优化查询速度的时候，首先想到的是，加索引、优化sql语句，有的sql走做引、有的sql不走索引
    9.     models.UserInfo.objects.bulk_create(bulk_list)

    分页原理及推导

    分页推导

    首先我们需要明确的时候，get请求也是可以携带参数的，所以我们在朝后端发送查看数据的同时可以携带一个参数告诉后端我们想看第几页的数据

    其次我们还需要知道一个点，queryset对象是支持索引取值和切片操作的，但是不支持负数索引情况

    接下来我们就可以推导我们的自定义分页器步骤了

    1. current_page = request.GET.get("page",1)  # 获取用户想访问的页码  如果没有 默认展示第一页
    2. try:  # 由于后端接受到的前端数据是字符串类型所以我们这里做类型转换处理加异常捕获
    3.   current_page = int(current_page)
    4. except Exception as e:
    5.   current_page = 1
    6. # 还需要定义页面到底展示几条数据
    7. per_page_num = 10  # 一页展示10条数据
    8.  
    9. # 需要对总数据进行切片操作 需要确定切片起始位置和终止位置
    10. start_page = ? 
    11. end_page = ?
    12. """
    13. 下面需要研究current_page、per_page_num、start_page、end_page四个参数之间的数据关系
    14. per_page_num = 10
    15. current_page                start_page                  end_page
    16.     1                           0                           10
    17.     2                           10                          20
    18.     3                           20                          30  
    19.     4                           30                          40
    20.  
    21. per_page_num = 5
    22. current_page                start_page                  end_page
    23.     1                           0                           5
    24.     2                           5                           10
    25.     3                           10                          15  
    26.     4                           15                          20
    27. 可以很明显的看出规律
    28. start_page = (current_page - 1) * per_page_num
    29. end_page =  current_page* per_page_num
    30. """

    数据总页面获取

    问题1:总数据有100条，每页展示10条，总共需要几页？
    答案:10条
    问题2:总数据有101条，每页展示10条，总共需要几页?
    答案:11条
    问题3:如何通过代码算出到底需要多少条？
    答案:去你妹的，不会！！！

    内置方法之divmod

    1. >>> divmod(100,10)
    2. (10, 0)  # 10页
    3. >>> divmod(101,10)
    4. (10, 1)  # 11页
    5. >>> divmod(99,10)
    6. (9, 9)  # 10页
    7. # 余数只要不是0就需要在第一个数字上加一

    我们可以判断元组的第二个数字是否为0从而确定需要多少页来展示数据

    1. book_queryset = models.Book.objects.all()
    2. all_count = book_queryset.count()  # 数据总条数
    3. all_pager, more = divmod(all_count, per_page_num)
    4. if more:  # 有余数则总页数加一
    5.   all_pager += 1

    至此分页器大致的功能及思路我们就已经大致清楚了
    最后我们只需要利用start_page和end_page对总数据进行切片取值再传入前端页面就能够分页展示

    1. book_list = models.Book.objects.all()[start_page:end_page]
    2. return render(request,'booklist.html',locals())

    接下来就是前端页面的代码编写了

    1. {% for book in book_list %}
    2. 	
      {{ book.title }}
    3. {% endfor %}

    现在我们实现了最简单的分页，但是前端没有按钮去让用户点击需要看第几页，所以我们需要渲染分页器相关代码，这里我们不做要求直接去bootstrap框架拷贝代码即可

    终极大法

    上面是自定义分页器开发流程的基本思路，我们不需要掌握代码的编写，只需要掌握基本用法即可

    自定义分页器封装代码

    1. class Pagination(object):
    2.     def __init__(self, current_page, all_count, per_page_num=2, pager_count=11):
    3.         """
    4.         封装分页相关数据
    5.         :param current_page: 当前页
    6.         :param all_count:    数据库中的数据总条数
    7.         :param per_page_num: 每页显示的数据条数
    8.         :param pager_count:  最多显示的页码个数
    9.         """
    10.         try:
    11.             current_page = int(current_page)
    12.         except Exception as e:
    13.             current_page = 1
    14.  
    15.         if current_page < 1:
    16.             current_page = 1
    17.  
    18.         self.current_page = current_page
    19.  
    20.         self.all_count = all_count
    21.         self.per_page_num = per_page_num
    22.  
    23.         # 总页码
    24.         all_pager, tmp = divmod(all_count, per_page_num)
    25.         if tmp:
    26.             all_pager += 1
    27.         self.all_pager = all_pager
    28.  
    29.         self.pager_count = pager_count
    30.         self.pager_count_half = int((pager_count - 1) / 2)
    31.  
    32.     @property
    33.     def start(self):
    34.         return (self.current_page - 1) * self.per_page_num
    35.  
    36.     @property
    37.     def end(self):
    38.         return self.current_page * self.per_page_num
    39.  
    40.     def page_html(self):
    41.         # 如果总页码 < 11个：
    42.         if self.all_pager <= self.pager_count:
    43.             pager_start = 1
    44.             pager_end = self.all_pager + 1
    45.         # 总页码  > 11
    46.         else:
    47.             # 当前页如果<=页面上最多显示11/2个页码
    48.             if self.current_page <= self.pager_count_half:
    49.                 pager_start = 1
    50.                 pager_end = self.pager_count + 1
    51.  
    52.             # 当前页大于5
    53.             else:
    54.                 # 页码翻到最后
    55.                 if (self.current_page + self.pager_count_half) > self.all_pager:
    56.                     pager_end = self.all_pager + 1
    57.                     pager_start = self.all_pager - self.pager_count + 1
    58.                 else:
    59.                     pager_start = self.current_page - self.pager_count_half
    60.                     pager_end = self.current_page + self.pager_count_half + 1
    61.  
    62.         page_html_list = []
    63.         # 添加前面的nav和ul标签
    64.         page_html_list.append('''
    65.                     
    66.                     
      •                 ''')
      •         first_page = '
      • 首页
        • ' % (1)
    67. page_html_list.append(first_page)
    69. if self.current_page <= 1:
    70. prev_page = '
    71. 上一页
      72. '
  • else:
  • prev_page = '
  • 上一页
    • ' % (self.current_page - 1,)
  • page_html_list.append(prev_page)
  • for i in range(pager_start, pager_end):
  • if i == self.current_page:
  • temp = '
  • %s
    • ' % (i, i,)
  • else:
  • temp = '
  • %s
    • ' % (i, i,)
  • page_html_list.append(temp)
  • if self.current_page >= self.all_pager:
  • next_page = '
  • 下一页
    • '
  • else:
  • next_page = '
  • 下一页
    • ' % (self.current_page + 1,)
  • page_html_list.append(next_page)
  • last_page = '
  • 尾页
    • ' % (self.all_pager,)
  • page_html_list.append(last_page)
  • # 尾部添加标签
  • page_html_list.append('''
  • ''')
  • return ''.join(page_html_list)

    • 自定义分页器的使用

    后端

    1.  def get_book(request):
    2.    book_list = models.Book.objects.all()
    3.    current_page = request.GET.get("page",1)
    4.    all_count = book_list.count()
    5.    page_obj = Pagination(current_page=current_page,all_count=all_count,per_page_num=10)
    6.    page_queryset = book_list[page_obj.start:page_obj.end]
    7.    return render(request,'booklist.html',locals())

    前端

    1. class="container">
    2.     
      class="row">
    3.         
      class="col-md-8 col-md-offset-2">
    4.             {% for book in page_queryset %}
    5.             
      {{ book.title }}
    6.             {% endfor %}
    7.             {{ page_obj.page_html|safe }}
    8.         
    9.

  • 相关阅读:
    关于一次两段式提交和数据库恢复数据我的一些想法
    Lua调试函数 debug.getinfo() namewhat详解
    Gophish 记录
    conda配置国内源（已验证速度）
    1024动态
    Python中执行SQL报错unsupported format character ‘Y‘ (0x59) at index 34
    linux 系统时间、时区、date、timedatectl
    CSS3 多个背景图像、线性渐变从上到下(默认)、线性渐变从左到右
    搭建 live2d api接口详细步骤
    git使用方法
  • 原文地址：https://blog.csdn.net/qq_67257222/article/details/134531612