Django 模型类与数据库（六）

一、Django ORM

Django 模型使用自带的 ORM。

对象关系映射（Object Relational Mapping，简称 ORM ）用于实现面向对象编程语言里不同类型系统的数据之间的转换。

ORM 在业务逻辑层和数据库层之间充当了桥梁的作用。

ORM 是通过使用描述对象和数据库之间的映射的元数据，将程序中的对象自动持久化到数据库中。

 ORM 的好处：

• 提高开发效率。
• 不同数据库可以平滑切换。

ORM 的缺点：

• ORM 代码转换为 SQL 语句时，需要花费一定的时间，执行效率会有所降低。
• 长期写 ORM 代码，会降低编写 SQL 语句的能力。

ORM 解析过程:

• 1、ORM 会将 Python 代码转成为 SQL 语句。
• 2、SQL 语句通过 pymysql 传送到数据库服务端。
• 3、在数据库中执行 SQL 语句并将结果返回。

ORM 对应关系表：

二、MySQL数据库

 1）登录数据库: mysql -h ip地址 -u用户名 -p密码

2)显示数据库 show databases;

创建数据库: create database hlx charset='utf8'

3)在django工程中的settings配置 （前提必须是安装:pip install pymysql）

三、数据库模型类

 (1)   定义模型类 ->对应于数据库表

（a）在app下的models中定义模型类BookInfo      

在app下的models中定义模型类CustomerInfo   

models.py代码：

from django.db import models    #导入模块

# Create your models here.
'''
 数据迁移： python manage.py makemigrations

类，属性，对象

图书表，人物表
'''
#定义一个图书的模型类，继承models
#需要使用属性
#1.图书表
class BookInfo(models.Model):
    #id 是自动创建PK
    #名称 字符串20
    name=models.CharField(verbose_name='名称',max_length=20)
    #发布日期: null=True 必须传入这个字段
    pub_date=models.DateField(verbose_name='分布日期',null=True)
    #阅读量 默认为0
    read_count=models.IntegerField(verbose_name='阅读量',default=0)
    #评论量
    comment_count=models.IntegerField(verbose_name='评论量',default=0)
    #逻辑删除 默认为False,没有删除
    is_del=models.BooleanField(verbose_name='逻辑删除',default=False)

   #这个Meta继承来的
    class Meta:
        # 如果我们不写它，那么django会给数据库表生成一个子应用名_模型类名
        #指定数据库表名
        db_table='bookinfo'
        #在admin显示图书表
        verbose_name='图书'
        verbose_name_plural=verbose_name  #显示图书复数形式

    # 这个继承models来的方法
    def __str__(self):
        return self.name

#2.人物表
class CustomerInfo(models.Model):
    #定义个元组存数据
    SEX_CHOICES=(
        (0,'male'),
        (1,'female'),
    )
    #人物名
    name=models.CharField(verbose_name='人物名',max_length=20)
    #性别,默认为0
    gender=models.SmallIntegerField(verbose_name='性别',choices=SEX_CHOICES,default=0)
    #详细信息
    detail=models.CharField(verbose_name='详细信息',max_length=200,null=True)
    #外键  ForeignKey 指定关联对象
    #on_delete 级联删除作用
    book=models.ForeignKey(BookInfo,on_delete=models.CASCADE,verbose_name='图书')
    #逻辑删除 默认为False,没有删除
    is_del=models.BooleanField(verbose_name='逻辑删除',default=False)

    class Meta:
          # 指定数据库表名
          db_table='customerinfo'
          verbose_name='人物'
          verbose_name_plural=verbose_name

    def __str__(self):
        return self.name   #返回对象名称

(2) 生成迁移文件  python manage.py makemigrations

 发生异常1：

原因：但是在 Django 中， 连接数据库时使用的是 MySQLdb 库，这在与 python3 的合作中就会报以下错误 

解决：在项目的 init.py 文件中添加以下代码即可。

import pymysql
pymysql.install_as_MySQLdb()

在migrations目录下生成一个文件！

（3） 同步到数据库 python manage.py migrate

