day64_django_orm
# 每日测验
```python
"""
今日考题
1.什么是FBV与CBV，能不能试着解释一下CBV的运作原理
2.模版语法的传值需要注意什么，常见过滤器及标签有哪些
3.自定义过滤器，标签，inclusion_tag的流程
4.什么是模版的继承与导入，如何正确使用
"""
```
# 昨日内容回顾
* CBV源码
```python
# 能够根据请求方式的不同自动匹配触发对应的方法的执行(只要是视图函数都应该有一个形参request)
# url FBV与CBV在路由匹配上本质是一样的都是 路由对应函数内存地址
url(r'^index/',views.index)
url(r'^login/',views.MyClass.as_view())
# url(r'^login/',views.view)
# 源码
MyClass.as_view()
@classonlymethod
def as_view(cls,**initkwargs):
def view(*args,**kwargs):
self = cls(*args,**kwargs)
...
return self.dispatch(*args,**kwargs)
"""
你在后面看python源码的时候 只要看到self点东西
你一定要问你自己一些当前这个self到底是谁？？？
属性方法查找顺序
对象本身找
产生对象的类中
类的父类们
"""
return view
def dispatch(*args,**kwargs):
if request.method.lower() in ['get','post',...]:
handler = getattr(self,request.method.lower(),'报错信息')
else:
handler = '报错提示方法'
return handler(request,*args,**kwargs)
```
* 模版语法的传值
变量相关:{{}}
逻辑相关:{%%}
```python
# 你要知道render支持两种给html文件传值的方式; locals() ,字典
# python所有的基本数据类型 函数名 类名 对象都可以被传到html上
# 针对函数名和类名 模版语法会自动加括号调用(但是不支持传递额外的参数)
# 模版语法如何获取容器类型里面的数据 统一采用句点符 .
.key
.index
.key.index.index.key
```
* 过滤器
```python
# 语法结构 最多只能有两个参数
{{ data|过滤器:'参数'}}
|length
|default
|filesizeformat
|date:'Y-m-d' 前端
|slice:'0:6:2'
|truncatechars(包含三个点)
|truncatewords(不包含三个点 按空格切)
|add
|cut
|join
|safe 可以转义，解析
转义
# 前端
|safe
# 后端
from django.utils.safestring import mark_safe
res = mark_safe('<h1>baby</h1>')
"""
前端代码不一定非要在html页面上书写，也可以在后端生成然后传递给html页面!!!
"""
```
* 标签
```python
# for循环
{% for i in l %}
{{ forloop }}
{% empty %}
可迭代对象里面没有元素 没法for循环的时候自动走empty
{% endfor %}
counter
counter0
first
last
# if判断
{% if user %}
{% elif age %}
{% else %}
{% endif %}
# with起别名
{% with data.0.name.1.password.2.heiheihei as t%}
{{ t }}
{%endwith%}
# 模版语法也支持对字典获取键 值 键值对操作
.keys
.values
.items
```
* 自定义过滤器，，标签、inclusion_tag
```python
"""
1.在对应的应用下创建一个名字必须叫 templatetags 文件夹，还需要在setting中设置下，不然报错
2.该文件夹内创建一个任意名称的py文件 mytag.py
3.在该py文件内需要先书写两句固定的代码
from django import template
register = template.Library()
"""
# 自定义过滤器
@register.filter(name='过滤器的名字')
def index(v1,v2):
return v1 + v2
# 自定义标签
@register.simple_tag(name='标签的名字')
def func(*args):
pass
# 自定义inclusion_tag
@register.inclusion_tag('html文件名')
def bar(n):
return locals() # 传数据方式1
return {} # 传数据方式2
# 如何使用上述三者
{% load mytag %}
{{ data|过滤器的名字:'参数' }}
{% 标签的名字 参数1 参数2 参数3 参数4%}
{% bar %}
```
* 模版的继承
```python
"""
同一个html页面 想重复的使用大部分样式 只是局部修改
"""
# 继承
{% extends '模版页面名' %}
# 局部修改
# 1.你需要先去模版页面中划定可以被修改的区域
{% block '名字' %}
模版内容（666）
{% endblock %}
# 2.子页面中即成了模版页面之后 就可以根据名字修改
{% block '名字' %}
子版内容
子版页面吃了可以自己写自己的之外 还可以继续使用模版的内容
{{ block.super }} 666
{{ block.super }} 666
{{ block.super }} 666
{{ block.super }} 666
{% endblock %}
# 规律:一般情况下模版页面内至少应该有三块区域
css
html
js
所有的子页面中 都可以有自己独立的css html 和js
# 利用模版的继承 能够让你的页面更加的好维护
```
* 模版的导入
```python
{% include '模版文件名' %}
```
# 今日内容概要(重要)
模型层(ORM语法):跟数据库打交道的
* 单表查询(增删改查)
* 常见的十几种查询方法
* 神奇的双下划线查询
* 多表操作
* 外键字段的增删改查
* 跨表查询(重点)
* 子查询
* 联表查询
* 聚合查询
* 分组查询
* F与Q查询
# 今日内容详细
### 单表操作
```python
# django自带的sqlite3数据库对日期格式不是很敏感 处理的时候容易出错
### 测试脚本
```python
"""
当你只是想测试django中的某一个py文件内容 那么你可以不用书写前后端交互的形式
而是直接写一个测试脚本即可
脚本代码无论是写在应用下的tests.py还是自己单独开设py文件都可以
"""
# 测试环境的准备 去manage.py中拷贝前四行代码 然后自己写两行 import os import sys if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day64.settings") import django django.setup() # 在这个代码块的下面就可以测试django里面的单个py文件了
model表代码
from django.db import models # Create your models here. class User(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() register_time = models.DateField() # 年月日 """ DateField DateTimeField 两个重要参数 auto_now:每次操作数据的时候 该字段会自动将当前时间更新 auto_now_add:在创建数据的时候会自动将当前创建时间记录下来 之后只要不认为的修改 那么就一直不变 """ def __str__(self): return '对象:%s'%self.name class Book(models.Model): title = models.CharField(max_length=32) price = models.DecimalField(max_digits=8,decimal_places=2) publish_date = models.DateField(auto_now_add=True) # 一对多 publish = models.ForeignKey(to='Publish') # 多对多 authors = models.ManyToManyField(to='Author') class Publish(models.Model): name = models.CharField(max_length=32) addr = models.CharField(max_length=64) email = models.EmailField() # varchar(254) 该字段类型不是给models看的 而是给后面我们会学到的校验性组件看的 def __str__(self): return '对象:%s'%self.name class Author(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() # 一对一 author_detail = models.OneToOneField(to='AuthorDetail') class AuthorDetail(models.Model): phone = models.BigIntegerField() # 电话号码用BigIntegerField或者直接用CharField addr = models.CharField(max_length=64)
测试
# 增 # res = models.User.objects.create(name='jason',age=18,register_time='2002-1-21') # print(res) # import datetime # ctime = datetime.datetime.now() # user_obj = models.User(name='egon',age=84,register_time=ctime) # user_obj.save() # 删 # res = models.User.objects.filter(pk=2).delete() # print(res) """ pk 会自动查找到当前表的主键字段 指代的就是当前表的主键字段 用了pk之后 你就不需要指代当前表的主键字段到底叫什么了 uid pid sid ... """ # user_obj = models.User.objects.filter(pk=1).first() # user_obj.delete() # 修改 # models.User.objects.filter(pk=4).update(name='egonDSB') # user_obj = models.User.objects.get(pk=4) # user_obj = models.User.objects.filter(pk=6) 需要first，才能修改 """ get方法返回的直接就是当前数据对象 ，找不到会报错，就像 字典 用get不报错， []括号获取就会报错 但是该方法不推荐使用 一旦数据不存在该方法会直接报错 而filter则不会 所以我们还是用filter """ # user_obj.name = 'egonPPP' # user_obj.save() ```
### 必知必会13条
```python # 必知必会13条 # 1.all() 查询所有数据 # 2.filter() 带有过滤条件的查询 # 3.get() 直接拿数据对象 但是条件不存在直接报错 # 4.first() 拿queryset里面第一个元素 # res = models.User.objects.all().first() # print(res) # 5.last() # res = models.User.objects.all().last() # print(res) # 6.values() 可以指定获取的数据字段 select name,age from ... 列表套字典 # res = models.User.objects.values('name','age') # <QuerySet [{'name': 'jason', 'age': 18}, {'name': 'egonPPP', 'age': 84}]> # print(res) # 7.values_list() 相当于列表套元祖 # res = models.User.objects.values_list('name','age') # <QuerySet [('jason', 18), ('egonPPP', 84)]> # print(res) # """ # # 查看内部封装的sql语句 # 上述查看sql语句的方式 只能用于queryset对象 # 只有queryset对象才能够点击query查看内部的sql语句 # # """ # 8.distinct() 去重 # res = models.User.objects.values('name','age').distinct() # print(res) res = models.User.objects.all() # print(res.values('name', 'age')) #一种数据两种显示 # print(res.values_list("name","age")) print(res.values('name','age').distinct()) """ 去重一定要是一模一样的数据 如果带有主键那么肯定不一样 你在往后的查询中一定不要忽略主键 """ # 9.order_by() # res = models.User.objects.order_by('age') # 默认升序 # res = models.User.objects.order_by('-age') # 降序 # # print(res) # 10.reverse() 反转的前提是 数据已经排过序了 order_by() # res = models.User.objects.all() # res1 = models.User.objects.order_by('age').reverse() # print(res,res1) # 11.count() 统计当前数据的个数 # res = models.User.objects.count() # print(res) # 12.exclude() 排除在外 # res = models.User.objects.exclude(name='jason') # print(res) # 13.exists() 基本用不到因为数据本身就自带布尔值 返回的是布尔值 # res = models.User.objects.filter(pk=10).exists() # print(res) ```
```
### 查看内部sql语句的方式
```python
# 方式1
res = models.User.objects.values_list('name','age') # <QuerySet [('jason', 18), ('egonPPP', 84)]>
print(res.query)
queryset对象才能够点击query查看内部的sql语句
# 方式2:所有的sql语句都能查看
# 去配置文件中配置一下即可
LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console':{ 'level':'DEBUG', 'class':'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'propagate': True, 'level':'DEBUG', }, } }
```
### 神奇的双下划线查询
```python
# 神奇的双下划线查询 # 1 年龄大于35岁的数据 # res = models.User.objects.filter(age__gt=35) # print(res) # 2 年龄小于35岁的数据 # res = models.User.objects.filter(age__lt=35) # print(res) # 大于等于 小于等于 # res = models.User.objects.filter(age__gte=32) # print(res) # res = models.User.objects.filter(age__lte=32) # print(res) # 年龄是18 或者 32 或者40 # res = models.User.objects.filter(age__in=[18,32,40]) # print(res) # 年龄在18到40岁之间的 首尾都要 # res = models.User.objects.filter(age__range=[18,40]) # print(res) # 查询出名字里面含有s的数据 模糊查询 # res = models.User.objects.filter(name__contains='s') # print(res) # # 是否区分大小写 查询出名字里面含有p的数据 区分大小写 # res = models.User.objects.filter(name__contains='p') # print(res) # 忽略大小写 # res = models.User.objects.filter(name__icontains='p') # print(res) # res = models.User.objects.filter(name__startswith='j') # res1 = models.User.objects.filter(name__endswith='j') # # print(res,res1) # 查询出注册时间是 2020 1月 # res = models.User.objects.filter(register_time__month='1') # res = models.User.objects.filter(register_time__year='2020')
```
### 一对多外键增删改查
```python
# 一对多外键增删改查 # 增，先写字表，才可以在多的一方插入数据 # 1 直接写实际字段 id # models.Book.objects.create(title='论语',price=899.23,publish_id=1) # models.Book.objects.create(title='聊斋',price=444.23,publish_id=2) # models.Book.objects.create(title='老子',price=333.66,publish_id=1) # 2 虚拟字段 对象 # publish_obj = models.Publish.objects.filter(pk=2).first() # models.Book.objects.create(title='红楼梦',price=666.23,publish=publish_obj) # 删 # models.Publish.objects.filter(pk=1).delete() # 级联删除,需要注意 # 修改，两种方式 # models.Book.objects.filter(pk=1).update(publish_id=2)
----------------------------------------
# publish_obj = models.Publish.objects.filter(pk=1).first() # models.Book.objects.filter(pk=1).update(publish=publish_obj) ```
### 多对多外键增删改查
```python # 如何给书籍添加作者？ book_obj = models.Book.objects.filter(pk=1).first() # print(book_obj.authors) # 就类似于你已经到了第三张关系表了 # book_obj.authors.add(1) # 书籍id为1的书籍绑定一个主键为1 的作者，两个主键都是 1 # book_obj.authors.add(2,3) 给 pk 为1 的书籍增加两条 作者为2 的记录 # author_obj = models.Author.objects.filter(pk=1).first() # author_obj1 = models.Author.objects.filter(pk=2).first() # author_obj2 = models.Author.objects.filter(pk=3).first() # book_obj.authors.add(author_obj) # book_obj.authors.add(author_obj1,author_obj2) """ add给第三张关系表添加数据 括号内既可以传数字也可以传对象 并且都支持多个 """ # 删 # book_obj.authors.remove(2) # book_obj.authors.remove(1,3) # author_obj = models.Author.objects.filter(pk=2).first() # author_obj1 = models.Author.objects.filter(pk=3).first() # book_obj.authors.remove(author_obj,author_obj1) """ remove 括号内既可以传数字也可以传对象 并且都支持多个 """ # 修改 # book_obj.authors.set([1,2]) # 括号内必须给一个可迭代对象 相当于建立 1，2； 1，1 # book_obj.authors.set([3]) # 括号内必须给一个可迭代对象 # author_obj = models.Author.objects.filter(pk=2).first() # author_obj1 = models.Author.objects.filter(pk=3).first() # book_obj.authors.set([author_obj,author_obj1]) # 括号内必须给一个可迭代对象 """ set 括号内必须传一个可迭代对象，该对象内既可以数字也可以对象 并且都支持多个,没有的话便是增加 """ # 清空 # 在第三张关系表中清空某个书籍与作者的绑定关系 book_obj.authors.clear() """ clear 括号内不要加任何参数 """ ```
### 正反向的概念
```python # 正向 # 反向 外键字段在我手上那么，我查你就是正向 外键字段如果不在手上，我查你就是反向 book >>>外键字段在书那儿(正向)>>> publish publish >>>外键字段在书那儿(反向)>>>book 一对一和多对多正反向的判断也是如此 """ 正向查询按字段 反向查询按表名小写 _set ... """ ```
# 多表查询
### 子查询(基于对象的跨表查询)
```python
# 1.查询书籍主键为1的出版社
# book_obj = models.Book.objects.filter(pk=1).first()
# # 书查出版社 正向
# res = book_obj.publish
# print(res)
# print(res.name)
# print(res.addr)
# 2.查询书籍主键为2的作者
# book_obj = models.Book.objects.filter(pk=2).first()
# # 书查作者 正向
# # res = book_obj.authors # app01.Author.None
# res = book_obj.authors.all() # <QuerySet [<Author: Author object>, <Author: Author object>]>
#
# print(res)
# 3.查询作者jason的电话号码
# author_obj = models.Author.objects.filter(name='jason').first()
# res = author_obj.author_detail
# print(res)
# print(res.phone)
# print(res.addr)
"""
在书写orm语句的时候跟写sql语句一样的
不要企图一次性将orm语句写完 如果比较复杂 就写一点看一点
正向什么时候需要加.all()
当你的结果可能有多个的时候就需要加.all()
如果是一个则直接拿到数据对象
book_obj.publish
book_obj.authors.all()
author_obj.author_detail
"""
# 4.查询出版社是东方出版社出版的书
# publish_obj = models.Publish.objects.filter(name='东方出版社').first()
# 出版社查书 反向
# res = publish_obj.book_set # app01.Book.None
# res = publish_obj.book_set.all()
# print(res)
# 5.查询作者是jason写过的书
# author_obj = models.Author.objects.filter(name='jason').first()
# 作者查书 反向
# res = author_obj.book_set # app01.Book.None
# res = author_obj.book_set.all()
# print(res)
# 6.查询手机号是110的作者姓名
# author_detail_obj = models.AuthorDetail.objects.filter(phone=110).first()
# res = author_detail_obj.author
# print(res.name)
"""
基于对象
反向查询的时候
当你的查询结果可以有多个的时候 就必须加_set.all() ：多对多，，一对多
当你的结果只有一个的时候 不需要加_set.all()
自己总结出 自己方便记忆的即可 每个人都可以不一样
"""
```
### 联表查询(基于双下划线的跨表查询)
```python # 基于双下划线的跨表查询 # 1.查询jason的手机号和作者姓名 # res = models.Author.objects.filter(name='jason').values('author_detail__phone','name') # print(res) # 反向 # res = models.AuthorDetail.objects.filter(author__name='jason') # 拿作者姓名是jason的作者详情 # res = models.AuthorDetail.objects.filter(author__name='jason').values('phone','author__name') # print(res) # 2.查询书籍主键为1的出版社名称和书的名称 # res = models.Book.objects.filter(pk=1).values('title','publish__name') # print(res) # 反向 # res = models.Publish.objects.filter(book__id=1).values('name','book__title') # print(res) # 3.查询书籍主键为1的作者姓名 # res = models.Book.objects.filter(pk=1).values('authors__name') # print(res) # 反向 # res = models.Author.objects.filter(book__id=1).values('name') # print(res) # 查询书籍主键是1的作者的手机号 # book author authordetail # res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone') # print(res) """ 你只要掌握了正反向的概念 以及双下划线 那么你就可以无限制的跨表 """
```
### 周末作业
```python
"""
今日作业
必做题
1.整理今日内容 用自己的话术整理到博客中(切勿直接复制粘贴)
独立完成以下任务
2.自己手动创建图书管理系统表及数据录入
3.独立完成单表查询N条方法，双下划线方法
4.将课上orm题目摘出来，自己完成orm语句书写，体会orm简便之处
选做题
1.图书管理系统 图书表的增删改查
（只需要完成图书表的就可以）
"""
```
