• Django ORM查询

    文章目录

    Django提供了一套非常方便的类似SqlAlchemy ORM的通过对象调用的方式操作数据库表的ORM框架。

    Django ORM操作主要分为以下几类：

    1. 增：向表内插入一条数据
    2. 删：删除表内数据（物理删除）
    3. 改：update操作更新某条数据
    4. 查：基本的表查询（包括多表、跨表、子查询、联表查询）

    其中比较复杂的是表查询。下面分类讲解这几种操作方式。

    1 增 – 向表内插入一条数据

    关于新增记录的操作这里分为两种方式:

    • 第一种方式，通过模型对象的save()方法：
    userObj=User()
userObj.username= request.data.get('username')
# userObj.password= make_password(request.POST.get('password'),None,'pbkdf2_sha256')  # 创建django密码，第三个参数为加密算法
userObj.set_password(request.data.get('password'))  # 创建django密码，第三个参数为加密算法
userObj.name= request.data.get('name')
userObj.phone= request.data.get('phone')
userObj.email= request.data.get('email')
userObj.create_name= request.data.get('create_name')
userObj.update_name= request.data.get('update_name')
userObj.is_superuser= 0
print(userObj.username)
print('username %s' % (userObj.username))
print('password %s' % (userObj.password))
userObj.save()


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    这种方式先创建一个模型对象，赋值，最后调用模型的 .save()方法的方式向数据库插入一条数据。

    • 第二种方式，通过objects.create的方式直接新增，类似一种缩略的方式，比较简单
    res = models.User.objects.create(username='admin',make_password='123456',register_time=datetime.datetime.now())
print(res)

    • 1
    • 2

    2 删 – 删除表内数据（物理删除）

    django删除表数据是通过.delete()方法，举例：

    如果我们只删除 user表 主键为1的记录： ret = models.User.objects.get(pk=1).delete()
    上述是只删一条记录，删除多条记录类似： ret = models.User.objects.filter(pk__gt=1).delete()

    这样我们可以批量删除user表中主键值大于1的其他所有记录。

    需要提醒的是，这种方式属于物理删除，删除后不可恢复，如需逻辑删除，参考下面 update的方式。

    3 改 – update操作更新某条数据

    django ORM 的改操作，这里分为三种方式。我们先按单记录的更新讲解，批量更新类似：

    • 第一种，指定更新字段更新：
    ret = models.User.objects.get(pk=1).update(username='admin',password='123456')

    • 1
    • 第二种，通过 Json 更新：
    object = {'username':'admin','password':'123456'}
ret = models.User.objects.get(pk=1).update(**object)

    • 1
    • 2
    • 第三种，类似增操作，直接通过.save()方法更新整条记录
    userObj=User()
userObj.id= request.data.get('id')
userObj.username= request.data.get('username')
# userObj.password= make_password(request.POST.get('password'),None,'pbkdf2_sha256')  # 创建django密码，第三个参数为加密算法
userObj.set_password(request.data.get('password'))  # 创建django密码，第三个参数为加密算法
userObj.name= request.data.get('name')
userObj.phone= request.data.get('phone')
userObj.email= request.data.get('email')
userObj.create_name= request.data.get('create_name')
userObj.update_name= request.data.get('update_name')
userObj.is_superuser= 0
print(userObj.username)
print('username %s' % (userObj.username))
print('password %s' % (userObj.password))
userObj.save()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    这种方式不太建议用，需要注意数据的完整性。

    4 查 – 基本的表查询（包括多表、跨表、子查询、联表查询）

    4.1 基本查询

    需要了解如下方法的使用：

    1. all() 查询所有数据
    2. filter() 带有过滤条件的查询 where
    3. get() 获取单条，查询不到会报错
    4. first() 取queryset里第一条记录
    5. last() 取queryset里最后一条记录
    6. values() 指定要获取的字段
    models.User.objects.filter(pk=1).values('username','phone')
# 返回 

    • 1
    • 2
    1. values_list() 列表套元祖
     models.User.objects.filter(pk=1).values_list('username','phone')
