Python笔记17（Django之ORM单表查询13条+外键操作（一对多））

一、ORM介绍

1、ORM概念

对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。

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

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

2、ORM由来

让我们从O/R开始。字母O起源于"对象"(Object),而R则来自于"关系"(Relational)。

几乎所有的软件开发过程中都会涉及到对象和关系数据库。在用户层面和业务逻辑层面，我们是面向对象的。当对象的信息发生变化的时候，我们就需要把对象的信息保存在关系数据库中。

按照之前的方式来进行开发就会出现程序员会在自己的业务逻辑代码中夹杂很多SQL语句用来增加、读取、修改、删除相关数据，而这些代码通常都是重复的。

3、ORM优势

ORM解决的主要问题是对象和关系的映射。它通常把一个类和一个表一一对应，类的每个实例对应表中的一条记录，类的每个属性对应表中的每个字段。

ORM提供了对数据库的映射，不用直接编写SQL代码，只需像操作对象一样从数据库操作数据。

让软件开发人员专注于业务逻辑的处理，提高了开发效率。

4、ORM劣势

ORM的缺点是会在一定程度上牺牲程序的执行效率。

ORM用多了SQL语句就不会写了，关系数据库相关技能退化...

5、总结

ORM只是一种工具，工具确实能解决一些重复，简单的劳动。这是不可否认的。

但我们不能指望某个工具能一劳永逸地解决所有问题，一些特殊问题还是需要特殊处理的。

但是在整个软件开发过程中需要特殊处理的情况应该都是很少的，否则所谓的工具也就失去了它存在的意义。

二、Model

在Django中model是你数据的单一、明确的信息来源。它包含了你存储的数据的重要字段和行为。通常，一个模型（model）映射到一个数据库表，

基本情况：

每个模型都是一个Python类，它是django.db.models.Model的子类。
模型的每个属性都代表一个数据库字段。
综上所述，Django为您提供了一个自动生成的数据库访问API。

下面这个例子定义了一个 Person 模型，包含 first_name 和 last_name：

from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

first_name 和 last_name 是模型的字段。每个字段被指定为一个类属性，每个属性映射到一个数据库列。

上面的 Person 模型将会像这样创建一个数据库表：

CREATE TABLE myapp_person (
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL
);

一些说明：

表myapp_person的名称是自动生成的，如果你要自定义表名，需要在model的Meta类中指定 db_table 参数，强烈建议使用小写表名，特别是使用MySQL作为后端数据库时。
id字段是自动添加的，如果你想要指定自定义主键，只需在其中一个字段中指定 primary_key=True 即可。如果Django发现你已经明确地设置了Field.primary_key，它将不会添加自动ID列。
本示例中的CREATE TABLE SQL使用PostgreSQL语法进行格式化，但值得注意的是，Django会根据配置文件中指定的数据库后端类型来生成相应的SQL语句。
Django支持MySQL5.5及更高版本。

三、Django ORM 常用字段和参数

1、常用字段

1）AutoField

int自增列，必须填入参数 primary_key=True。当model中如果没有自增列，则自动会创建一个列名为id的列。

2）IntegerField

一个整数类型,范围在 -2147483648 to 2147483647。

3）CharField

字符类型，必须提供max_length参数， max_length表示字符长度。

4）DateField

日期字段，日期格式 YYYY-MM-DD，相当于Python中的datetime.date()实例。

5）DateTimeField

日期时间字段，格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相当于Python中的datetime.datetime()实例。

6）字段集合

   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)
        - 二进制类型

字段集合

7）自定义字段

class UnsignedIntegerField(models.IntegerField):
    def db_type(self, connection):
        return 'integer UNSIGNED'

自定义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)

创建的表结构：

8）ORM字段与数据库实际字段的对应关系

对应关系：
    'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',

对应关系

2、字段参数

1）null

用于表示某个字段可以为空。

2）unique

如果设置为unique=True 则该字段在此表中必须是唯一的。

3）db_index

如果db_index=True 则代表着为此字段设置索引。增加查询速度。

4）default

为该字段设置默认值。

5）DateField和DateTimeField

auto_now_add：配置auto_now_add=True，第一次创建数据记录的时候会把当前时间添加到数据库。

auto_now：配置上auto_now=True，每次更新数据记录的时候会更新该字段。

四、ORM必知必会单表查询13条

1、必知必会13条

<1> all():                 查询所有结果
 
<2> filter(**kwargs):      它包含了与所给筛选条件相匹配的对象
 
<3> get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
 
<4> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象
 
