2019年4月1日13:28:30 发表评论 571 views

第1章 ORM基础

1.1 ORM介绍

1.1.1 ORM概念

对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单的说ORM是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。ORM在业务逻辑层和数据库层之间充当了桥梁的作用。

1.1.2 ORM由来

字母O起源于"对象"(Object)，而R则来自于"关系"(Relational)，几乎所有的软件开发过程中都会涉及到对象和关系数据库。在用户层面和业务逻辑层面，我们是面向对象的，当对象的信息发生变化的时候，我们就需要把对象的信息保存在关系数据库中。按照之前的方式来进行开发就会出现程序员会在自己的业务逻辑代码中夹杂很多SQL语句用来增加、读取、修改、删除相关数据，而这些代码通常都是重复的。

1.1.3 ORM的优势

ORM解决的主要问题是对象和关系的映射，它通常把一个类和一个表一一对应，类的每个实例对应表中的一条记录，类的每个属性对应表中的每个字段。ORM提供了对数据库的映射，不用直接编写SQL代码，只需像操作对象一样从数据库操作数据，让软件开发人员专注于业务逻辑的处理，提高了开发效率。

1.1.4 ORM的劣势

ORM的缺点是会在一定程度上牺牲程序的执行效率，ORM用多了SQL语句就不会写了，关系数据库相关技能退化...

1.1.5 ORM总结

ORM只是一种工具，工具确实能解决一些重复、简单的劳动，但我们不能指望某个工具能一劳永逸地解决所有问题，一些特殊问题还是需要特殊处理的，但是在整个软件开发过程中需要特殊处理的情况应该都是很少的。

1.2 Django中的ORM

1.2.1 使用MySQL数据库

在Django项目的settings.py文件中配置数据库连接信息：

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.mysql",
        "NAME": "你的数据库名称",           # 需要自己手动创建数据库
        "USER": "数据库用户名",
        "PASSWORD": "数据库密码",
        "HOST": "数据库IP",
        "POST": 3306
    }
}

在settings.py同目录下的__init__.py文件中配置使用pymysql模块连接MySQL数据库：

import pymysql
pymysql.install_as_MySQLdb()

在app/models.py中定义类，类一定要继承models.Model：

class Book(models.Model):
    id = models.AutoField(primary_key=True)
    title = models.CharField(max_length=32)

在和manage.py同级的目录下执行两条命令：

python manage.py makemigrations # 将models.py文件中的改动记录在app/migrations/00xx_****.py上
python manage.py migrate        # 将改动翻译成SQL语句并去数据库中执行

1.2.2 Model

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

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

1.2.3 快速入门

【示例】：定义一个包含first_name和last_name的Person模型：

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发现已经明确地设置了primary_key，它将不会添加自动ID列。
本示例中的CREATE TABLE SQL使用PostgreSQL语法进行格式化，但Django会根据配置文件中指定的数据库后端类型来生成相应的SQL语句。
Django支持5及更高版本。

第2章 Django ORM 常用字段和参数

2.1 常用字段

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

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

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

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

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

2.2 字段合集

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
参数：
1. protocol：用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
2. unpack_ipv4：如果指定为True，则输入::ffff:192.0.2.1时候可解析为192.0.2.1，开启此功要rotocol="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中提供读取文件夹下文件的功能
参数：
1. path, 文件夹路径
2. match=None,                正则匹配
3. recursive=False,   递归下面的文件夹
4. allow_files=True, 允许文件
5. allow_folders=False, 允许文件夹

FileField(Field)
字符串，路径保存在数据库，文件上传到指定目录
参数：
1. upload_to = ""      上传文件的保存路径
2. storage = None 存储组件，默认django.core.files.storage.FileSystemStorage

ImageField(FileField)
字符串，路径保存在数据库，文件上传到指定目录
参数：
1. upload_to = "" 上传文件的保存路径
2. storage = None 存储组件，默认django.core.files.storage.FileSystemStorage
3. width_field=None, 上传图片的高度保存的数据库字段名（字符串）
4. 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进制小数
参数：
1. max_digits，小数总长度
2. decimal_places，小数位长度