四、shell使用

  shell 作用：帮助我们配置好当前工程的运行环境（如连接好数据库等），以便可以直接在终端中执行测试python语句。

(4.1) python manage.py shell

(4.2)   from books.models import BookInfo,CustomerInfo 重点：导入模型类，以便后续使用 

(4.3)  数据库操作

1 新增有两种方法。

1）save** 通过创建模型类对象，执行对象的save()方法保存到数据库中。

2）create** 使用模型中的属性objects,用于模型类对象和数据交互

     通过模型类.objects.create()保存。

 2 修改有两种方法

1）save

**修改模型类对象的属性，然后执行save()方法**

2）update

**使用模型类.objects.filter().update()，会返回受影响的行数。filter 过滤

>>>    BookInfo.objects.filter(name="Teddy").update(name="hello")

3.删除两种方法

**1）模型类对象delete**

>>> from books.models import BookInfo,CustomerInfo  导入模型类（必须一次！）

>>> book=BookInfo.objects.get(name='hello')

>>> book.delete()

**2）模型类.objects.filter().delete()**

>>> BookInfo.objects.filter(name='Oracle').delete()

 4 查询

4.1 基本查询

**get **查询单一对象，如果不存在会抛出**模型类.DoesNotExist**异常。

>>> BookInfo.objects.get(id=1)

如果需要捕获异常
```
try:
    book=BookInfo.objects.get(id=2)
# except Exception :
#     pass
except BookInfo.DoesNotExist:
    pass
```

**all **查询多个结果。返回列表

>>> BookInfo.objects.all()

**count **查询结果数量。

>>> BookInfo.objects.count()

4.2过滤查询

实现SQL中的where功能，包括

filter  过滤出多个结果

exclude  排除掉符合条件剩下的结果

get  过滤单一结果

对于过滤条件的使用，上述三个方法相同，故仅以**filter**进行讲解。

过滤条件的表达语法如下：

```

属性名称__比较运算符=值

# 属性名称和比较运算符间使用两个下划线，所以属性名不能包括多个下划线

```

 4.2.1 相等

**exact：表示判等。**

例：查询编号为4的图书。

exact 精确的 准确的 就是等于=

get 返回单个对象

>>> BookInfo.objects.get(id=4)

>>> BookInfo.objects.get(id__exact=4)

filter 返回集合

>>>BookInfo.objects.filter(id=4)

>>> BookInfo.objects.filter(id__exact=4)

4.3 模糊查询

**contains：是否包含。**

> 说明：如果要包含%无需转义，直接写即可。

例：查询书名包含'江'的图书。

>>> BookInfo.objects.filter(name__contains='江')

**startswith、endswith：以指定值开头或结尾。**

例：查询书名以'湖'结尾的图书

>>> BookInfo.objects.filter(name__startswith='笑')

>>> BookInfo.objects.filter(name__endswith='湖')

 4.4 空查询

**isnull：是否为null。**

例：查询书名为空的图书。

>>> BookInfo.objects.filter(name__isnull=True)

 

4.5 范围查询

**in：是否包含在范围内。**

例：查询编号为1或3或5的图书

>>> BookInfo.objects.filter(id__in=[1,3,5])

4.6 比较查询

**5）比较查询**

- **gt**大于 (greater then)

- **gte**大于等于 (greater then equal)

- **lt**小于 (less then)

- **lte**小于等于 (less then equal)

例：查询编号大于2的图书

>>> BookInfo.objects.filter(id__gte=2)

**不等于的运算符，使用exclude()过滤器。**

例：查询书籍id不为2的图书

>>> BookInfo.objects.exclude(id=2)

>>> BookInfo.objects.exclude(id__exact=2)

4.7 日期查询

year、month、day、week_day、hour、minute、second：对日期时间类型的属性进行运算。**

例：查询1986年发表的图书。

>>> BookInfo.objects.filter(pub_date__year=1986)

例：查询1990年1月1日后发表的图书。

>>> BookInfo.objects.filter(pub_date__gt='1990-1-1')

>>> BookInfo.objects.filter(pub_date__lt='1990-1-1')