# 返回 

    • 1
    • 2
    1. distinct() 去重
    ret = models.User.objects.filter(pk=1).distinct()

    • 1

    需要注意，这里去重是针对整条数据的去重，主键不一样也不会去重

    1. order_by() 排序
    ret = models.User.objects.order_by('username')# 默认升序
ret = models.User.objects.order_by('-username')# 降序

    • 1
    • 2
    1. reverse() 反转，前提已排序
    ret = models.User.objects.order_by('username').reverse()# 默认升序
ret = models.User.objects.order_by('-username').reverse()# 降序

    • 1
    • 2
    1. count() 当前查询条件的记录数
    ret = models.User.objects.filter(pk=1).count()

    • 1
    1. exclude() 排除 ，相当于查询条件不等于
    ret = models.User.objects.exclude(pk=1)

    • 1
    1. exists() 记录是否存在，不太实用，不过多讲

    4.2 双下划线查询条件

    django不支持 类似：>=,<=等查询判断方式，但提供了一套很好用的方法：

    • __gt <=> 大于:
      ret = models.User.objects.filter(id__gt=1)#查询id>1的记录

    • __lt <=> 小于: ret = models.User.objects.filter(id__lt=1)#查询id<1的记录

    • __gte <=> 大于等于: ret = models.User.objects.filter(id__gte=1)#查询id>=1的记录

    • __lte <=> 小于等于: ret = models.User.objects.filter(id__lte=1)#查询id<=1的记录

    • __in <=> 条件是否归属所给的选择: ret = models.User.objects.filter(id__in=[1,2])#查询id=1或id=2的记录

    • __range <=> 范围: ret = models.User.objects.filter(id__range=[1,3])#查询1<=id<=3的记录

    • __contains <=> 模糊查询 ,区分大小写: ret = models.User.objects.filter(username__contains='a')#查询 username like '%a%'的记录

    • __icontains <=> 模糊查询 ,不区分大小写: ret = models.User.objects.filter(username__icontains='a')#查询 username like '%a%'的记录

    • __startswith <=> 模糊查询 ,指定内容开始: ret = models.User.objects.filter(username__icontains='a')#查询 username like 'a%'的记录

    • __endswith <=> 模糊查询 ,指定内容结束: ret = models.User.objects.filter(username__icontains='a')#查询 username like '%a'的记录

    注意：__contains、__icontains、__startswith、__endswith这些模糊查询性能很低，生产环境不建议使用。

    4.3 逻辑查询：or、and、not

    涉及概念：Django的Q对象

    4.3.1 Q对象

    Q对象实例化后能够增加各个条件之间的关系，而且这种写法用在你不知道用户到底传入了多少个参数的时候很方便。

    1. 比如默认情况下filter()里面每个字段的连接都是&，我们使用Q对象通常都是让它变成|，来进行查询 。
    from django.db.models import Q

query = Q()
q1 = Q()
q1.connector = "AND"  # 连接的条件是AND 代表就是& 
q1.children.append(("email", "280773872@qq.com")) # email代表的是数据库的字段
q1.children.append(("password", "666"))
 # 等同于：email="280773872@qq.com" & password="666"
q2 = Q()
q2.connector = "AND"  # 同样q2对象连接条件也是AND 
q2.children.append(("username", "fe_cow")) # 同样数据库里username字段
q2.children.append(("password", "fe_cow666"))
 # 等同于：username="fe_cow" & password="fe_cow666"
query.add(q1, "OR") 
query.add(q2, "OR")
 # query目前里面的符合条件结果就是: （email="280773872@qq.com" & password="666"） |  （username="fe_cow" & password="fe_cow666"）
userinfo_obj = models.UserInfo.objects.filter(query).first()


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    filter()过滤器的方法中关键字参数查询，会合并为And(),需要进行or查询，使用Q()对象，Q对象django.db.models.Q用于封装一组关键字参数，这些关键字参数与比较运算符中的相同。

    • Q对象可以使用&(and)、|(or)操作符组合起来，当操作符应用在两个Q对象时，会产生一个新的Q对象。
    list.filter(pk__lt=6).filter(bcomment__gt=10) 