BinaryField(Field)
二进制类型

2.3 自定义字段

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):
        super().__init__(max_length=max_length, *args, **kwargs)
        self.length = max_length

    def db_type(self, connection):
        """
        限定生成数据库表的字段类型为char，长度为length指定的值
        """
        return 'char(%s)' % self.length

class Class(models.Model):
    id = models.AutoField(primary_key=True)
    title = models.CharField(max_length=25)
    # 使用上面自定义的char类型的字段
    cname = FixedCharField(max_length=25)

创建的表结构：

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.4 字段参数

2.4.1 通用参数

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

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

db_index
如果db_index=True 则代表着为此字段设置数据库索引。

default
为该字段设置默认值。

2.4.2 时间字段独有参数

DatetimeField、DateField、TimeField这个三个时间字段都可以设置如下属性：

auto_now_add
配置auto_now_add=True，创建数据记录的时候时候自动填充当前时间到数据库中。

auto_now
配置上auto_now=True，每次修改的时候自动把当前时间更新。

第3章关系字段

3.1 ForeignKey

外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多'中'多'的一方。ForeignKey可以和其他表做关联关系同时也可以和自身做关联关系。

3.1.1 字段参数

to
设置要关联的表。

to_field
设置要关联的表的字段。

related_name
反向操作时使用的字段名，用于代替原反向查询时的'表名_set'。

class Classes(models.Model):
        name = models.CharField(max_length=32)

class Student(models.Model):
        name = models.CharField(max_length=32)
        theclass = models.ForeignKey(to="Classes")

# 查询某个班级关联的所有学生（反向查询）
models.Classes.objects.first().student_set.all()

# 在ForeignKey字段中添加了参数 related_name 后
class Student(models.Model):
        name = models.CharField(max_length=32)
# 1对多，外键通常设置在多的那一边（一个班级对应多个学生，外键设置在学生处）
        theclass = models.ForeignKey(to="Classes", related_name="students")

# 查询某个班级关联的所有学生（反向查询）
models.Classes.objects.first().students.all()

related_query_name
反向查询操作时，使用的连接前缀，用于替换表名。

on_delete
当删除关联表中的数据时，当前表与其关联的行的行为。

models.CASCADE：删除关联数据，与之关联也删除
models.DO_NOTHING：删除关联数据，引发错误IntegrityError
models.PROTECT：删除关联数据，引发错误ProtectedError
models.SET_NULL：删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
models.SET_DEFAULT：删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
models.SET：删除关联数据，
a) 与之关联的值设置为指定值，设置：models.SET(值)
b) 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)

def func():
        return 10

class MyModel(models.Model):
        user = models.ForeignKey(
            to="User",
            to_field="id"，
            on_delete=models.SET(func)
        )

db_constraint
是否在数据库中创建外键约束，默认为True，False：外键软关联，不建立约束。

3.2 OneToOneField

通常一对一字段用来扩展已有字段，既保证数据都完整的保存下来，又能保证大部分的检索更快。

3.2.1 使用场景

一对一的关联关系多用在当一张表的不同字段查询频次差距过大的情况下将本可以存储在一张表的字段拆开放置在两张表中，然后将两张表建立一对一的关联关系。

3.2.2 字段参数

to
设置要关联的表。

to_field
设置要关联的字段。

on_delete
同ForeignKey字段。

【示例】：一对一的查询

from app02 import models
author_obj = models.Author.objects.get(id=1)
obj = author_obj.detail
print(obj.hobby, obj.addr)

【SQL语句】：

SELECT `app02_author`.`id`, `app02_author`.`name`, `app02_author`.`age`, `app02_author`.`phone`, `app02_author`.`detail_id` FROM `app02_author` WHERE `app02_author`.`id` = 1; args=(1,)

SELECT `app02_authordetail`.`id`, `app02_authordetail`.`hobby`, `app02_authordetail`.`addr` FROM `app02_authordetail` WHERE `app02_authordetail`.`id` = 1; args=(1,)