>>> BookInfo.objects.filter(pub_date__lt='1990.1.1') 

发生异常：

4.8 F和Q对象

1 F对象

之前的查询都是对象的属性与常量值比较，两个属性怎么比较呢？ 答：使用F对象，被定义在django.db.models中。

语法如下：

```

filter(字段名__运算符=F('字段名'))

```

例：查询阅读量大于等于评论量的图书。

>>> from django.db.models import F

>>> BookInfo.objects.filter(read_count__gt=F('comment_count'))

可以在F对象上使用算数运算。

例：查询阅读量大于2倍评论量的图书。

>>> BookInfo.objects.filter(read_count__gt=F('comment_count')*2)

2 Q对象

**多个过滤器逐个调用表示逻辑与关系，同sql语句中where部分的and关键字。**

例：查询阅读量大于20，并且编号小于3的图书。

>>> BookInfo.objects.filter(read_count__gt=20,id__lt=3)

>>> BookInfo.objects.filter(read_count__gt=20).filter(id__lt=3)

**如果需要实现逻辑或or的查询，需要使用Q()对象结合|运算符**，Q对象被义在django.db.models中。

语法如下：

```

Q(属性名__运算符=值)

```

例：查询阅读量大于20的图书，改写为Q对象如下。

>>> from django.db.models import Q

>>> BookInfo.objects.filter(Q(read_count__gt=20))

Q对象可以使用&、|连接 ；

  其中&表示逻辑与，|表示逻辑或。

例：查询阅读量大于20，或编号小于3的图书，只能使用Q对象实现

>>> BookInfo.objects.filter(Q(read_count__gt=20)| Q(id__lt=3))

Q对象前可以使用~操作符，表示非not。

例：查询编号不等于3的图书。

>>> BookInfo.objects.exclude(id=3)

>>> BookInfo.objects.filter(~Q(id=3))

4.9 聚合函数和排序函数

1. 聚合函数

使用aggregate()过滤器调用聚合函数。

聚合函数包括：**Avg**平均，**Count**数量，**Max**最大，**Min**最小，**Sum**求和，被定义在django.db.models中。

语法如下：

```

aggregate(聚合函数('字段名'))

```

例：查询图书的总阅读量。

>>> from django.db.models import Sum,Avg,Min,Max,Count

>>> BookInfo.objects.aggregate(Sum('read_count'))

使用count时一般不使用aggregate()过滤器。

例：查询图书总数。

>>> BookInfo.objects.count()

注意count函数的返回值是一个数字。

2. 排序

使用**order_by**对结果进行排序

语法如下

```

升序：order_by('字段名')

降序：order_by('-字段名')

```

# 默认升序

>>> BookInfo.objects.all().order_by('read_count')

# 降序

>>> BookInfo.objects.all().order_by('-read_count')

4.10 关联查询

（1） 一对多语法：

一对应的模型类对象.多对应的模型类名小写_set

例：查询书籍为1的所有人物信息

# 通过书籍查询人物信息( 已知 主表数据,关联查询从表数据)

# 主表模型(实例对象).关联模型类名小写_set.all()

>>> book=BookInfo.objects.get(id=1)

>>> book.customerinfo_set.all()

（2） 多对一语法:

多对应的模型类对象.多对应的模型类中的关系类属性名

例：查询人物为1的书籍信息

# 通过人物查询书籍信息( 已知 从表数据,关联查询主表数据)

# 从表模型(实例对象).外键

>>> customer=CustomerInfo.objects.get(id=1)

>>> customer.book

（3）一对一的模型类关联对象的id语法:

多对应的模型类对象.关联类属性_id

例：查询人物为1的书籍id

# 通过人物查询书籍信息( 已知 从表数据,关联查询主表数据)

# 从表模型(实例对象).关联类属性_id

>>> customer=CustomerInfo.objects.get(id=1)

>>> customer.book_id

4.11 关联过滤查询

**由多模型类条件查询一模型类数据**:

语法如下：

```

filter(关联模型类名小写__属性名__条件运算符=值)

```

> **注意：如果没有"__运算符"部分，表示等于。**