list.filter(Q(pk__lt=6) | Q(bcomment__gt=10))

    • 1
    • 2

    • 使用~操作符在Q对象前表示取反: list.filter(~Q(pk__lt=6))

    • 可以使用&|~结合括号进行分组，构造出复杂的Q对象

    4.3.2 or、and、not
    import os
import django


os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'salary.settings')
django.setup(set_prefix=False)

from employee.models import Employees  # 这一行必须在`os.environ.setdefault`之后，先把配置、环境变量准备好后才能import
from django.db.models import Q
# emps = Employees.objects.all()  # 懒查询，只有后面对查询结构有引用时，才会驱动真正的查询
# print(emps)  # 查询集

mgr = Employees.objects
# AND查询： 五种方式
x = mgr.filter(pk__gt=10005, pk__lt=10010)
print(x)
y = mgr.filter(pk__gt=10005).filter(pk__lt=10010)
print(y)
z = mgr.filter(pk__gt=10005) & mgr.filter(pk__lt=10010)
print(z)
# Django的Q对象
xx = mgr.filter(Q(pk__gt=10005) & Q(pk__lt=10010))
yy = mgr.filter(Q(pk__gt=10005), Q(pk__lt=10010))

# OR查询: 三种方式
x = mgr.filter(pk__in=[10005, 10010])
print(x)
y = mgr.filter(pk=10005) | mgr.filter(pk=10010)
print(y)
z = mgr.filter(Q(pk=10005) | Q(pk=10010))

# NOT查询：
x = mgr.exclude(pk=10005)
print(x)
y = mgr.filter(~(Q(pk__gt=10005) & Q(pk__lt=10010)))
print(y)

    • 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
    • 32
    • 33
    • 34
    • 35
    • 36

    4.3.3 集合查询

    # 聚合