【运行结果】：

篮球 abc

【示例】：在app02里面查询id是1的作者关联的书

ret = models.Author.objects.get(id=1).books.all()
print(ret)

【SQL语句】：

SELECT `app02_book`.`id`, `app02_book`.`title`, `app02_book`.`publish_date`, `app02_book`.`price`, `app02_book`.`publisher_id` FROM `app02_book` INNER JOIN `app02_author_books` ON (`app02_book`.`id` = `app02_author_books`.`book_id`) WHERE `app02_author_books`.`author_id` = 1 LIMIT 21; args=(1,)

【运行结果】：

<QuerySet [<Book: Dive Into Python 3第一版>, <Book: Python编程快速上手第一版>]>

【示例】：从作者关联的书里面移除id是1的书

ret = models.Author.objects.get(id=1).books.remove(5)

SQL语句】：

DELETE FROM `app02_author_books` WHERE (`app02_author_books`.`author_id` = 1 AND `app02_author_books`.`book_id` IN (5)); args=(1, 5)

【运行结果】：

3.3 ManyToManyField

用于表示多对多的关联关系，在数据库中通过第三张表来建立关联关系。

3.3.1 字段参数

to
设置要关联的表

related_name
同ForeignKey字段。

related_query_name
同ForeignKey字段。

symmetrical
仅用于多对多自关联时，指定内部是否创建反向操作的字段。默认为True。

# 此时person对象就没有person_set属性
class Person(models.Model):
        name = models.CharField(max_length=16)
        # 多对多，通常设置在正向查询多的那一边
        friends = models.ManyToManyField("self")

# 此时person对象可以使用person_set属性进行反向查询
class Person(models.Model):
        name = models.CharField(max_length=16)
        friends = models.ManyToManyField("self", symmetrical=False)

through
在使用ManyToManyField字段时，Django将自动生成一张表来管理多对多的关联关系,也可以手动创建第三张表来管理多对多关系，此时就需要通过through来指定第三张表的表名。

through_fields
设置关联的字段。

db_table
默认创建第三张表时，数据库中表的名称。

3.3.2 多对多关联关系的三种方式

3.3.2.1 方式一：自行创建第三张表

# 书
class Book(models.Model):
    title = models.CharField(max_length=32)
    publish_date = models.DateField(auto_now_add=True)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    # 创建外键，关联publish
    publisher = models.ForeignKey(to="Publisher")

    def __str__(self):
        return self.title

# 作者
class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    phone = models.IntegerField()
    detail = models.OneToOneField(to="AuthorDetail")

    def __str__(self):
        return self.name

# 自己动手创建作者和书关联的第三张表
# 此时在ORM层面作者和书就没有多对多的关系了
class Author2Book(models.Model):
    id = models.AutoField(primary_key=True)
    # 作者id
    author = models.ForeignKey(to="Author")
    # 书id
    book = models.ForeignKey(to="Book")

    class Meta:
        # 建立唯一约束
        unique_together = ("author", "book")

【示例】：在app03里面查询id是4的作者关联的书

from app03 import models
ret = models.Author2Book.objects.filter(author_id=4).values_list("book_id")
print(ret)

【SQL语句】：

SELECT `app03_author2book`.`book_id` FROM `app03_author2book` WHERE `app03_author2book`.`author_id` = 4 LIMIT 21; args=(4,)

【运行结果】：

<QuerySet [(2,), (4,), (10,)]>

【示例】：在app03里面查询id是4的作者关联的书的id

from app03 import models
ret = models.Author2Book.objects.filter(author_id=4).values_list("book_id")
ret = [i[0] for i in ret]
print(ret)

【SQL语句】：

SELECT `app03_author2book`.`book_id` FROM `app03_author2book` WHERE `app03_author2book`.`author_id` = 4; args=(4,)

【运行结果】：

[2, 4, 10]

【示例】：在app03里面查询id是4的作者关联的书的名称