例：查询图书，要求图书人物为"郭靖"

# 我们需要的是书籍信息,已知条件是人物信息

# 我们需要的是主表数据,已知条件是从表信息

>>> book=BookInfo.objects.filter(customerinfo__name='郭靖')

>>> book

例：查询图书，要求图书中人物的描述包含"八"

>>> book=BookInfo.objects.filter(customerinfo__detail__contains='八')

>>> book

 4.12一模型类条件查询多模型类数据

语法如下：

```

filter(一模型类关联属性名（外键）__一模型类属性名__条件运算符=值)

```

> **注意：如果没有"__运算符"部分，表示等于。**

例：查询书名为“天龙八部”的所有人物。

# 我们需要的是 人物信息,已知条件是 书籍信息

# 我们需要是是 从表数据,已知条件是 主表信息

>>> customer=CustomerInfo.objects.filter(book__name='天龙八部')

>>> customer

例：查询图书阅读量大于30的所有人物

>>> customer=CustomerInfo.objects.filter(book__read_count__gt=30)

>>> customer

4.13 查询集QuerySet

 3.4.6.1 概念

Django的ORM中存在查询集的概念。

查询集，也称查询结果集、QuerySet，表示从数据库中获取的对象集合。

当调用如下过滤器方法时，Django会返回查询集（而不是简单的列表）：

all()：返回所有数据。

filter()：返回满足条件的数据。

exclude()：返回满足条件之外的数据。

order_by()：对结果进行排序。

对查询集可以再次调用过滤器进行过滤，如

例：查询图书阅读量大于30,并按发布日期升序排序

>>> book=BookInfo.objects.filter(read_count__gt=30).order_by('pub_date')

>>> book

也就意味着查询集可以含有零个、一个或多个过滤器。过滤器基于所给的参数限制查询的结果。

**从SQL的角度讲，查询集与select语句等价，过滤器像where、limit、order by子句。

**判断某一个查询集中是否有数据**：

- exists()：判断查询集中是否有数据，如果有则返回True，没有则返回False。

4.14 两大特性

**1）惰性执行**

创建查询集不会访问数据库，直到调用数据时，才会访问数据库，调用数据的情况包括迭代、序列化、与if合用

例如，当执行如下语句时，并未进行数据库查询，只是创建了一个查询集books

books = BookInfo.objects.all()

继续执行遍历迭代操作后，才真正的进行了数据库的查询

```

for book in books:

    print(book.name)

```

**2）缓存**

使用同一个查询集，第一次使用时会发生数据库的查询，然后Django会把结果缓存下来，再次使用这个查询集时会使用缓存的数据，减少了数据库的查询次数。

**情况一**：如下是两个查询集，无法重用缓存，每次查询都会与数据库进行一次交互，增加了数据库的负载。

>>> [book.id for book in BookInfo.objects.all()]

**情况二**：经过存储后，可以重用查询集，第二次使用缓存中的数据。

# 优化

# 查询出来结果集

>>> book=BookInfo.objects.all()

#只需要从结果集里面查询，不需要再去数据库里面查询

>>> [bk.id for bk in book]

4.15 限制查询集

可以对查询集进行取下标或切片操作，等同于sql中的limit和offset子句。

> 注意：不支持负数索引。

**对查询集进行切片后返回一个新的查询集，不会立即执行查询。**

如果获取一个对象，直接使用[0]，等同于[0:1].get()，但是如果没有数据，[0]引发IndexError异常，[0:1].get()如果没有数据引发DoesNotExist异常。

示例：获取第1项，运行查看。

>>> book=BookInfo.objects.all()[1:2]

>>> book

4.16 分页

#导入分页类

from django.core.paginator import Paginator

如下警告：

原因：这是Django自带的分页报错的警告，分页前必须排序

解决： books = BookInfo.objects.all().order_by(‘id’)

再重新输入哦！

>>> from django.core.paginator import Paginator

>>> books = BookInfo.objects.all().order_by('id')
>>> paginator=Paginator(books,2)
>>> page_skus = paginator.page(1)