from django.db.models import Max, Min, Count, Sum, Avg
x = mgr.filter(pk__gt=10008).count()  # 将所有数据看做一行出结构
print(x)  # 单值
# aggregate聚合函数：出统计函数的结果，返回字典，默认key命名为`字段名_聚合函数名`
y = mgr.filter(pk__gt=10008).aggregate(Count("pk"), Max("pk"), Min("pk"), sm_pk=Sum('pk'), avg_pk=Avg('pk'))  # 可以给聚合查询结果起别名
print(y)
# 结果：{'sm_pk': 120174, 'avg_pk': 10014.5, 'pk__count': 12, 'pk__max': 10020, 'pk__min': 10009}
# annotate聚合函数：这个聚合函数会分组，没有指定分组使用pk分组，行行分组。返回结果集
z = mgr.filter(pk__gt=10013).annotate(Count("pk"), Max("pk"), Min("pk"), sm_pk=Sum('pk'), avg_pk=Avg('pk'))
print(z)
xx = mgr.filter(pk__gt=10013).values('gender').annotate(c=Count("pk")).values("c")  # 第一个values控制分组，第二个values控制投影
print(xx)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    4.4 多表查询

    4.4.1 一对多查询
    1. Django不支持联合主键，只支持单一主键，这一点和sqlalchemy不一样
    2. Django不支持在Model中声明编码格式，这一点和sqlalchemy不一样，只能在setting.py的DATABASES注册中添加选项
    DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'test',
        'USER': 'root',
        'PASSWORD': 'cli*963.',
        'HOST': '127.0.0.1',
        'PORT': '3306',
    },
    'OPTIONS': {
        'charset': 'utf8mb4',
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    一对多模型构造：
    员工表 – 工资表是一对多的关系。由于django不支持联合主键，需改造工资表。增加自增的id列，并设为主键，删除其他主键和外键。

    from django.db import models

# Create your models here.


class Employees(models.Model):
    """
    CREATE TABLE `employees` (
      `emp_no` int(11) NOT NULL,
      `birth_date` date NOT NULL,
      `first_name` varchar(14) NOT NULL,
      `last_name` varchar(16) NOT NULL,
      `gender` enum('M','F') NOT NULL,
      `hire_date` date NOT NULL,
      PRIMARY KEY (`emp_no`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;
    """
    class Meta:  # 数据库表名，固定的，Django就是这样定义，一个Meta类
        db_table = "employees"  # 表名

    emp_no = models.IntegerField(primary_key=True, null=False)
    birth_date = models.DateField(null=False)
    first_name = models.CharField(max_length=14, null=False)
    last_name = models.CharField(null=False, max_length=16)
    gender = models.SmallIntegerField(null=False)
    hire_date = models.DateField(null=False)
    # 在多端添加了外键属性后，主端的（Employees）类属性字典__dict__中会自动增加一个默认名称为Salaries_set的属性。
    # 如果外键声明的参数中使用了related_name=***，则这个属性的名称变为related_name指定的值

    # 序列化
    filed = '__all__'
    depth = 1

    def __repr__(self):
        return "".format(self.emp_no, self.first_name, self.last_name)

    @property
    def full_name(self):
        return "full name:{}-{}".format(self.first_name, self.last_name)

    __str__ = __repr__


class Salaries(models.Model):
    """
    CREATE TABLE `salaries` (
      `emp_no` int(11) NOT NULL,
      `salary` int(11) NOT NULL,
      `from_date` date NOT NULL,
      `to_date` date NOT NULL,
      `id` int(11) NOT NULL AUTO_INCREMENT,
      PRIMARY KEY (`id`) USING BTREE,
      KEY `emp_no` (`emp_no`),
      CONSTRAINT `salaries_ibfk_1` FOREIGN KEY (`emp_no`) REFERENCES `employees` (`emp_no`) ON DELETE CASCADE
    ) ENGINE=InnoDB AUTO_INCREMENT=41 DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;
    """
    class Meta:
        db_table = "salaries"
    # 一对多的多端，被引用的主表中的字段名emp_no，在多端(从表)的类属性字典__dict__中保存的key值为emp_no_id，实际上对应了主表emp_no在数据库中的值。
    # 多端查询这个被引用的外键值时，也是拿着emp_no_id去主表中查的，此时会报key emp_no_id不存在异常。这种情况只需在外键声明的参数中使用db_column='emp_no'指定key值。
    emp_no = models.ForeignKey('Employees', models.CASCADE, db_column='emp_no')
    # emp_no = models.ForeignKey('Employees', models.CASCADE, db_column='emp_no', related_name="salaries")  # 使用related_name
    salary = models.IntegerField(null=False)
    from_date = models.DateField(null=False)
    to_date = models.DateField(null=False)
    id = models.AutoField(primary_key=True)  # 自增

    def __repr__(self):
        return "".format(self.emp_no_id, self.salary)

    __str__ = __repr__


    • 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
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72

    如上示例，在Salaries Model模型类中，创建ForeignKey外键。创建外键后:

    • 一对多的多端：多端这里就是Salaries定义的表。在这里，多端（从表）引用的主表的主键对应的字段名为emp_no。
      多端Salaries的类属性字典__dict__中会自动增加一个属性，命名规则为被引用的字段名_id，这里就是emp_no_id，
      对应主表在数据库中emp_no字段的值。在多端查询时，由于拿着emp_no_id去主表中查，而主表中的key为emp_no，
      导致报key emp_no_id不存在错误时，这种情况需在外键声明中加上db_column="emp_no"就可以了，
      表示不要用Django自动命名的emp_no_id去查，而是用指定的key值去主表中查。
    • 一对多的一端：多端加了外键属性后，主表类属性字典__dict__中会自动增加salaries_set属性，命名规则默认为多端表名_set。
      如果在外键声明中增加related_name="Salaries"参数，则这个自动增加的属性名则使用related_name指定的值

    所以：

    • 从一端向多端查，则使用instance.salaries_set
    • 从多端向一端查，则使用instance.emp_no_id
    • 在多端的__repr__中，为了提高效率不触发主表查询，也应该用self.emp_no_id，而不是self.emp_no
    print(*Employee.__dict__.items(), sep='\n')  
# 一端，Employees类中多了一个类属性
#（'salaries_set', )

print(*salary._dict_,itemsO), sep='\n')
# 多端，Salaries类中也多了一个类属性
#('emp_no_id'，)
#（'emp_no' ）指向Employees类的一个实例

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    查询示例：

    import os