<5> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列model的实例化对象，而是一个可迭代的字典序列
 
<6> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
 
<7> order_by(*field):      对查询结果排序
 
<8> reverse():             对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)。
 
<9> distinct():            从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。)
 
<10> count():              返回数据库中匹配查询(QuerySet)的对象数量。
 
<11> first():              返回第一条记录
 
<12> last():               返回最后一条记录
 
<13> exists():             如果QuerySet包含数据，就返回True，否则返回False

示例：

# 如何在一个py文件中 使用Django项目的相关配置或内容
import os

# 右键运行时执行此文件的代码，写脚本可以这样写
if __name__ == '__main__':
    # 找到当前Django环境的所有配置
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")
    import django

    django.setup()

    from app01 import models

    # 查询age=18的第一个人，返回一个对象
    # （通常根据唯一的值进行查询 查询结果多余一个时，会报错，通常根据pk（主键）、unique来查询）
    # 通常使用get时，可以使用try来捕获异常，这样就不会报错了
    ret = models.Person.objects.get(age=18)
    print(ret)
    # 查询age=18的所有人， 返回一个QuerySet列表，查询不到结果返回null
    ret = models.Person.objects.filter(age=18)
    print(ret[0])  # 可以根据索引取值

    # 查询age=18的所有人，返回QuerySet列表，元素为每个人包含age与phone字段的字典
    ret = models.Person.objects.filter(age=18).values("age", "phone")
    print(ret)

    # 查询age=18的所有人，返回QuerySet列表，元素为每个人包含age与phone值的元组
    ret = models.Person.objects.filter(age=18).values_list("age", "phone")
    print(ret)

    # 按照年龄排序
    ret = models.Person.objects.all().order_by("age")
    print(ret)

分类：

