django 数据库操作

MySQL驱动程序安装Mysql相关操作数据库相关命令表相关命令增查 django操作mysql原生mysql语句操作使用ORM操作mysql模型映射视图函数中使用模型操作Mysql基本操作查增删改 模型常用属性navie time和aware timedjango中的时区问题时区配置模型中使用 Field常用字段：Field的常用参数：模型中Meta配置： 外键和表关系外键通过外键获取对应的外键对象外键删除操作：使用其他app的模型作为外键引用自身作为外键表关系一对多一对一多对多related_name参数 查询操作查询条件exactiexactcontains和icontainsin**基本使用**：字段名__in查询条件可以是列表、元组，也可以是QuerySet对象 gt、gte、lt、ltestartswith和istartswithendswith和iendswithrange获取时间段内的数据查询id在1-4 dateyear，month，day，week_daytimeisnullregex和iregex根据关联的表进行查询related_query_name 聚合函数Avg：求平均值CountMax和MinSumaggregate和annotate的区别 F表达式Q表达式 QuerySet APIQuerySet 链式调用filterexcludeannotateorder_byvalues基本用法关联其他表 values_listallselect_relatedprefetch_relateddeferonlygetcreateget_or_createbulk_createcountfirst和lastaggregateexistdistinctupdatedelete切片操作Django会将QuerySet转换为SQL去执行的时机QuerySet对象并不会直接转换为sql去执行QuerySet会转换为SQL语句执行的情况 ORM练习 ORM模型迁移迁移命令migrations中的迁移版本和数据库中的迁移版本对不上怎么办？根据已有的表自动生成模型生成模型修正模型生成初始化的迁移脚本将Django的核心表映射到数据库中

MySQL驱动程序安装

使用Django来操作MySQL，实际上底层还是通过Python来操作的。因此用Django来操作MySQL，首先需要安装一个驱动程序。 在Python3中，驱动程序有多种选择。比如pymysql以及mysqlclient等。这里使用mysqlclient来操作，通过pip install mysqlclient安装。

常见MySQL驱动介绍：

MySQL-python：也就是MySQLdb。是对C语言操作MySQL数据库的一个简单封装。遵循了Python DB API v2。但是只支持Python2，目前还不支持Python3。mysqlclient：是MySQL-python的另外一个分支。支持Python3并且修复了一些bug。pymysql：纯Python实现的一个驱动。因为是纯Python编写的，因此执行效率不如MySQL-python。并且也因为是纯Python编写的，因此可以和Python代码无缝衔接。MySQL Connector/Python：MySQL官方推出的使用纯Python连接MySQL的驱动。因为是纯Python开发的。效率不高。

Mysql相关操作

数据库相关命令

查询数据库列表： show databases;创建数据库：mysql> create database if not exists django default charset utf8mb4 collate utf8mb4_general_ci; 删除数据库： drop database [数据库名称];切换数据库： use [数据库名称];

表相关命令