import django


os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'salary.settings')
django.setup(set_prefix=False)

from employee.models import Employees, Salaries  # 这一行必须在`os.environ.setdefault`之后，先把配置、环境变量准备好后才能import


print(Employees.__dict__.items())
print('_______________')
print(Salaries.__dict__.items())
print('______________')
emps = Employees.objects
sals = Salaries.objects
# 查询10004号员工的工资
# 从员工表查询，这个好，没有冗余查询
emp = emps.get(pk=10004)  # 一个Employees对象
print(emp.salaries_set.all())  # 返回一个查询结果集

# 从工资表查询，这个不好，多对一，产生了冗余查询
sal = sals.filter(emp_no=10004).all()
print(sal)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    distinct去重:

    # 查询工资大于5500的员工
_emps = sals.filter(salary__gt=5500).values('emp_no').distinct()
print(_emps)
print(emps.filter(emp_no__in=_emps))  # in子查询
# print(emps.filter(emp_no__in=[x.get("emp_no") for x in _emps]))  # in列表

    • 1
    • 2
    • 3
    • 4
    • 5

    raw的使用：
    对于非常复杂的sql语句，使用django ORM不好写了，可以使用raw，直接执行sql语句。 例如：

    # 查询工资大于50000的所有员工的姓名
sql = """
SELECT DISTINCT e.* from employees as e
JOIN salaries as s
ON e.emp_no = s.emp_no
WHERE salary > 50000
"""
emgr = Employees.objects  # 管理器
res = emgr.raw(sql)
print(list(res))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    更多学习案例：
    https://juejin.cn/post/6974298891353063431

    4.4.2 多对多查询

    多对多查询有两种建模方式：

    • 借助第三张表。

    例如一个员工可以在多个部门，一个部门有多个员工。这种多对多的关系，可以增加第三张表"部门-员工表"。这样多对多模型转换为"多-1-多"的模型：部门表 - 部门&员工表 - 员工表"。最后查询转为为一对多的查询。

    • 使用models.ManyToManyField，构建多对多模型。

    models.ManyToManyField会自动创建第三张表。models.ManyToManyField可以建在两个模型类中的任意一个。

    下面以第二种方式举例。

    多对多模型： 一篇文章可以被多个用户关注，一个用户也可以关注多篇文章,二者是多对多的关系
    模型构建：
    定义两张表：User表（用户表），Artile表（文章表）。

    import datetime
from django.db import models
from django.contrib.auth.models import AbstractUser
from django.contrib.auth.hashers import make_password #密码加密

class Artile(models.Model):
    """
        title: 标题
        sub_title: 子标题
        content: 内容
    """
    def __str__(self):
        return self.title
    title = models.CharField(max_length=250,default='',verbose_name='标题')
    sub_title = models.CharField(max_length=250,default='',verbose_name='子标题')
    content = models.CharField(max_length=2000,default='',blank=True,verbose_name='内容')
    # 通过models.DateTimeField与User表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，自动创建第三张表
    users = models.ManyToManyField(to='User', )
    create_time = models.DateTimeField(default=datetime.datetime.now(),verbose_name='创建时间')
    create_name = models.CharField(max_length=20,verbose_name='创建人')
    update_time = models.DateTimeField(default=datetime.datetime.now(),blank=True,verbose_name='更新时间')
    update_name = models.CharField(max_length=20,verbose_name='更新人',blank=True,)
    is_delete = models.IntegerField(default=0,verbose_name='删除状态',blank=True,) # 逻辑删除 0 正常 1:删除

    class Meta:
        verbose_name = "文章"
        verbose_name_plural = verbose_name
        app_label = 'webApi'


