Django框架(五)
定义模型类
from django.db import models
# Create your models here.
class User(models.Model):
uid = models.AutoField(primary_key=True, verbose_name='编号')
name = models.CharField(max_length=32, verbose_name='姓名')
age = models.IntegerField(verbose_name='年龄')
join_time = models.DateTimeField(auto_now_add=True)
补充知识
# 1、存储时间格式数据：
models.DateField() # 日期字段：存储年月日
models.DateTimeField() # 日期字段：存储年月日时分秒
# 日期字段重要参数
auto_now : 每次更新操作数据的时候 该字段会自动将当前时间更新
auto_now_add : 在创建数据的时候会自动将当前创建时间记录下来，之后只要不人为的修改，那么时间就一直不变
# 2、pk关键字
作用：pk会自动查找到当前表的主键字段 指代的就是当前表的主键字段
优点：用了pk之后 你就不需要指代当前表的主键字段到底叫什么了(nid,pid,uid....)
# 3、.get()方法
作用：.get()方法可直接拿到当前用户对象
eg：
user_obj = models.User.objects.get(pk=1) # 直接拿到id=1的用户对象
相当于：
user_obj = models.User.objects.filter(pk=1).first()
# 但是不推荐使用get方法：因为一旦数据不存在那么使用该方法就会立刻报错，而使用filter方法如果数据不存在则返回空列表[]不会报错
执行数据库迁移命令
方式一：使用命令行
python manage.py makemigrations
python manage.py migrate
方式二：使用pycharm快捷方式
上方菜单栏里找到并点击Tools——Run manage.py Task，依次执行下面两条语句即可
makemigrations
migrate
使用pychram连接mysql
一、修改配置文件
二、连接mysql
编写测试脚本
当我们只想操作django中某一个py文件内容时，那么可以不用书写前后端交互的形式来判断运行结果是否正确，我们可以直接写一个测试脚本即可。
- 在我们创建应用的时候，会自动创建一个tests.py文件，我们可以在这里编写测试脚本。
from django.test import TestCase
# Create your tests here.
# 测试环境准备：去manage.py文件中拷贝下述代码到测试文件，然后自己配置两行，如下：
import os
# from app01 import models.py 不可以写在这里
def main():
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djangoProject1.settings')
import django
django.setup() # 相当于启动django
from app01 import models
print(models.User.objects.filter())
# 注意：如果测试的脚本需要用到模块，必须写在配置好的环境下面，不可在最外层导入模块使用
if __name__ == '__main__':
main()
- pycharm也提供了一种测试环境
单表操作
表的新增
# 方式一：
res = models.User.objects.create(name='jack',age=19,register_time='2000-1-2')
print(res) # 返回值为当前被创建对象本身
# 方式二：
import datetime
ctime = datetime.datetime.now() # 当前时间
user_obj = models.User(name='tom',age=10,register_time=ctime) # 也可存入一个日期对象
user_obj.save()
表的删除
# 方式一：
res = models.User.objects.filter(pk=2).delete()
print(res) # 返回值为当前sql语句影响的行数(到底删了几行)
# 方式二：
user_obj = models.User.objects.filter(pk=1).first() # 拿到当前用户对象
user_obj.delete() # 用户对象也有delete方法
表的修改
# 方式一：
models.User.objects.filter(pk=4).update(name='tom2222') # 匹配到id=4的记录并只修改name属性
# 方式二：
user_obj = models.User.objects.get(pk=4)
user_obj.name = 'tom3333'
user_obj.save()
ORM常见查询关键字
1.all()
# 查询所有数据
res = models.User.objects.all() # 括号内不可添加筛选条件
print(res)
# 结果：<QuerySet [<User: 对象：jack>, <User: 对象：tom>]>
2.filter()
# 带有过滤条件的查询
res = models.User.objects.filter(pk=2) # 括号内可添加筛选条件
print(res)
# 结果：<QuerySet [<User: 对象：tom>]>
3.get()
# 直接拿数据对象，但是条件所匹配的数据不存在则直接报错
res = models.User.objects.get(pk=2)
print(res) # 结果 对象：tom
res1 = models.User.objects.get(pk=3)
print(res1) # 结果 报错
4.first()
# 拿queryset里面的第一个元素
res = models.User.objects.filter().first()
print(res)
# 结果：对象：jack
5.last()
# 拿queryset里面的最后一个元素
res = models.User.objects.filter().last()
print(res)
# 结果：对象：tom
6.values()
# 可指定获取的字段，返回结果可以看作是列表套字典的形式
# 拿到所有用户的信息
res = models.User.objects.values()
print(res)
# 结果：<QuerySet [{'id': 1, 'name': 'jack', 'age': 19, 'register_time': datetime.date(2000, 1, 2)}, {'id': 2, 'name': 'tom', 'age': 10, 'register_time': datetime.date(2022, 2, 26)}]> # 列表套字典的形式
eg:
# 1、只拿用户的名字
res = models.User.objects.values('name')
print(res)
# 结果：<QuerySet [{'name': 'jack'}, {'name': 'tom'}]>
# 2、只拿用户的名字和年龄
res = models.User.objects.values('name','age')
print(res)
# 结果：<QuerySet [{'name': 'jack', 'age': 19}, {'name': 'tom', 'age': 10}]>
相当于sql语句：select name,age from user
7.values_list()
# 同样可以指定需要获取的字段
# 但返回结果可以看作是列表套元组的形式
res = models.User.objects.values()
print(res)
# 结果：<QuerySet [(1, 'jack', 19, datetime.date(2000, 1, 2)), (2, 'tom', 10, datetime.date(2022, 2, 26))]>
8.distinct()
# 去重
# 注意：去重一定要是一摸一样的数据(一定要考虑主键),一个对象如果包含主键的话永远去不了重复数据
res = models.User.objects.filter().distinct()
print(res) # 查所有：无意义，因为包含主键
res1= models.User.objects.values('name').distinct()
print(res1) # 按照name字段去重
# 结果：
# <QuerySet [<User: 对象：jack>, <User: 对象：tom>, <User: 对象：jack>, <User: 对象：gary>]>
# <QuerySet [{'name': 'jack'}, {'name': 'tom'}, {'name': 'gary'}]>
9.order_by()
# 排序
.order_by('age') # 默认升序
.order_by('-age') # 降序在参数前加一个-
# eg：
res1 = models.User.objects.values('age').order_by('age')
print(res1) # 升序
res = models.User.objects.order_by('-age')
print(res) # 降序
10.reverse()
# 反转
# 前提：数据已经排序了，如果没排序是不支持反转的，必须提前排序过。
order_by().reverse() # 通常情况下跟order_by联合使用
# eg：
res = models.User.objects.filter().reverse()
print(res)
res1 = models.User.objects.order_by('age')
res2 = models.User.objects.order_by('age').reverse()
print(res2)
11.count()
# 统计当前数据的个数
res = .count()
# eg：
res = models.User.objects.filter().count()
print(res) # 统计所有数据对象的个数
res = models.User.objects.values('name').distinct().count()
print(res) # 按照name去重之后统计数据个数
# 结果：
4
3
12.exclude()
# .exclude() # 排除(括号内匹配成功)之外的数据
# eg：
res = models.User.objects.exclude(name='jack')
print(res)
# 查询name = 'jack'之外的数据
13.exists()
# 判断是否存在 返回的是布尔值
# 作用不大：因为数据本身就存在布尔值
# eg：
res = models.User.objects.filter(pk=1).exists()
print(res)
res1 = models.User.objects.filter(pk=200)
print(res1)
res2 = models.User.objects.filter(pk=200).exists()
print(res2)
# 结果：
True
<QuerySet []>
False
14.raw()
执行SQL语句
还可以借助于模块
from django.db import connection
cursor = connection.cursor()
cursor.execute("insert into hello_author(name) VALUES ('郭敬明')")
cursor.execute("update hello_author set name='韩寒' WHERE name='郭敬明'")
cursor.execute("delete from hello_author where name='韩寒'")
cursor.execute("select * from hello_author")
cursor.fetchone()
cursor.fetchall()
ORM双下划线查询方法
比较运算
# 关键字：
大于： __gt
小于： __lt
大于等于： __gte
小于等于： __lte
# 举例：
res = models.User.objects.filter(age__gt=20)
print(res) # 年龄大于20
res1 = models.User.objects.filter(age__lt=30)
print(res) # 年龄小于30
res2 = models.User.objects.filter(age__gte=19)
print(res2) # 年龄大于等于19
res3 = models.User.objects.filter(age__lte=30)
print(res3) # 年龄小于等于30
在某一数据集内
# 关键字：__in=['数据集']
# 举例：
res = models.User.objects.filter(age__in=[10,20,30,40])
print(res)
在某一范围内
# 关键字：__range=[]
# 举例：
res = models.User.objects.filter(age__range=[19,40])
print(res)
模糊查询
# 关键字：__contain='' 区分大小写
__icontain='' 不区分大小写
# 举例：
res = models.User.objects.filter(name__contains='k')
print(res)
res1 = models.User.objects.filter(name__icontains='k')
print(res1)
以什么开头/结尾
# 关键字：__startswith='' 以什么开头
__endswith='' 以什么结尾
__istartswith='' 不区分大小写
__iendswith='' 不区分大小写
按照日期查询
# 关键字：
__month='1' # 按照月份取
__year='2020' # 按照年份
__day='29' # 按照天筛选
__weekday='' # 按照日期
# 举例：
res = models.User.objects.filter(register_time__month='01')
print(res)
res1= models.User.objects.filter(register_time__day='02')
print(res1)
res2= models.User.objects.filter(register_time__week_day='02')
print(res2)
res3 = models.User.objects.filter(register_time__year='2022')
print(res3)
res4 = models.User.objects.filter(register_time__year='2022',register_time__month='02')
print(res4)
查看ORM底层SQL语句
# .query方法
.query方法可查看内部封装的sql语句
但是使用该方法查看sql语句的方式，只能用于queryset对象属性
只有返回结果为queryset对象才能够使用
eg:
res1 = models.User.objects.filter()
print(res1.query)
res = models.User.objects.get(name='jack')
print(res.query)
# 解决：所有的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',
},
}
}
ORM外键字段的创建
一对多
ORM中外键字段建在多的一方 models.ForeignKey()
会自动添加_id后缀
多对多
ORM中有三种创建多对多字段的方式 models.ManyToManyField()
方式1:直接在查询频率较高的表中填写字段即可 自动创建第三张关系表
方式2:自己创建第三张关系表
方式3:自己创建第三张关系表 但是还是要orm多对多字段做关联
一对一
ORM中外键字段建在查询频率较高的表中 models.OneToOneField()
会自动添加_id后缀
django1.X 针对 models.ForeignKey() models.OneToOneField()不需要on_delete
django2.X 3.X 则需要添加on_delete参数
ORM多表操作
多表操作前期准备
models.py
class Book(models.Model):
name = models.CharField(max_length=32,verbose_name='书名')
price = models.DecimalField(max_digits=8,decimal_places=2,verbose_name='价格')
publish_date = models.DateTimeField(auto_now_add=True,verbose_name='出版时间')
publish = models.ForeignKey('Publish') # 一对多
authors = models.ManyToManyField('Author') # 多对多
class Publish(models.Model):
name = models.CharField(max_length=32,verbose_name='出版社名字')
addr = models.CharField(max_length=32,verbose_name='出版社地址')
class Author(models.Model):
name = models.CharField(max_length=32,verbose_name='作者名字')
age = models.IntegerField(verbose_name='作者年龄')
author_detail = models.OneToOneField('AuthorDetails') # 一对一
class AuthorDetails(models.Model):
phone = models.BigIntegerField(verbose_name='作者电话')
addr = models.CharField(max_length=32,verbose_name='作者地址')
一对多外键增删改查
# 一对多外键增加数据
# 方式一：直接写实际字段
models.Book.objects.create(name='红楼梦',price=111.11,publish_id=1)
# 方式二：虚拟字段
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.create(name='三国演义',price=22.5,publish=publish_obj)
# 一对多外键删除数据
models.Pulish.objects.filter(pk=1).delete()
# 删除记录是级联删除的，所以对应的外键字段一会直接删除，取消关联关系
# 一对多外键修改数据
# 方式一：直接写实际字段
models.Book.objects.filter(pk=1).update(publish_id=2)
# 方式二：虚拟字段
publist_obj = models.Publish.objects.filter(pk=3).first()
models.Book.objects.filter(pk=2).update(publish=publist_obj)
多对多外键增删改查
# 多对多的增删改查其实就是在操作第三张虚拟表
# 先思考一个问题，如何添加作者
# 这张表不是我们自己创建的是系统帮助我们创建的，所以我们根本不能通过models的方法(.)到这张表
# 这里就要通过对象(.)外键的方式找到第三张表
# 多对多表关系的增加：
# 关键字：.add(主键值)
# 方式一：
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.authors.add(1)
book_obj.authors.add(2,3) # 增加多个
# 方式二：
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) # 增加多个
# 多对多表关系的删：
# 关键字：.remove(主键值)
# 方式一：
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.authors.remove(2,3) # 同样支持多条数据同时删除
# 方式二：对象
book_obj1 = models.Book.objects.filter(pk=2).first()
author_obj1 = models.Author.objects.filter(pk=1).first()
author_obj2 = models.Author.objects.filter(pk=2).first()
author_obj3 = models.Author.objects.filter(pk=3).first()
book_obj1.authors.remove(author_obj1,author_obj2)
# 多对多表关系的修改
# 关键字：set()
# 方式一：
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.authors.set([2,3]) # 同样支持多条数据同时修改
# 方式二：对象
book_obj1 = models.Book.objects.filter(pk=2).first()
author_obj1 = models.Author.objects.filter(pk=1).first()
author_obj2 = models.Author.objects.filter(pk=2).first()
author_obj3 = models.Author.objects.filter(pk=3).first()
book_obj1.authors.set([author_obj1,author_obj2])
# 注意：set关键字括号内必须填写一个可迭代对象(列表或者元组)
# 多对多表关系的清空(清空在第三中某个书籍与作者的绑定关系)
# 关键字：clear() # 括号内不要加任何参数
正反向的概念
正反向的概念核心就在于外键字段在谁手上
正向查询
通过书查询出版社 外键字段在书表中
反向查询
通过出版社查询书 外键字段不在出版社表中
ORM跨表查询口诀>>>:正向查询按外键字段 反向查询按表名小写
基于对象的跨表查询(子查询)
# 查找主键值为1的书的出版社名字和出版社地址(正向)
book_obj = models.Book.objects.filter(pk=1).first() # 先拿到主键为1的书籍对象
res = book_obj.publish # 拿到外键字段所对应关系表中的对象
print(res) # 对应出版社的对象
print(res.name) # 出版社名字
print(res.addr) # 出版社地址
# 查询书籍主键为2的作者(正向)
book_obj = models.Book.objects.filter(pk=2).first()
res = book_obj.authors #
print(res)
# 我们发现返回了一个：app01.Author.None
# 注意这个返回结果是一个标志性的问题：在当返回结果可能为多个的时候(一本书可以由多名作者编写(多对多的表关系)必须加关键字.all())
# # 查询书籍主键为2的作者(正向)
book_obj = models.Book.objects.filter(pk=2).first()
res = book_obj.authors.all()
print(res)
print(res[0].name) # 因对象有多个所以要通过索引取值拿到单独的对象
print(res[1].name)
# 查询作者gary的电话号码(正向)
author_obj = models.Author.objects.filter(name='gary').first()
print(author_obj)
res = author_obj.author_detail
print(res)
print(res.phone)
print(res.addr)
# 查询是南方出版社出版的书(无外键字段(反向))
publish_obj = models.Publish.objects.filter(name='东方出版社').first()
res = publish_obj.book
print(res)
# 反向查询上边有提到需要加入_set
# 查询是南方出版社出版的书(无外键字段(反向))
publish_obj = models.Publish.objects.filter(name='南方出版社').first()
res = publish_obj.book_set.all() # 并且使用到.all()方法
print(res)
# 5.查询作者是jason写过的书
author_obj = models.Author.objects.filter(name='jason').first()
res = author_obj.book_set.all()
print(res)
# 6.查询手机号是110的作者姓名
authorsetails_obj = models.AuthorDetails.objects.filter(phone='110').first()
res1 = authorsetails_obj.author
print(res1)
总结：
# 基于对象
反向查询的时候
当你的查询结果可能有多个的时候 就必须加_set.all()
当你的结果只能有一个的时候 不需要加_set.all()
基于双下划线的跨表查询(连表操作)
# 同样遵循
# 正向查询按字段
# 反向查询按表名小写
# 查询作者gary的手机号(必须用一行代码展示)
res = models.Author.objects.filter(name='gary').values('author_detail__phone'，'name')
print(res)
# 利用values方法查询
注意：此时Author为基表可通过values方法直接查到该表的属性值
# 反向：(不允许.Author)
res = models.AuthorDetails.objects.filter(author__name='gary').values('phone','author__name')
print(res)
# 查询书籍主键为1的出版社的名称和书的名称
res = models.Book.objects.filter(pk=1).values('name','publish__book')
print(res)
# 方式二：反向
res = models.Publish.objects.filter(book__id='1').values('name','book__name')
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的作者的手机号
# 注意：这道题涉及到三张表
# 思路：通过书籍查作者，再通过作者查作者详情
res = models.Book.objects.filter(pk=1).values('authors__author_detail__phone')