from app03 import models
ret = models.Author2Book.objects.filter(author_id=4).values_list("book_id")
ret = models.Book.objects.filter(id__in=ret)
print(ret)

【SQL语句】：

SELECT `app03_book`.`id`, `app03_book`.`title`, `app03_book`.`publish_date`, `app03_book`.`price`, `app03_book`.`publisher_id` FROM `app03_book` WHERE `app03_book`.`id` IN (SELECT U0.`book_id` AS Col1 FROM `app03_author2book` U0 WHERE U0.`author_id` = 4) LIMIT 21; args=(4,)

【运行结果】：

<QuerySet [<Book: 像计算机科学家一样思考Python第一版>, <Book: Python编程快速上手第一版>, <Book: 跟我学python第一版>]>

3.3.2.2 方式二：通过ManyToManyField自动创建第三张表

# 书
class Book(models.Model):
    title = models.CharField(max_length=32)
    publish_date = models.DateField(auto_now_add=True)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    # 创建外键，关联publish
    publisher = models.ForeignKey(to="Publisher")

    def __str__(self):
        return self.title

# 作者
class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    phone = models.IntegerField()
    # 通过ORM自带的ManyToManyField自动创建第三张表
    books = models.ManyToManyField(to="Book", related_name="authors")
    detail = models.OneToOneField(to="AuthorDetail")

    def __str__(self):
        return self.name

3.3.2.3 方式三：设置ManyTomanyField并指定自行创建的第三张表

# 书
class Book(models.Model):
    title = models.CharField(max_length=32)
    publish_date = models.DateField(auto_now_add=True)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    # 创建外键，关联publish
    publisher = models.ForeignKey(to="Publisher")

    def __str__(self):
        return self.title

# 作者
class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    phone = models.IntegerField()
    # 通过through，through_fields来指定使用我创建的第三张表来构建多对多的关系
    # through_fields接受一个2元组（'field1'，'field2'）：
    # field1是定义ManyToManyField的模型外键的名（author），field2是关联目标模型（book）的外键名。
    books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book",))
    # 第一个字段：多对多设置在哪一张表里，第三张表通过什么字段找到这张表就把这个字段写在前面
    detail = models.OneToOneField(to="AuthorDetail")

    def __str__(self):
        return self.name

# 自己创建第三张表，并通过ManyToManyField指定关联，此时在ORM层面
class Author2Book(models.Model):
    id = models.AutoField(primary_key=True)
    # 作者id
    author = models.ForeignKey(to="Author")
    # 书id
    book = models.ForeignKey(to="Book")
    # memo
    memo = models.CharField(max_length=64, null=True)

    class Meta:
        # 建立唯一约束
        unique_together = ("author", "book")

注意：当需要在第三张关系表中存储额外的字段时就要使用第三种方式，但是当使用第三种方式创建多对多关联关系时，无法使用set、add、remove、clear方法来管理多对多的关系，需要通过第三张表的model来管理多对多关系。

【示例】：在app04里面查询id是5的作者关联的书

from app04 import models
ret = models.Author.objects.get(id=5).books.all()
print(ret)

【SQL语句】：

SELECT `app04_author`.`id`, `app04_author`.`name`, `app04_author`.`age`, `app04_author`.`phone`, `app04_author`.`detail_id` FROM `app04_author` WHERE `app04_author`.`id` = 5; args=(5,)

SELECT `app04_book`.`id`, `app04_book`.`title`, `app04_book`.`publish_date`, `app04_book`.`price`, `app04_book`.`publisher_id` FROM `app04_book` INNER JOIN `app04_author2book` ON (`app04_book`.`id` = `app04_author2book`.`book_id`) WHERE `app04_author2book`.`author_id` = 5 LIMIT 21; args=(5,)

【运行结果】：

<QuerySet [<Book: Python编程：从入门到实践第一版>, <Book: Python自然语言处理第一版>]>

【示例】：从id是4的作者关联的书里面移除id是2的书

from app04 import models
# 此时没有django ORM 封装的那些快捷方式了，需要自己亲自改第三张表
models.Author2Book.objects.get(author_id=1, book_id=1).delete()