查询表列表： show tables; 创建数据表： mysql> create table if not exists books( -> id INT UNSIGNED AUTO_INCREMENT, -> title VARCHAR(40) NOT NULL, -> author VARCHAR(20) NOT NULL, -> PRIMARY KEY (id) -> ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 查询表详情： desc [表名称]; 删除数据表： drop table [表名称];

增

向MySQL数据表插入数据通用的 INSERT INTO SQL语法： INSERT INTO table_name ( field1, field2,…fieldN ) VALUES ( value1, value2,…valueN ); 注意： 如果数据是字符型，必须使用单引号或者双引号，如：“value”。 如果所有的列都要添加数据可以不规定列进行添加数据：

INSERT INTO runoob_tbl VALUES (0, “JAVA 教程”, “RUNOOB.COM”, ‘2016-05-06’); 第一列如果没有设置主键自增（PRINARY KEY AUTO_INCREMENT）的话添加第一列数据比较容易错乱，要不断的查询表看数据。

如果添加过主键自增（PRINARY KEY AUTO_INCREMENT）第一列在增加数据的时候，可以写为0或者null，这样添加数据可以自增， 从而可以添加全部数据，而不用特意规定那几列添加数据。

查

MySQL数据库中查询数据通用的 SELECT 语法： SELECT column_name1,column_name2 FROM table_name 【WHERE Clause】【LIMIT N】【 OFFSET M】

**select * : ** 返回所有记录； **limit N : ** 返回 N 条记录； offset M : 跳过 M 条记录； **limit N,M : **相当于 limit M offset N , 从第 N 条记录开始, 返回 M 条记录； 实现分页： *select * from _table limit (page_number-1)lines_perpage, lines_perpage 或 *select * from _table limit lines_perpage offset (page_number-1)lines_perpage

django操作mysql

原生mysql语句操作

在settings.py中配置mysql数据库连接信息： 在视图函数中导入from django.db import connection，通过execute(“原生sql语句”)执行sql语句。

使用ORM操作mysql

模型映射

在app/models.py中定义模型： 将app注册在settings.py的INSTALLED_APPS中： 生成模型映射文件： 执行：python manage.py makemigration 执行映射： 执行：python manage.py migrate

视图函数中使用模型操作Mysql基本操作

查

导入模型类；通过Book.objects获取数据，get方法获取一条数据，filter可以获取多条数据，all获取所有数据。 注意：可以用pk代表主键名称进行查询。

增

实例化Book类；调用book对象的save方法保存数据；

删

先根据条件查询到数据；调用book对象的delete方法删除；

改

先根据条件查询到数据；调用book对象的delete方法删除； 注意：filter返回的是QuerySet对象。QuerySet对象没有save方法，如果要保存，则需要遍历QuerySet对象对每个book对象执行save。

模型常用属性

navie time和aware time

linux系统下，通过astimezone函数将本地时间转换为UTC时间时会报错“本地时间时navie时间不能使用astimezone()”，navie datetime意思就是：这里的now自身没有指明是什么时区的，不清楚和UTC的时间差，没办法转换为UTC时间。 相反，aware time就是清楚自身属于什么时区的，可以直接转换为UTC时间。 解决办法： 通过replace方法修改now的时区为Shanghai，使now成为aware time，然后再转换为UTC时间。 **注意：**也可以在获取时间时指明时区 datetime.now(tz=pytz.timezone(“Asia/Shanghai”)）

django中的时区问题

时区配置

在settings.py中配置USE_TZ=True，TIME_ZONE=“Asia/Shanghai”。 如果要获取datetime，则可以导入 from django.utils.timezone import now ，now方法可以根据settings.py中USE_TZ=True获取aware时间。

模型中使用

模型中DataTimeField通过配置auto_now_add=True和auto_now=True，分别代表首次添加数据时自动获取时间和每次修改时自动更新时间。 数据库中存的时间都是UTC时间，要返回给前台时进行转换，或者在前台进行转换。 from django.utils.timezone import localtime导入localtime方法，localtime会读取settings.py中配置的时区，然后将UTC时间转换为配置的时区时间。

参考文章：link

Field常用字段：

在Django中，定义了一些Field来与数据库表中的字段类型来进行映射。

**AutoField：**映射到数据库中是int类型，可以有自动增长的特性。一般不需要使用这个类型，如果不指定主键，那么模型会自动的生成一个叫做id的自动增长的主键。如果你想指定一个其他名字的并且具有自动增长的主键，使用AutoField也是可以的。

BigAutoField： 64位的整形，类似于AutoField，只不过是产生的数据的范围是从1-9223372036854775807。

**BooleanField：**在模型层面接收的是True/False。在数据库层面是tinyint类型。如果没有指定默认值，默认值是None。

**CharField：**在数据库层面是varchar类型。在Python层面就是普通的字符串。这个类型在使用的时候必须要指定最大的长度，也即必须要传递max_length这个关键字参数进去。

**DateField：**日期类型。在Python中是datetime.date类型，可以记录年月日。在映射到数据库中也是date类型。使用这个Field可以传递以下几个参数： auto_now：在每次这个数据保存的时候，都使用当前的时间。比如作为一个记录修改日期的字段，可以将这个属性设置为True。 auto_now_add：在每次数据第一次被添加进去的时候，都使用当前的时间。比如作为一个记录第一次入库的字段，可以将这个属性设置为True。

**DateTimeField：**日期时间类型，类似于DateField。不仅仅可以存储日期，还可以存储时间。映射到数据库中是datetime类型。这个Field也可以使用auto_now和auto_now_add两个属性。

**TimeField：**时间类型。在数据库中是time类型。在Python中是datetime.time类型。

**EmailField：**类似于CharField。在数据库底层也是一个varchar类型。最大长度是254个字符。

**FileField：**用来存储文件的。这个请参考后面的文件上传章节部分。

**ImageField：**用来存储图片文件的。这个请参考后面的图片上传章节部分。

**FloatField：**浮点类型。映射到数据库中是float类型。

**IntegerField：**整形。值的区间是-2147483648——2147483647。

**BigIntegerField：**大整形。值的区间是-9223372036854775808——9223372036854775807。

**PositiveIntegerField：**正整形。值的区间是0——2147483647。

**SmallIntegerField：**小整形。值的区间是-32768——32767。

**PositiveSmallIntegerField：**正小整形。值的区间是0——32767。

**TextField：**大量的文本类型。映射到数据库中是longtext类型。

**UUIDField：**只能存储uuid格式的字符串。uuid是一个32位的全球唯一的字符串，一般用来作为主键。

**URLField：**类似于CharField，只不过只能用来存储url格式的字符串。并且默认的max_length是200。

Field的常用参数：

null： 如果设置为True，Django将会在映射表的时候指定是否为空，默认是为False。 在使用字符串相关的Field（CharField/TextField）的时候，官方推荐尽量不要使用这个参数，也就是保持默认值False。 因为Django在处理字符串相关的Field的时候，即使这个Field的null=False，如果你没有给这个Field传递任何值，那么Django也会使用一个空的字符串""来作为默认值存储进去。因此如果再使用null=True，Django会产生两种空值的情形（NULL或者空字符串）。 如果想要在表单验证的时候允许这个字符串为空，那么建议使用blank=True。如果你的Field是BooleanField，那么对应的可空的字段则为NullBooleanField。

blank： 标识这个字段在表单验证的时候是否可以为空。默认是False。 这个和null是有区别的，null是一个纯数据库级别的。而blank是表单验证级别的。

db_column： 这个字段在数据库中的名字。如果没有设置这个参数，那么将会使用模型中属性的名字。

default： 默认值。可以为一个值，或者是一个函数，但是不支持lambda表达式。并且不支持列表/字典/集合等可变的数据结构。

primary_key： 是否为主键。默认是False。

unique： 在表中这个字段的值是否唯一。一般是设置手机号码/邮箱等。

更多Field参数请参考官方文档：link

模型中Meta配置：

对于一些模型级别的配置。我们可以在模型中定义一个类，叫做Meta。然后在这个类中添加一些类属性来控制模型的作用。比如我们想要在数据库映射的时候使用自己指定的表名，而不是使用模型的名称。那么我们可以在Meta类中添加一个db_table的属性。示例代码如下：

class Book(models.Model): name = models.CharField(max_length=20,null=False) desc = models.CharField(max_length=100,name=‘description’,db_column=“description1”)

class Meta: db_table = 'book_model'

以下将对Meta类中的一些常用配置进行解释。

db_table： 这个模型映射到数据库中的表名。如果没有指定这个参数，那么在映射的时候将会使用模型名来作为默认的表名。

ordering： 设置在提取数据的排序方式。后面章节会讲到如何查找数据。比如我想在查找数据的时候根据添加的时间排序，那么示例代码如下：

class Book(models.Model): name = models.CharField(max_length=20,null=False) desc = models.CharField(max_length=100,name=‘description’,db_column=“description1”) pub_date = models.DateTimeField(auto_now_add=True)

class Meta: db_table = 'book_model' ordering = ['pub_date']

更多的配置参考官方文档：link

外键和表关系

外键

在MySQL中，表有两种引擎，一种是InnoDB，另外一种是myisam。如果使用的是InnoDB引擎，是支持外键约束的。

通过models.ForeignKey(to,on_delete,**options)在定义外键。第一个参数是引用的模型名称，第二个参数是在使用外键引用的模型数据被删除了，这个字段该如何处理，比如有CASCADE、SET_NULL等。

实际上数据库中book表存储的是category的id字段，即category_id。

实例化Book对象时，将拿到的Category对象赋值给Book的category参数，会自动转换为id存储在表中。 修改book模型对应的外键：

通过外键获取对应的外键对象

在Django内部为Book表添加了一个**“属性名_id”**的字段（比如category的字段名称是category_id），这个字段是一个外键，记录着对应的分类表的主键。 通过book.category访问的时候，实际上是先通过category_id找到对应的Category表中的数据形成一个模型对象。

外键删除操作：

如果一个模型使用了外键，可以通过on_delete来指定对方模型数据被删掉后，该进行什么样的操作。 可以指定的类型如下：

CASCADE：级联操作。如果外键对应的那条数据被删除了，那么这条数据也会被删除。 PROTECT：受保护。即只要这条数据引用了外键的那条数据，那么就不能删除外键的那条数据。 SET_NULL：设置为空。如果外键的那条数据被删除了，那么在本条数据上就将这个字段设置为空。如果设置这个选项，前提是要指定这个字段可以为空。 SET_DEFAULT：设置默认值。如果外键的那条数据被删除了，那么本条数据上就将这个字段设置为默认值。如果设置这个选项，前提是要指定这个字段一个默认值。 SET()：如果外键的那条数据被删除了。那么将会获取SET函数中的值来作为这个外键的值。SET函数可以接收一个可以调用的对象（比如函数或者方法），如果是可以调用的对象，那么会将这个对象调用后的结果作为值返回回去。 DO_NOTHING：不采取任何行为。一切全看数据库级别的约束。

注意：以上这些选项只是Django级别的，数据级别依旧是RESTRICT！

使用其他app的模型作为外键

如果想要引用另外一个app的模型，那么应该在传递to参数的时候，使用**[app名称.model名称]**进行指定。

# User模型在user这个app中 class User(models.Model): username = models.CharField(max_length=20) password = models.CharField(max_length=100) # Article模型在article这个app中 class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() author = models.ForeignKey("user.User", on_delete=models.CASCADE)

引用自身作为外键

如果模型的外键引用的是本身自己这个模型，那么to参数可以为’self’，或者是这个模型的名字。 在论坛开发中，一般评论都可以进行二级评论，即可以针对另外一个评论进行评论，那么在定义模型的时候就需要使用外键来引用自身。示例代码如下：

class Comment(models.Model): content = models.TextField() origin_comment = models.ForeignKey('self', on_delete=models.CASCADE, null=True) # 或者 # origin_comment = models.ForeignKey('Comment', on_delete=models.CASCADE, null=True)

表关系

related_name

一对多

应用场景：比如文章和作者之间的关系。一个文章只能由一个作者编写，但是一个作者可以写多篇文章。文章和作者之间的关系就是典型的多对一的关系。 实现方式：一对多或者多对一，都是通过ForeignKey来实现的。

获取某篇文章对应的分类：可以通过Book对象的category属性拿到对应的Category对象。

获取某个分类下所有的文章：可以通过category.book_set来获取，book_set和category.objects一样可以使用all、filter、get、first等方法获取部分内容。 book_set是在Book中使用ForeignKey引用了Category时，django自动给Category对象添加的一个属性，用于拿到对应的book。

一对一

应用场景：比如一个用户表和一个用户信息表。在实际网站中，可能需要保存用户的许多信息，但是有些信息是不经常用的，如果把所有信息都存放到一张表中可能会影响查询效率，因此可以把用户的一些不常用的信息存放到另外一张表中我们叫做UserExtension。但是用户表User和用户信息表UserExtension就是典型的一对一了。

实现方式：Django为一对一提供了一个专门的Field叫做OneToOneField来实现一对一操作。

# 用户表 class User(models.Model): username = models.CharField(max_length=20) password = models.CharField(max_length=100) # 用户信息表 class UserExtension(models.Model): birthday = models.DateTimeField(null=True) school = models.CharField(blank=True, max_length=50) user = models.OneToOneField("User", on_delete=models.CASCADE)

在UserExtension模型上增加了一个一对一的关系映射，其实底层是在UserExtension这个表上增加了一个user_id来和user表进行关联，并且这个外键数据在表中必须是唯一的，来保证一对一。 保存数据：

通过用户反向获取用户信息： user.userextension。 通过用户信息获取用户：userextension.user

多对多

应用场景：比如文章和标签的关系。一篇文章可以有多个标签，一个标签可以被多个文章所引用。因此标签和文章的关系是典型的多对多的关系。

在数据库层面，实际上Django是为这种多对多的关系建立了一个中间表。这个中间表分别定义了两个外键，引用到article和tag两张表的主键。

实现方式：Django为这种多对多的实现提供了专门的Field。叫做ManyToManyField。

class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() tags = models.ManyToManyField("Tag",related_name="articles") class Tag(models.Model): name = models.CharField(max_length=50)

** 多对多需要用 article.tags.add（tag）和tag.articles.add（article）的方式添加多对多引用关系**

# 通过tag添加article tag = Tag.objects.get(pk=9) article = Article(title="fghj", content="erty") article.save() tag.articles.add(article) # 通过article添加tag tag = Tag(name="头条") tag.save() article = Article.objects.get(pk=1) article.tags.add(tag)

related_name参数

以User和Article为例来进行说明。 如果一个article想要访问对应的作者，那么可以通过author来进行访问。但是如果有一个author对象，想要通过这个author对象获取所有的文章，该如何做呢？这时候可以通过author.article_set来访问，这个名字的规律是模型名字小写_set。示例代码如下：

user = User.objects.get(name='张三') user.article_set.all()

如果不想使用模型名字小写_set的方式，想要使用其他的名字，那么可以在定义模型的时候指定related_name。示例代码如下：

class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() # 传递related_name参数，以后在方向引用的时候使用articles进行访问 author = models.ForeignKey("User", on_delete=models.SET_NULL,null=True, related_name='articles')

以后在反向引用的时候。使用articles可以访问到这个作者的文章模型。示例代码如下：

user = User.objects.get(name='张三') user.articles.all()

如果不想使用反向引用，那么可以指定related_name=’+’。示例代码如下：

class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() # 传递related_name参数，以后在方向引用的时候使用articles进行访问 author = models.ForeignKey("User",on_delete=models.SET_NULL,null=True,related_name='+')

以后将不能通过user.article_set来访问文章模型了。

查询操作

查询一般就是使用filter、exclude以及get三个方法来实现。在调用这些方法的时候传递不同的参数来实现查询需求。在ORM层面，这些查询条件都是使用field+__+condition的方式来使用的。

查询条件

exact

如下:

查询条件title="hello"和title__exact="hello"实际上没区别，翻译为sql语句都是“=”。数据库内容是大小不敏感的。

大小不敏感的解决方案： 参考：link collation修改为*_bin规则。

iexact

结论：“iexact” 约等于 “exact” 约等于 “=”。

如下：

iexact和exact的唯一区别就是将“=”替换为了“LIKE”。mysql中like用于模糊查询，例如：LIKE %hello%就可以匹配到 “hello world”、“world hello”等。但是django中的iexact只是将“=”替换为“LIKE”，没有再hello前后加%等模糊匹配符，所有与“=”没有实际区别。 尝试在使用“hello%”，会自动加上\，会导致匹配不上。

contains和icontains

contains：大小写敏感，判断某个字段是否包含了某个数据。翻译成SQL语句为：select … where title like binary ‘%hello%’; contains：大小写不敏感，判断某个字段是否包含了某个数据。翻译成SQL语句为：select … where title like ‘%hello%’;

contains和icontains翻译为sql语句都是LIke语句，用于模糊查找，区别就是是否区分大小写。

in

翻译成SQL语句为：select … where id in (条件)

基本使用：字段名__in

查询条件可以是列表、元组，也可以是QuerySet对象

如下： 查询出books后，将books作为条件，通过books_in查询满足条件的Category。

gt、gte、lt、lte

**gt：**翻译成SQL语句为：select … where id > value; **gte：**翻译成SQL语句为：select … where id >= value; **lt：**翻译成SQL语句为：select … where id < value; **lte：**翻译成SQL语句为：select … where id <= value;

startswith和istartswith

startswith 翻译成以下SQL语句：select … where title like binary ‘hello%’; istartswith 翻译成以下SQL语句：select … where title like ‘hello%’;

endswith和iendswith

endswith 翻译成以下SQL语句：select … where title like binary ‘%hello’; iendswith 翻译成以下SQL语句：select … where title like ‘%hello’;

range

判断某个field的值是否在给定的区间中。

获取时间段内的数据

如下图：

range接收一个元组，元组的两个字段分别是start和end范围。start_time是12点，end_time是13点。转换成sql语句时，django会根据settings.py中配置的时区（当前配置的是Asia）自动转换为UTC时间（数据库中存的都是UTC时间）。假如settings.py中的USE_TZ=False，那么django就不会自动去转换UTC时间。 如果，USE_TZ=False，那么django会根据TIME_ZONE配置的时区，转换为UTC时间后再去执行sql查询。 使用datetime获取的时间时navie time，django会有警告信息，可以通过django提供的make_aware方法将其转换为aware time。 make_aware如果没有传入timezone，就会去读取settings.py中的时区，然后用replace方法修改datetime的tzinfo。

查询id在1-4

date

针对某些date或者datetime类型的字段，根据年月日查询，用法：“字段名称__date”。

如下：数据库中有2020.7.3号的数据但是没有查到。 原因是：默认情况下MySQL的表中是没有存储时区相关的信息的。 因此我们需要下载一些时区表的文件，然后添加到Mysql的配置路径中。如果用的是windows操作系统。那么在http://dev.mysql.com/downloads/timezones.html下载timezone_2018d_posix.zip - POSIX standard。然后将下载下来的所有文件拷贝到C:\ProgramData\MySQL\MySQL Server 5.7\Data\mysql中，如果提示文件名重复，那么选择覆盖即可。 如果用的是linux或者mac系统，那么在命令行中执行以下命令：mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -D mysql -u root -p，然后输入密码，从系统中加载时区文件更新到mysql中。 更新时区文件后，重新启动mysql服务：

year，month，day，week_day

year：根据年份进行查找； month：根据月份进行查找； day：根据日进行查找； week_day：根据星期几进行查找。1表示星期天，7表示星期六，2-6代表的是星期一到星期五。

time

根据时间进行查找。 如下图：sql中会将create_time由UTC时间转换为Asia/Shanghai，然后再和16:0:0对比。

isnull

根据值是否为空进行查找。翻译成SQL语句如下： select … where pub_date is not null; 字段__isnull=True 等价于 字段=None。

regex和iregex

分别代表大小写敏感和大小写不敏感的正则表达式。

根据关联的表进行查询

有两个ORM模型，一个是Article，一个是Category，查询书籍id在[1,2,3]中的书籍对应分类。

先查询出id在[1,2,3]中的书籍，通过book.category获取对应分类；通过连接查询，book__id__in=[1,2,3]查询出满足条件分类。

related_query_name

注意：由于Book中定义了外键引用Category，所以查询Category时可以通过：“类名小写”__“字段名”__in的方式查询满足条件的分类。 默认是类名小写，可以通过model.Foreignkey中related_query_name自定义反向连接查询的类名称。 如下：自定义related_query_name=“books”，那么反向查询时使用的就是books__id__in。

聚合函数

对查询结果求平均值、计算数量、总和、最大值、最小值都需要通过聚合函数实现。

Avg：求平均值

如下：

聚合函数Avg需要放在Book.objects.aggreate()中执行。默认结果是一个字典，key是“filed__avg”，可以通过**aggregate(自定义字段名=Avg())**来自定义返回值的key。由于返回值是字典，所有没有.query方法。这里通过connection.queries拿到所有的查询sql语句。

Count

Count获取指定的对象的个数。 Count类中，还有另外一个参数叫做distinct，默认是等于False，如果是等于True，那么将去掉重复的值。

Max和Min

Max用于求最大值。 Min用于求最小值。

Sum

Sum求指定对象的总和。

aggregate和annotate的区别

aggregate：返回使用聚合函数后的字段和值。 annotate：在原来模型字段的基础之上添加一个使用了聚合函数的字段，并且在使用聚合函数的时候，会使用当前这个模型的主键进行分组（group by）。

例如： 查询所有书籍分类中，每个分类下的书籍的平均价格：

通过books__price关联到Book模型的price。通过annotate执行Avg聚合函数，annotate会给原Category增加avg一个属性用于展示平均价格。查看执行的sql语句，因为一个分类对应多个书籍，要求书籍的平均价格就需要用到group by，根据分类id进行分类，然后再求平均价格。

F表达式

F表达式是用来优化ORM操作数据库的，一个F()对象代表一个模型字段的值或注释列。使用它可以直接引用模型字段的值并执行数据库操作而不用把它们导入到python的内存中。

例1：将所有书籍的价格都增加100元。 不使用F表达式：先从数据库中提取所有书籍的价格到Python内存中，然后使用Python代码在书籍价格的基础之上增加100元，最后再保存到数据库中。这里面涉及的流程就是，首先从数据库中提取数据到Python内存中，然后在Python内存中做完运算，之后再保存到数据库中。

books= Book.objects.all() for book in books: book.price += 100 book.save()

使用F表达式： F(“price”)代表book.price。

例2：title和author相同的书籍数据。

不使用F表达式：

books= Books.objects.all() for book in books: if book.title == book.author: print(book )

使用F表达式：

Q表达式

Q表达式用于多个条件的逻辑组合，与（&）、或（|）、非（~）。

QuerySet API

通常做查询操作的时候，都是通过模型名字.objects的方式进行操作。 其实模型名字.objects是一个django.db.models.manager.Manager对象，而Manager这个类是一个“空壳”的类，它本身是没有任何的属性和方法的。它的方法全部都是通过Python动态添加的方式，从QuerySet类中拷贝过来的。

QuerySet 链式调用

QuerySet API进行查找操作的后返回的也是QuerySet，可以进行链式调用。 注意：如下使用filter和order_by，实际的sql语句并没有拆分为两条，实际上还是执行了一条语句。

filter

将满足条件的数据提取出来，返回一个新的QuerySet。具体操作参照前面的章节。

exclude

排除满足条件的数据，返回一个新的QuerySet。

annotate

给QuerySet中的每个对象都添加一个使用查询表达式（聚合函数、F表达式、Q表达式、Func表达式等）的新字段。参考前面aggregate和annotate的区别章节。

order_by

指定将查询的结果根据某个字段进行排序。如果要倒叙排序，那么可以在这个字段的前面加一个负号。

# 根据创建的时间正序排序 articles = Article.objects.order_by("create_time") # 根据创建的时间倒序排序 articles = Article.objects.order_by("-create_time") # 根据作者的名字进行排序 articles = Article.objects.order_by("author__name") # 首先根据创建的时间进行排序，如果时间相同，则根据作者的名字进行排序 articles = Article.objects.order_by("create_time",'author__name')

注意： 多个order_by链式调用会把前面排序的规则给打乱，而使用后面的排序方式。比如以下代码会根据作者的名字进行排序，而不是使用文章的创建时间。：

articles = Article.objects.order_by("create_time").order_by("author__name")

values

用来指定在提取数据出来，需要提取哪些字段。 默认情况下会把表中所有的字段全部都提取出来，可以使用values来进行指定，并且使用了values方法后，提取出的QuerySet中的数据类型不是模型对象，而是在values方法中指定的字段和值形成的字典。

基本用法

关联其他表

模型类如下： 查询如下： 通过Book表关联Category拿到分类名称。

默认情况下最终结果分类名称是：“类名小写__字段名称”。可以通过values中指定关键字参数的形式，自定义展示的名称，但需要使用F表达式动态获取“类名小写__字段名称"。 统计每个分类下的书籍个数：

values_list

类似于values。只不过返回的QuerySet中，存储的不是字典，而是元组。

如下图：如果在values_list中只有一个字段。那么你可以传递flat=True来将结果扁平化。

all

获取这个ORM模型的QuerySet对象。

select_related

在提取某个模型的数据的同时，也提前将相关联的数据提取出来。 select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。

注意：select_related只能用在外键的关联对象上，多对一或者一对一中，不能用在多对多或者一对多中。例如：Book通过外键ForeignKey关联书籍分类，Book.objects.select_related(“category”)。

例如：查询id为1的book所对应的分类。 不使用select_related：先用get获取book，然后通过book.category拿到category对象，再获取其category属性。 如下，实际发生了2次查询操作。 使用select_related时，实际只查询了一次，一次性把category和book查出来。

prefetch_related

defer

defer用于过滤表中的某些字段，过滤的字段不显示在最终结果中。 defer跟values有点类似，只不过defer返回的不是字典，而是模型。 注意：1. 如下过滤了create_time字段，但是如果再调用book.create_time则会再发起一次查询。 2. defer不能过滤主键id字段。

only

跟defer类似，只不过defer是过滤掉指定的字段，而only是只提取指定的字段。 注意：主键id字段也是默认会提取出来的。

get

获取满足条件的数据。get只能返回一条数据，并且如果给的条件有多条数据，那么这个方法会抛出MultipleObjectsReturned错误，如果给的条件没有任何数据，那么就会抛出DoesNotExit错误。 所以get方法在获取数据的时候，只能有且只有一条。

create

创建一条数据，并且保存到数据库中。这个方法相当于先用指定的模型创建一个对象，然后再调用这个对象的save方法。

get_or_create

根据某个条件进行查找，如果找到了那么就返回这条数据，如果没有查找到，那么就创建一个。 返回值是一个元组，第一个是拿到的模型对象，第二个是布尔值，代表是否创建新对象，True代表创建，False代表没创建。 注意：如果查询到多条会报MultipleObjectsReturned。 没找到就会创建：

bulk_create

一次性创建多个数据。 返回值：新创建的数据模型对象列表。 如下图：插入操作只执行了一条语句。

count

获取提取的数据的个数。如果想要知道总共有多少条数据，那么建议使用count，而不是使用len(articles)这种。因为count在底层是使用select count(*)来实现的，这种方式比使用len函数更加的高效。 如下： 从sql语句可以看出直接在sql层面获取了数据个数，不需要在python中再处理。 通过count和聚合函数Count都可以实现。

first和last

返回QuerySet中的第一条和最后一条数据。 查询出来有值时，返回模型对象。 查询出来有值时，返回None。

aggregate

使用聚合函数，具体参照前面聚合函数章节。

exist

判断某个条件的数据是否存在。如果要判断某个条件的元素是否存在，那么建议使用exists，这比使用count或者直接判断QuerySet更有效得多。

if Article.objects.filter(title__contains='hello').exists(): print(True) # 比使用count更高效： if Article.objects.filter(title__contains='hello').count() > 0: print(True) # 也比直接判断QuerySet更高效： if Article.objects.filter(title__contains='hello'): print(True)

distinct

去除掉那些重复的数据。这个方法如果底层数据库用的是MySQL，那么不能传递任何的参数。 比如想要提取所有销售的价格超过80元的图书，并且删掉那些重复的，那么可以使用distinct来帮我们实现。

注意：distinct会根据每条数据的每个字段对比，如果有一个不一样都不会过滤。

如下图： 由于vlaues提取了id字段，每条数据的id字段不一致，所有distinct不会去重。 注意： 如果使用了order_by（“id”）会根据id字段排序，那么distinct也无法去重。

update

执行更新操作，在SQL底层用的也是update命令。

delete

删除所有满足条件的数据。删除数据的时候，要注意on_delete指定的处理方式。

切片操作

有时候我们查找数据，有可能只需要其中的一部分，那么这时候可以使用切片操作来帮我们完成。 QuerySet使用切片操作就跟列表使用切片操作是一样的。

切片操作就是在sql中使用了LIMIT和OFFSET。

Django会将QuerySet转换为SQL去执行的时机

QuerySet对象并不会直接转换为sql去执行

生成一个QuerySet对象并不会马上转换为SQL语句去执行。

QuerySet会转换为SQL语句执行的情况

打印或迭代：在遍历QuerySet对象的时候，会首先先执行这个SQL语句，然后再把这个结果返回进行迭代。比如以下代码就会转换为SQL语句：

使用步长做切片操作：QuerySet可以类似于列表一样做切片操作。做切片操作本身不会执行SQL语句，但是如果如果在做切片操作的时候提供了步长，那么就会立马执行SQL语句。需要注意的是，做切片后不能再执行filter方法，否则会报错。

调用len函数：调用len函数用来获取QuerySet中总共有多少条数据也会执行SQL语句。

调用list函数：调用list函数用来将一个QuerySet对象转换为list对象也会立马执行SQL语句。

判断：如果对某个QuerySet进行判断，也会立马执行SQL语句。

ORM练习

from django.db import models class Student(models.Model): """学生表""" name = models.CharField(max_length=100) gender = models.SmallIntegerField() class Meta: db_table = 'student' class Course(models.Model): """课程表""" name = models.CharField(max_length=100) teacher = models.ForeignKey("Teacher", on_delete=models.SET_NULL, null=True) class Meta: db_table = 'course' class Score(models.Model): """分数表""" student = models.ForeignKey("Student", on_delete=models.CASCADE) course = models.ForeignKey("Course", on_delete=models.CASCADE) number = models.FloatField() class Meta: db_table = 'score' class Teacher(models.Model): """老师表""" name = models.CharField(max_length=100) class Meta: db_table = 'teacher'

查询平均成绩大于60分的同学的id和平均成绩；

查询所有同学的id、姓名、选课的数、总成绩；

查询姓“李”的老师的个数；

查询没学过“黄老师”课的同学的id、姓名；

5. 查询学过课程id为1和2的所有同学的id、姓名； 6. 查询学过“黄老师”所教的所有课的同学的学号、姓名；

查询所有课程成绩小于60分的同学的id和姓名；

查询没有学全所有课的同学的id、姓名； 

查询所有学生的姓名、平均分，并且按照平均分从高到低排序； 注意：values返回值是字典类型 。

查询各科成绩的最高和最低分，以如下形式显示：课程ID，课程名称，最高分，最低分；

查询没门课程的平均成绩，按照平均成绩进行排序；

统计总共有多少女生，多少男生；

将“黄老师”的每一门课程都在原来的基础之上加5分；

查询两门以上不及格的同学的id、姓名、以及不及格课程数；

查询每门课的选课人数；

ORM模型迁移

迁移命令

makemigrations：将模型生成迁移脚本。模型所在的app，必须放在settings.py中的INSTALLED_APPS中。这个命令有以下几个常用选项： app_label：后面可以跟一个或者多个app，那么就只会针对这几个app生成迁移脚本。如果没有任何的app_label，那么会检查INSTALLED_APPS中所有的app下的模型，针对每一个app都生成响应的迁移脚本。 –name：给这个迁移脚本指定一个名字。 –empty：生成一个空的迁移脚本。如果你想写自己的迁移脚本，可以使用这个命令来实现一个空的文件，然后自己再在文件中写迁移脚本。

migrate：将新生成的迁移脚本。映射到数据库中。创建新的表或者修改表的结构。以下一些常用的选项： app_label：将某个app下的迁移脚本映射到数据库中。如果没有指定，那么会将所有在INSTALLED_APPS中的app下的模型都映射到数据库中。 app_label migrationname：将某个app下指定名字的migration文件映射到数据库中。 –fake：可以将指定的迁移脚本名字添加到数据库中。但是并不会把迁移脚本转换为SQL语句，修改数据库中的表。 –fake-initial：将第一次生成的迁移文件版本号记录在数据库中。但并不会真正的执行迁移脚本。

showmigrations：查看某个app下的迁移文件。如果后面没有app，那么将查看INSTALLED_APPS中所有的迁移文件。

sqlmigrate：查看某个迁移文件在映射到数据库中的时候，转换的SQL语句。

migrations中的迁移版本和数据库中的迁移版本对不上怎么办？

找到哪里不一致，然后使用python manage.py --fake [版本名字]，将这个版本标记为已经映射。删除指定app下migrations和数据库表django_migrations中和这个app相关的版本号，然后将模型中的字段和数据库中的字段保持一致，再使用命令python manage.py makemigrations重新生成一个初始化的迁移脚本，之后再使用命令python manage.py makemigrations --fake-initial来将这个初始化的迁移脚本标记为已经映射。以后再修改就没有问题了。

更多关于迁移脚本的。请查看官方文档：link

根据已有的表自动生成模型

在实际开发中，有些时候可能数据库已经存在了。如果我们用Django来开发一个网站，读取的是之前已经存在的数据库中的数据。那么该如何将模型与数据库中的表映射呢？ 根据旧的数据库生成对应的ORM模型，需要以下几个步骤：

生成模型

Django给我们提供了一个inspectdb的命令，可以非常方便的将已经存在的表，自动的生成模型。想要使用inspectdb自动将表生成模型。首先需要在settings.py中配置好数据库相关信息。不然就找不到数据库。示例代码如下： DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': "migrations_demo", 'HOST': '127.0.0.1', 'PORT': '3306', 'USER': 'root', 'PASSWORD': 'root' } }

比如有以下表：

article表：

tag表：

article_tag表： front_user表：

那么通过python manage.py inspectdb，就会将表转换为模型后的代码，显示在终端：

from django.db import models class ArticleArticle(models.Model): title = models.CharField(max_length=100) content = models.TextField(blank=True, null=True) create_time = models.DateTimeField(blank=True, null=True) author = models.ForeignKey('FrontUserFrontuser', models.DO_NOTHING, blank=True, null=True) class Meta: managed = False db_table = 'article_article' class ArticleArticleTags(models.Model): article = models.ForeignKey(ArticleArticle, models.DO_NOTHING) tag = models.ForeignKey('ArticleTag', models.DO_NOTHING) class Meta: managed = False db_table = 'article_article_tags' unique_together = (('article', 'tag'),) class ArticleTag(models.Model): name = models.CharField(max_length=100) class Meta: managed = False db_table = 'article_tag' class FrontUserFrontuser(models.Model): username = models.CharField(max_length=100) telephone = models.CharField(max_length=11) class Meta: managed = False db_table = 'front_user_frontuser'

以上代码只是显示在终端。如果想要保存到文件中。那么可以使用>重定向输出到指定的文件。比如让他输出到models.py文件中。示例命令如下：

python manage.py inspectdb > models.py

注意：以上的命令，只能在终端执行，不能在pycharm->Tools->Run manage.py Task…中使用。

如果只是想要转换一个表为模型。那么可以指定表的名字。示例命令如下：

python manage.py inspectdb article_article > models.py

修正模型

新生成的ORM模型有些地方可能不太适合使用。比如模型的名字，表之间的关系等等。那么以下选项还需要重新配置一下：

模型名：自动生成的模型，是根据表的名字生成的，可能不是你想要的。这时候模型的名字你可以改成任何你想要的。模型所属app：根据自己的需要，将相应的模型放在对应的app中。放在同一个app中也是没有任何问题的。只是不方便管理。模型外键引用：将所有使用ForeignKey的地方，模型引用都改成字符串。这样不会产生模型顺序的问题。另外，如果引用的模型已经移动到其他的app中了，那么还要加上这个app的前缀。让Django管理模型：将Meta下的managed=False删掉，如果保留这个，那么以后这个模型有任何的修改，使用migrate都不会映射到数据库中。当有多对多的时候，应该也要修正模型。将中间表注视了，然后使用ManyToManyField来实现多对多。并且，使用ManyToManyField生成的中间表的名字可能和数据库中那个中间表的名字不一致，这时候肯定就不能正常连接了。那么可以通过db_table来指定中间表的名字。

示例代码如下：

class Article(models.Model): title = models.CharField(max_length=100, blank=True, null=True) content = models.TextField(blank=True, null=True) author = models.ForeignKey('front.User', models.SET_NULL, blank=True, null=True) # 使用ManyToManyField模型到表，生成的中间表的规则是：article_tags # 但现在已经存在的表的名字叫做：article_tag # 可以使用db_table，指定中间表的名字 tags = models.ManyToManyField("Tag",db_table='article_tag') class Meta: db_table = 'article' 表名：切记不要修改表的名字。不然映射到数据库中，会发生找不到对应表的错误。

生成初始化的迁移脚本

执行命令python manage.py makemigrations生成初始化的迁移脚本。方便后面通过ORM来管理表。这时候还需要执行命令python manage.py migrate --fake-initial，因为如果不使用–fake-initial，那么会将迁移脚本会映射到数据库中。这时候迁移脚本会新创建表，而这个表之前是已经存在了的，所以肯定会报错。此时我们只要将这个0001-initial的状态修改为已经映射，而不真正执行映射，下次再migrate的时候，就会忽略他。

将Django的核心表映射到数据库中

Django中还有一些核心的表也是需要创建的。不然有些功能是用不了的。比如auth相关表。如果这个数据库之前就是使用Django开发的，那么这些表就已经存在了，可以不用管了。 如果之前这个数据库不是使用Django开发的，那么应该使用migrate命令将Django中的核心模型映射到数据库中。