分类：
1. 返回QuerySet列表的有哪一些？
    1. all()
    2. filter()
    3. exclude()
    4. order_by()
    5. reverse()
    6. distinct()
                        
    7. values('字段名', ...)     --> 查询结果的列表里，都是字典
    8. values_list(字段名', ...) --> 查询结果的列表里，都是元祖
                        
2. 返回具体对象的
    1. first()
    2. last()
    3. get()

3. 返回数字的
    1. count()

4. 返回布尔值
    1. exists()

2、单表查询之神奇的双下划线

# 如何在一个py文件中 使用Django项目的相关配置或内容
import os

# 右键运行时执行此文件的代码，写脚本可以这样写
if __name__ == '__main__':
    # 找到当前Django环境的所有配置
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")
    import django

    django.setup()

    from app01 import models
    

        # 查询年龄大于18岁，id大于1的（大于age__gt、小于age__lt、小于等于age__lte）
    ret = models.Person.objects.filter(age__gt=18, id__gt=1)
    print(ret)

    # 查询id值在 [1, 2]的人
    ret = models.Person.objects.filter(id__in=[1, 2, 20000])
    print(ret)

    # 查询id值不在[1,2]的人
    ret = models.Person.objects.exclude(id__in=[1,2])
    print(ret)

    # 查询名字中包含 JJ 的那个人
    ret = models.Person.objects.filter(name__contains="JJ")
    print(ret)
    
    # 不区分大小写查询
    ret = models.Person.objects.filter(name__icontains="jj")
    print(ret)

    # 查询id在1-3区间内的数据
    ret = models.Person.objects.filter(id__range=[1, 3])
    print(ret)

    # 查询以JJ结尾的人
    ret = models.Person.objects.filter(name__endswith='JJ')
    print(ret)
    print(models.Person.objects.first().birthday)
    # 查询 生日 是 2018年的所有人
    ret = models.Person.objects.filter(birthday__year=2018)
    print(ret)

3、外键ForeignKey

1）示例

modles.py:

from django.db import models


# 出版社表
class Publisher(models.Model):
    name = models.CharField(max_length=12)


# 书籍表
class Book(models.Model):
    title = models.CharField(max_length=32)
    # on_delete=models.CASCADE 级联删除 当出版社删除时，关联的书籍也删除
    # Django1.1 默认为级联删除  Django2.0需要明确此选项on_delete=models.CASCADE 否则运行时会报错
    # 当orm创建数据库表时， 会自动在外键设置的字段上加上publisher_id
    publisher = models.ForeignKey(to="Publisher", on_delete=models.CASCADE)

modles.py

urls.py:

from django.conf.urls import url
from django.contrib import admin
from app01 import views

urlpatterns = [
    url(r'^book_list/$', views.book_list),
    url(r'^add_book/$', views.AddBook.as_view()),
    url(r'^delete_book/(?P<pk>d+)/$', views.DeleteBook.as_view()),
    url(r'^edit_book/(?P<pk>d+)/$', views.EditBook.as_view()),
]

urls.py

views.py:

from django.shortcuts import render, redirect, HttpResponse
from django.http import JsonResponse
from app01 import models
from django.urls import reverse
from django import views


def publisher_list(request):
    print(request.path_info)
    data = models.Publisher.objects.all()
    return render(request, "publisher_list.html", {"publisher_list": data})


def book_list(request):
    # 去数据库查询所有的书籍
    data = models.Book.objects.all()
    return render(request, "book_list.html", {"book_list": data})


class AddBook(views.View):

    def get(self, request):
        data = models.Publisher.objects.all()
        return render(request, "add_book.html", {"publisher_list": data})

    def post(self, request):
        book_name = request.POST.get("title")
        publisher_id = request.POST.get("publisher")
        # publisher_obj = models.Publisher.objects.get(id=publisher_id)
        # 创建书籍
        models.Book.objects.create(
            title=book_name,
            publisher_id=publisher_id
            # publisher=publisher_obj
        )
        return redirect("/book_list/")


class DeleteBook(views.View):
    def get(self, request, pk):
        models.Book.objects.filter(id=pk).delete()
        return redirect("/book_list/")


class EditBook(views.View):
    def get(self, request, pk):
        book_obj = models.Book.objects.get(id=pk)
        publisher_list = models.Publisher.objects.all()
        return render(request, "edit_book.html", {"book": book_obj, "publisher_list": publisher_list})

    def post(self, request, pk):
        book_obj = models.Book.objects.get(id=pk)
        new_title = request.POST.get("title")
        new_publisher_id = request.POST.get("publisher")
        # 更新
        book_obj.title = new_title
        book_obj.publisher_id = new_publisher_id
        # 同步到数据库
        book_obj.save()
        return redirect("/book_list/")

Views.py

huml页面代码：

{#book_list.html#}

<table border="1">
    <thead>
    <tr>
        <th>#</th>
        <th>书名</th>
        <th>出版社名称</th>
        <th>操作</th>
    </tr>
    </thead>
    <tbody>
        {% for book in book_list %}
            <tr>
            <td>{{ forloop.counter }}</td>
            <td>{{ book.title }}</td>
            <td>{{ book.publisher.name }}</td>
            <td>
                <a href="/delete_book/{{ book.id }}/">删除</a>
                <a href="/edit_book/{{ book.id }}/">编辑</a>
            </td>
            </tr>
        {% endfor %}
    </tbody>
</table>

{#edit_book.html#}

<form action="" method="post">
{% csrf_token %}
    <input type="text" name="title" value="{{ book.title }}">
    <select name="publisher">
        {% for publisher in publisher_list %}

            {% if book.publisher == publisher %}
                <option selected value="{{ publisher.id }}">{{ publisher.name }}</option>
            {% else %}
                <option value="{{ publisher.id }}">{{ publisher.name }}</option>
            {% endif %}
        {% endfor %}
    </select>
    <input type="submit" value="提交">
</form>

{#add_book.html#}

<form action="" method="post">
{% csrf_token %}
    <input type="text" name="title">
    <select name="publisher">
        {% for publisher in publisher_list %}
            <option value="{{ publisher.id }}">{{ publisher.name }}</option>
        {% endfor %}
    </select>
    <input type="submit" value="提交">
</form>

html页面代码

2）正常查找

对象查找（跨表）：

语法：对象.关联字段.字段

字段查找（跨表）：

语法：关联字段__字段

3）反向查找

对象查找：

语法：obj.表名_set

字段查找：

语法：表名__字段

示例：

    # 查询第一本书关联的出版社的名字
    # 1. 基于对象的查询
    book_obj = models.Book.objects.first()
    ret = book_obj.publisher.name
    print(ret)
    # 2. 基于queryset的双下划线查询，双下划线表示跨表
    ret = models.Book.objects.all().values_list("publisher__name").distinct()
    print(ret)

    # 反向查询
    # 1. 由出版社反向查询书籍(基于对象的查询)
    publisher_obj = models.Publisher.objects.get(id=2)  # 找到张江出版社
    # 张江出版社出版的所有书籍
    ret = publisher_obj.book_set.all()
    print(ret)

    # 2. 基于queryset的双下划线
    # 江出版社出版的所有书籍的书名
    ret = models.Publisher.objects.filter(id=2).values_list("book__title")
    print(ret)