【SQL语句】：

SELECT `app04_author2book`.`id`, `app04_author2book`.`author_id`, `app04_author2book`.`book_id`, `app04_author2book`.`memo` FROM `app04_author2book` WHERE (`app04_author2book`.`author_id` = 4 AND `app04_author2book`.`book_id` = 2); args=(4, 2)

DELETE FROM `app04_author2book` WHERE `app04_author2book`.`id` IN (7); args=(7,)

【运行结果】：

3.3.3 元信息

ORM对应的类里面包含另一个Meta类，而Meta类封装了一些数据库的信息。主要字段如下：

db_table
ORM在数据库中的表名默认是 app_类名，可以通过db_table可以重写表名。

index_together
联合索引。

unique_together
联合唯一索引。

ordering
指定默认按什么字段排序，只有设置了该属性查询到的结果才可以被reverse()。

第4章测试环境

4.1 数据库初始化

4.1.1 models.py文件

from django.db import models
# Create your models here.

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

    def __str__(self):
        return self.name

# 书
class Book(models.Model):
    title = models.CharField(max_length=32)
    publish_date = models.DateField(auto_now_add=True)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    # 创建外键，关联publish
    publisher = models.ForeignKey(to="Publisher")

    def __str__(self):
        return self.title

# 作者
class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    phone = models.IntegerField()
    books = models.ManyToManyField(to="Book", related_name="authors")
    detail = models.OneToOneField(to="AuthorDetail")

    def __str__(self):
        return self.name

# 作者详情
class AuthorDetail(models.Model):
    # 爱好
    hobby = models.CharField(max_length=32)
    # 地址
    addr = models.CharField(max_length=128)

4.2 数据库表数据

4.2.1 app02_publisher表

4.2.2 app02_author表

4.2.3 app02_book表

4.2.4 app02_author_books表

4.2.5 app02_authordetail表

第5章参考资料

https://www.cnblogs.com/liwenzhou/p/8688919.html

https://docs.djangoproject.com/en/2.0/topics/db/queries/

我的微信

如果有技术上的问题可以扫一扫我的微信

1. 本网站名称：Leon的博客
2. 本站永久网址：https://blog.leonshadow.cn
3. 本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长QQ632113590进行删除处理。
4. 本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
5. 本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
6. 本站资源大多存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。

2023年 3月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

第1章 ORM基础

1.1 ORM介绍

1.1.1 ORM概念

1.1.2 ORM由来

1.1.3 ORM的优势

1.1.4 ORM的劣势

1.1.5 ORM总结

1.2 Django中的ORM

1.2.1 使用MySQL数据库

1.2.2 Model

1.2.3 快速入门

第2章 Django ORM 常用字段和参数

2.1 常用字段

2.2 字段合集

2.3 自定义字段

2.4 字段参数

2.4.1 通用参数

2.4.2 时间字段独有参数

第3章 关系字段

3.1 ForeignKey

3.1.1 字段参数

3.2 OneToOneField

3.2.1 使用场景

3.2.2 字段参数

3.3 ManyToManyField

3.3.1 字段参数

3.3.2 多对多关联关系的三种方式

3.3.2.1 方式一：自行创建第三张表

3.3.2.2 方式二：通过ManyToManyField自动创建第三张表

3.3.2.3 方式三：设置ManyTomanyField并指定自行创建的第三张表

注意：当需要在第三张关系表中存储额外的字段时就要使用第三种方式，但是当使用第三种方式创建多对多关联关系时，无法使用set、add、remove、clear方法来管理多对多的关系，需要通过第三张表的model来管理多对多关系。

3.3.3 元信息

第4章 测试环境

4.1 数据库初始化

4.1.1 models.py文件

4.2 数据库表数据

4.2.1 app02_publisher表

4.2.2 app02_author表

4.2.3 app02_book表

4.2.4 app02_author_books表

4.2.5 app02_authordetail表

第5章 参考资料

第3章关系字段

第4章测试环境

第5章参考资料