class User(AbstractUser):
    """
        name: 昵称
        account: 用户名
        pwd: 密码
        phone:手机号
        email:邮箱
        avator:头像
        group_id:归属组
    """
    def __str__(self):
        return self.account
    name = models.CharField(max_length=20,default='',verbose_name='昵称')
    phone = models.CharField(max_length=20,default='',blank=True,verbose_name='手机号')
    email = models.CharField(max_length=20,default='',blank=True,verbose_name='邮箱')
    avator = models.CharField(max_length=200,default='',blank=True,verbose_name='头像')
    group_id = models.CharField(max_length=50,default='',blank=True,verbose_name='组')
    create_time = models.DateTimeField(default=datetime.datetime.now(),verbose_name='创建时间')
    create_name = models.CharField(max_length=20,verbose_name='创建人')
    update_time = models.DateTimeField(default=datetime.datetime.now(),blank=True,verbose_name='更新时间')
    update_name = models.CharField(max_length=20,verbose_name='更新人',blank=True,)
    is_delete = models.IntegerField(default=0,verbose_name='删除状态',blank=True,) # 逻辑删除 0 正常 1:删除
    # blank=True, 可选字段

    class Meta:
        verbose_name = "用户"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.username
    # 明文密码转加密
    def set_password(self, password):
        print('set_password %s' % (password))
        self.password = make_password(password,'jxy','pbkdf2_sha256')
    # 验证密码是否匹配
    def check_password(self, password):
        print('password: %s' % (password))
        print('check_password: %s' % (make_password(password,'jxy','pbkdf2_sha256')))
        print('self.password: %s' % (self.password))

        return self.password == make_password(password,'jxy','pbkdf2_sha256')

    • 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
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71

    添加记录：
    向这张关系表中添加几条关系。比如，我们将 Artile表主键为1的一条记录，添加User表 主键为1，2两条关系。

    user1 = models.User.object.filter(pk=1).first()
user2 = models.User.object.filter(pk=2).first()

artile1 = models.Artile.object.filter(pk=1).first()
artile1.users.add(user1,user2)

# 方法二
userSet = models.User.object.filter(pk__in=[1,2]).all()
artile1.users.add(*userSet)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    这样便在关系表中创建了 Artile表主键为1的记录与User表主键为1，2的两条关系。
    另外清除关系绑定用法类似，使用remove替代add:

    artile1 = models.Artile.object.filter(pk=1).first()
userSet = models.User.object.filter(pk__in=[1,2]).all()
artile1.users.remove(*userSet) #解绑指定关系
artile1.users.clear() #清空所有关系

    • 1
    • 2
    • 3
    • 4

    多对多查询：

    • 正向查询，例如查询Artile表第一条记录有哪些用户关注:
    artile1 = models.Artile.object.filter(pk=1).first()
print(artile1.users.all().values('username')) # 打印关注Artile表第一条记录的用户名称

    • 1
    • 2
    • 逆向查询，例如查询User表第一条记录关注过哪些Artile:
    user1 = models.User.object.filter(pk=1).first()
print(user1.artile__set.all().values('title')) # 打印User表第一条记录关注的文章名称

    • 1
    • 2

    总结

    在开发中，一般都会采用ORM框架，这样就可以使用对象操作表了。

    • Django中，定义表映射的类，继承自Model类。Model类使用了元编程，改变了元类。
    • 使用Field实例作为类属性来描述字段。
    • 使用ForeignKey来定义外键约束。
  • 相关阅读:
    Zeno‘s paradoxes
    【我的C/C++语言学习进阶之旅】C语言标识符的命名规则和分类
    vue3获取元素并修改元素样式
    SpringCloud系列（一）Eureka 注册中心
    服装行业数字化改革及未来趋势
    面试中常问到的C++11的题目和答案
    计算机网络笔记6应用层
    双11倒计时3天！凯诘、华扬、多准：“三波段脉冲式促收”策略解读
    【视频教程】基于PyTorch机器学习与深度学习实践应用与案例分析
    Java虚拟机运行时数据区结构详解
  • 原文地址：https://blog.csdn.net/luofeng_/article/details/133895120