ORM单表查询，跨表查询，分组查询
queryset特性和queryset优化
select_related 和 prefetch_relat查询优化
ORM的概念
ORM是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。
ORM在业务逻辑层和数据库层之间充当了桥梁的作用。
ORM的优势:ORM解决的主要问题是对象和关系的映射
ORM提供了对数据库的映射，不用直接编写SQL代码，只需像操作对象一样从数据库操作数据。
ORM的劣势:在一定程度上牺牲程序的执行效率。
ORM是“对象-关系-映射”的简称
MVC或者MTV框架中包括一个重要的部分，就是ORM，它实现了数据模型与数据库的解耦，即数据模型的设计不需要依赖于特定的数据库
在Django中使用ORM连接Mysql
''' 1. 手动创建数据库 2. 在settings.py里面配置一下数据库的连接信息（告诉Django连接哪一个数据库） DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', # 连接数据库的类型 'NAME': 'day62xiawu', # 数据库名字 'HOST': '127.0.0.1', # IP 'PORT': 3306, # 端口 'USER': 'root', # 用户名 'PASSWORD': '123456', # 密码 } } 3. 在和settings.py同目录下的__init__.py文件中，告诉Django用pymysql代替MySQLdb来连接数据库 import pymysql pymysql.install_as_MySQLdb() 4. 在app/models.py中，定义类，类一定要继承models.Model class Book(models.Model): id = models.AutoField(primary_key=True) title = models.CharField(max_length=32) 5. 执行两条命令 1. 在哪儿执行？ 在项目的根目录（有manage.py文件的那个目录） 2. 命令 python manage.py makemigrations --> 将models.py文件中的改动记录在小本本（app/migrations/00xx_****.py）上 python manage.py migrate --> 将改动翻 '''
常用字段
'''
1.AutoField
int自增列，必须填入参数 primary_key=True 没有自增列，则自动会创建一个列名为id的列。
因此在创建表的时候id不写，也能创建成功，默认创建一个id字段
id=models.AutoField(primary_key=True)
2.IntegerField(10位的长度）
整数类型,范围在 -2147483648 to 2147483647。
使用IntegerField类型不能存手机号，手机号是11位。用来存age
BigIntegerField（19位）可以用来存手机号
3.CharField：表示varcharage=models.IntegerField()
字符类型，必须提供max_length参数， max_length表示字符长度。
name=models.CharField(max_length=255)
4.DecimalField 10进制小数
参数：max_digits，小数总长度
decimal_places，小数位长度
5.自定义char类型字段：
class FixedCharField(models.Field):
"""
自定义的char类型的字段类
"""
def __init__(self, max_length, *args, **kwargs):
self.max_length = max_length
super(FixedCharField, self).__init__(max_length=max_length, *args, **kwargs)
def db_type(self, connection):
"""
限定生成数据库表的字段类型为char，长度为max_length指定的值
"""
return 'char(%s)' % self.max_length
class Class(models.Model):
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=25)
# 使用自定义的char类型的字段
cname = FixedCharField(max_length=25)
6.DateField 日期字段，日期格式 YYYY-MM-DD 相当于Python中的datetime.date()实例
DateTimeField 日期时间字段，格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] 相当于Python中的datetime.datetime()
DateField和DateTimeField有两个属性：
1. auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。相当于人的生日
2.auto_now=True，每次更新数据记录的时候会更新该字段
不能同时用，一般都设置auto_now_add=True
birthdy=models.DateField(auto_now_add=True)
在表中添加数据时需要手动添加birthday 在create创建时，不用添加birthday，会自动添加
7.datetime.timedelta类型
求失效的时间
import datetime
now=datetime.datetime.now()
print(now)
#有效其七天
d7=datetime.timedelta(days=7) #也可以weeks，不能years 一年52周
ret=now+d7
print(ret)
8.FileField 文件类型
绑定上传的文件到表单,后台接收request.FIlES
为了上传文件,需要确保你的<form> 元素正确定义enctype 为"multipart/form-data"：
<form enctype="multipart/form-data" method="post" action="/foo/">
avatar = models.FileField(upload_to="avatars/", default="avatars/default.png", verbose_name="头像")
def upload(request):
if request.method=="POST":
file_obj=request.FIlES.get('upload_file')
filename=file_obj.name
with open(filename,"wb") as f:
for line in file_obj:
f.write(line)
return HttpResponse("上传成功")
return render(request,"upload.html")
'''
字段合集
AutoField(Field) - int自增列，必须填入参数 primary_key=True BigAutoField(AutoField) - bigint自增列，必须填入参数 primary_key=True 注：当model中如果没有自增列，则自动会创建一个列名为id的列 from django.db import models class UserInfo(models.Model): # 自动创建一个列名为id的且为自增的整数列 username = models.CharField(max_length=32) class Group(models.Model): # 自定义自增列 nid = models.AutoField(primary_key=True) name = models.CharField(max_length=32) SmallIntegerField(IntegerField): - 小整数 -32768 ～ 32767 PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) - 正小整数 0 ～ 32767 IntegerField(Field) - 整数列(有符号的) -2147483648 ～ 2147483647 PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField) - 正整数 0 ～ 2147483647 BigIntegerField(IntegerField): - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807 BooleanField(Field) - 布尔值类型 NullBooleanField(Field): - 可以为空的布尔值 CharField(Field) - 字符类型 - 必须提供max_length参数， max_length表示字符长度 TextField(Field) - 文本类型 EmailField(CharField)： - 字符串类型，Django Admin以及ModelForm中提供验证机制 IPAddressField(Field) - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制 GenericIPAddressField(Field) - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6 - 参数： protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6" unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol="both" URLField(CharField) - 字符串类型，Django Admin以及ModelForm中提供验证 URL SlugField(CharField) - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号） CommaSeparatedIntegerField(CharField) - 字符串类型，格式必须为逗号分割的数字 UUIDField(Field) - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证 FilePathField(Field) - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能 - 参数： path, 文件夹路径 match=None, 正则匹配 recursive=False, 递归下面的文件夹 allow_files=True, 允许文件 allow_folders=False, 允许文件夹 FileField(Field) - 字符串，路径保存在数据库，文件上传到指定目录 - 参数： upload_to = "" 上传文件的保存路径 storage = None 存储组件，默认django.core.files.storage.FileSystemStorage ImageField(FileField) - 字符串，路径保存在数据库，文件上传到指定目录 - 参数： upload_to = "" 上传文件的保存路径 storage = None 存储组件，默认django.core.files.storage.FileSystemStorage width_field=None, 上传图片的高度保存的数据库字段名（字符串） height_field=None 上传图片的宽度保存的数据库字段名（字符串） DateTimeField(DateField) - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] DateField(DateTimeCheckMixin, Field) - 日期格式 YYYY-MM-DD TimeField(DateTimeCheckMixin, Field) - 时间格式 HH:MM[:ss[.uuuuuu]] DurationField(Field) - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型 FloatField(Field) - 浮点型 DecimalField(Field) - 10进制小数 - 参数： max_digits，小数总长度 decimal_places，小数位长度 BinaryField(Field) - 二进制类型 字段合集
字段参数
1.null:null 是针对数据库而言,如果 null=True, 表示数据库的该字段可以为空
blank 是针对表单的，如果 blank=True，表示你的表单填写该字段的时候可以不填，但是对数据库来说，没有任何影响
2.unique：如果设置为unique=True 则该字段在此表中必须是唯一的。如身份证号，手机号都要设置唯一的
3.db_index：如果db_index=True 则代表着为此字段设置索引
4.default
关系字段
ForeignKey
外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多'中'多'的一方
字段参数：
1.to：设置要关联的表
2to_field 设置要关联的表的字段
3.related_name：用于代替原反向查询时的'表名_set。即关系表中少的一方要查询多的一方时
一个班级中有多个学生，学生是多的一方
class Classes(models.Model):
name = models.CharField(max_length=32)
class Student(models.Model):
name = models.CharField(max_length=32)
the_class = models.ForeignKey(to="Classes")
正向查询：student_obj=models.Student.objects.filter(pk=1).first()
print(student_obj.the_class.name)
反向查询：表名_set 查询某个班级关联的所有学生：models.Classes.objects.first().student_set.all()
在ForeignKey字段中添加了参数 related_name 后 the_class = models.ForeignKey(to="Classes", related_name="students") models.Classes.objects.first().students.all()
4.on_delete 当删除关联表中的数据时，当前表与其关联的行的行为
models.CASCADE 删除关联数据，与之关联也删除
publisher = models.ForeignKey(to="Publisher",on_delete=models.CASCADE)
models.SET_NULL 删除关联数据，与之关联的值设置为null
# 表示外键关联到作者表,当作者表删除了该条数据,图书表中不删除,仅仅是把外键置空
author = models.ForeignKey(AuthModel, null=True, blank=True, on_delete=models.SET_NULL)
models.SET_DEFAULT 删除关联数据，与之关联的值设置为默认值 models.SET 删除关联数据，
a. 与之关联的值设置为指定值，设置：models.SET(值) b. 与之关联的值设置为可执行对象的返回值，
设置：models.SET(可执行对象) publisher = models.ForeignKey(to="Publisher",on_delete=models.SET(10)
OneToOneField
通常一对一字段用来扩展已有字段。
把常用的字段放在一张表中，不常用的字段放到另一张表中
比如作者姓名和名字经常用到，而年龄和地址不经常用到，就把年龄和地址放到另一张表中
class Person(models.Model): id=models.AutoField(primary_key=True) name=models.CharField(max_length=255) detail=models.OneToOneField(to="PersonDetail") class PersonDetail(models.Model): age=models.IntegerField() addr=models.TextField() 正向查询： egon=models.Person.objects.filter(name="egon").first() print(egon.detail.age) 反向查询： authorDetail_list=models.PersonDetail.objects.filter(addr="beijing") for obj in authorDetail_list: print(obj.person.name)
ManyToManyField
用于表示多对多的关联关系。在数据库中通过第三张表来建立关联关系
1.自己关联自己的表 朋友的信息也存在Person这张表中。关联的话仍关联Person这张表。用于评论功能
class Person(models.Model): name = models.CharField(max_length=16) friends = models.ManyToManyField("self")
2.symmetrical
仅用于多对多自关联时，指定内部是否创建反向操作的字段。默认为True。不能进行反向查询。
可以使用person_set属性进行反向查询 db_table可自定义第三张表的表名
class Person(models.Model): name = models.CharField(max_length=16) friends = models.ManyToManyField("self", symmetrical=False db_table="表名"
class Author(models.Model): id = models.AutoField(primary_key=True) name = models.CharField(max_length=16, null=False, unique=True) # 告诉ORM 我这张表和book表是多对多的关联关系,ORM自动帮我生成了第三张表 book = models.ManyToManyField(to="Book" related_name="books" ) 正向查询： book_obj=Book.objects.filter(title="后来的我们").first() authors=book_obj.authors.all() for author_obj in authors: print(author_obj.name,author_obj.authorDetail.telephone) 反向查询： author_obj=Author.objects.get(name="egon") book_list=author_obj.book_set.all() #与egon作者相关的所有书籍 book_list=author_obj.books.all() 添加related_name="books" for book_obj in book_list: print(book_obj.title)
增 删 改 查操作
操作ORM时,需要明白:
1 方法是由谁调用的,返回值是什么类型
2 queryset支持链式操作
Book.objects.filter().order_by().reverse().count()
from django.db import models # Create your models here. #出版社 单表 class Publisher(models.Model): id = models.AutoField(primary_key=True) # 创建一个自增的主键字段 name = models.CharField(max_length=64,null=False,unique=True) # 创建一个varchar(20)类型的不能为空的字段 # 书 两张表连接 class Book(models.Model): id = models.AutoField(primary_key=True) title = models.CharField(max_length=64,null=False,unique=True) publisher=models.ForeignKey(to="Publisher") #ForeignKey会自动在属性后面加id #作者表 多表连接 class Author(models.Model): id=models.BigAutoField(primary_key=True) name=models.CharField(max_length=16,null=False) book=models.ManyToManyField(to="Book") # 返回对象的属性 def __str__(self): return self.name
增 删 改 查的操作均在views.py中操作
编辑完要保存
以出版设为例：
1.单表的操作：
1.查询数据: 方式1:get-------Obj 得到具体对象 obj=models.Publisher.objects.get(id=1) 方式2:filter---->Queryset obj=models.Publisher.objects.filter(id=1).first() 2.添加数据: 方式1:create obj=Book.objects.create() 方式2:save obj=Book(title="A") obj.save() 或者:obj=Book() book.title="A" book.save() 3.修改数据: queryset=models.Publisher.object.filter(id=1) obj=models.Publisher.object.get(id=1) 方式1：update------->调用的对象必须是queryset queryset.update(price=100) 或者:queryset.update(**{"price":100}) 方式2:Obj---->使用对象 obj.name=new_name obj.save() 4.删除数据：delete queryset和obj均可使用 queryset.delete() model_obj.delete() models.Publisher.objects.get(id=1).delete()
2.外键的增删改查：增，删，查和单表一样
改：book_obj=models.Book.objects.get(id) book_obj.name 是书的名字。是一个属性 book_obj.publisher_id 是和书关联的出版社id值，是书的一个自身属性 book_obj.publisher 是和书关联的出版社对象。是一个对象 book_obj.publisher.id 出版社的id book_obj.publisher.name 出版社的名字
绑定一对多的关系:
book表中内容： id name publish_id 1 A 1 2 B 2 方法1：绑定关联的id值 book_obj=Book(title="A",publish_id=1) book.save() 方法2：绑定关联的对象 book_obj=Book(title="A",publish=publish_obj) book.save() 方法3: book=Book() book.title="A" book.publish=publish_obj book.save()
3.多对多的操作
绑定多对多的关系 book_authors id book_id author_id 1 1 1 2 1 2 3 1 3 1.查询id为1的作者写哪些书 author_obj=models.Author.objects.get(id=1) author_obj.books.all() 和作者关联的所有书对象（这些对象包括书的id，书名等信息） 2.书籍绑定作者:add book_obj=Book.objects.filter(pk=1).first() 方式1： book_obj.authors.add(1) 添加多个作者: book_obj.authors.add(1,2,3,4) 或者: book_obj.authors.add(*[1,2,3,4]) 方式2：添加作者对象 author_obj=Author.objects.get(pk=1) book_obj.authors.add(author_obj) 3.书籍移除作者：remove 方式1： book_obj.authors.remove(1) 移除多个作者： book_obj.authors.remove(2,3) 或者： book_obj.authors.remove(*[2,3]) 4.书籍清空作者:clear book_obj.authors.clear()
set的用法:一般用于编辑
set先清空数据再重新添加
原本绑定了id为1,2,3作者，使用set后，会将这3个作者清空，绑定id为8的作者
book_obj.authors.set(8)
添加多个作者时,不打散
book_obj.authors.set([1,2,3])
1.增加 在为书籍添加作者的时候，书籍已经创建。新建作者，然后显示出书籍列表，为其选择 在处理函数时，获取作者或关联的书籍，书籍是多选的不能用get获取 author=request.POST.get("author") # 书籍选择是多选的，不能用get，使用getlist books = request.POST.getlist("book") # 创建作者 new_author_obj = models.Author.objects.create(name=author) # 把新作者和书籍建立对应关系,自动提交 new_author_obj.books.set(books) author_obj.books.set([1,2,3]) 把id是1、2、3的书和我这个作者关联上 2.编辑时，修改完书籍直接使用set赋新值 book_id = request.POST.getlist("books") author_obj=models.Author.objects.get(id=author_id) author_obj.name=author_name author_obj.books.set(book_id) author_obj.save()
中介模型
student_course id student_id course_id 1 1 1
使用ManyToManyField字段,django默认会建立一张表,
这张表中只有三个字段,如果想定义其他字段，就需要使用给中介模型，通过through指定第3张表,在自定义的表中添加额外的字段
class Student(): name=.... courses=models.ManyToManyFiled(to="Course",through="student_course") class student_course(): student course score
在中介模型中 add/remove/set均无效
约会网站 记录约会时间
###约会记录##
# 男孩1 女孩1
# 男孩2 女孩2
# 男孩3 女孩3
class Boy(models.Model): name=models.CharField(max_length=32) def __str__(self): return self.name class Girl(models.Model): name=models.CharField(max_length=32) #through_fields("field1","field2") 多对多建在建在哪张表，field1就是这个表的名字 field2是目标表的名字 boys=models.ManyToManyField(to=Boy,through="Info",through_fields=("girl","boy")) #顺序不能颠倒 def __str__(self): return self.name class Info(models.Model): boy=models.ForeignKey(to=Boy) girl= models.ForeignKey(to=Girl) date=models.DateField(auto_now_add=True)
元信息
1.ORM对应的类里面包含另一个Meta类，而Meta类封装了一些数据库的信息。主要字段如下
db_table
ORM在数据库中的表名默认是 app_类名，可以通过db_table可以重写表名
class Meta:
db_table = "表名"
2.index_together 联合索引
3.unique_together 联合唯一索引
4.ordering
指定默认按什么字段排序 只有设置了该属性，我们查询到的结果才可以被reverse()
必会的查询操作
返回QuerySet的有：
1. all()
3. filter()
4. exclude()
7. values_list() --> 元祖
8. values() --> 字典
9. order_by()
10. reverse()
13. distinct()
返回对象：
2. get()
5. first()
6. last()
返回数字：
11. count()
返回布尔值：
12. exist()
<1> all(): 查询所有结果
<2> filter(**kwargs): 得到结果集 是个列表<QuerySet [<Publisher: Publisher object>]>
ret = models.Person.objects.filter(id=100) 不存在返回一个空的QuerySet，不会报错
就算查询的结果只有一个，返回的也是QuerySet，我们要用索引的方式取出第一个元素
ret = models.Person.objects.filter(id=1)[0]
<3> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
<4> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
<5> values(*field): 返回一个可迭代的字典序列
ret = models.Person.objects.values("name", "birthday") 返回一个QuerySet对象，里面都是字典。 不写字段名，默认查询所有字段
<6> values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
ret = models.Person.objects.values_list()
<7> order_by(*field): 对查询结果排序
ret = models.Person.objects.all().order_by("birthday")
<8> reverse(): 对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。
对有序的QuerySet才能调用reverse ret = models.Person.objects.all().count()
<9> distinct(): 从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)
<10> count(): 返回数据库中匹配查询(QuerySet)的对象数量。
<11> first(): 返回第一条记录
<12> last(): 返回最后一条记录
<13> exists(): 如果QuerySet包含数据，就返回True，否则返回False
#all print(models.Book.objects.all()) #得到对象的集合 <QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>]> #get print(models.Publisher.objects.get(id=1)) #得到的是对象Publisher object.返回结果有且只有一个,不存在会报错 #filter print(models.Publisher.objects.filter(id=1)) #得到结果集 是个列表<QuerySet [<Publisher: Publisher object>]> # 不存在返回一个空的QuerySet，不会报错 用索引的方式取出第一个元素 ret = models.Person.objects.filter(id=1)[0] # exclude得到不包含要求的对象 print(models.Book.objects.exclude(id=1)) #<QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>]> print(models.Book.objects.exclude(id=1)[0].title) #得到的是列表，使用索引得到指定的对象。得到其属性 #values返回 QuerySet对象 字典序列 print(models.Book.objects.values()) #<QuerySet [{'id': 1, 'title': '四世同堂', 'publisher_id': 2}, {'id': 2, 'title': 'python从入门到放弃', 'publisher_id': 1}, {'id': 3, 'title': '后来的我们', 'publisher_id': 2}]> #取其属性 print(models.Book.objects.values()[1]["title"]) #python从入门到放弃 print(models.Book.objects.values("title","price")) #values_list print(models.Book.objects.values_list("title", "price")) # order_by 按照指定的字段排序 升序 print(models.Book.objects.all().order_by( "price")) #reverse print(models.Person.objects.all().reverse()) #count print(models.Book.objects.all().count()) # first 返回QuerySet中第一个对象 print(models.Book.objects.first()) # last 返回QuerySet中最后一个对象 print(models.Book.objects.all().last()) # exists 判断表里有没有数据 print(models.Book.objects.exists())
Django终端打印SQL语句
在Django项目的settings.py文件中，在最后复制粘贴如下代码： 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脚本中调用Django环境
''' import os if __name__ == '__main__': os.environ.setdefault("DJANGO_SETTINGS_MODULE", "BMS.settings") #BMS为Django项目名 import django django.setup() '''
ORM中choice的用法
choices元组用于页面上的选择框标签,第一个元素表示存在数据库内真实的值，第二个表示页面上显示的具体内容
例如对应的时间：在数据库中存数字，在页面哈上显示对应的具体值
class Book(models.Model): time_choices = ( (1, '8:00'), (2, '9:00'), (3, '10:00'), (4, '11:00'), (5, '12:00'), (6, '13:00'), (7, '14:00'), (8, '15:00'), (9, '16:00'), (10, '17:00'), (11, '18:00'), (12, '19:00'), (13, '20:00'), ) time_now = models.IntegerField(choices=time_choices)
得到choices的内容get_字段_display()
obj.get_time_now_display() 得到的是具体的时间点"8:00"