【Django】数据库（ORM）各种关系表操作方法

最新推荐文章于 2022-09-05 23:29:57 发布
最新推荐文章于 2022-09-05 23:29:57 发布
阅读量439 收藏 1
点赞数 1
分类专栏： Python 文章标签： Django ORM 数据库 表操作

目录

  • 1、一对一（OneToOneField）
  • 2、一对多或多对一（ForeignKey）
  • 3、多对多
  •   3.1 ManyToManyField
  •   3.2 第三张表
  •   3.3 第三张表+ManyToManyField
  • 4、事务
  • 5、MVC和MTV

 

1、一对一(OneToOneField)

class Author(models.Model):
    name = models.CharField(max_length=32)
    authorinfo = models.OneToOneField(to="AuthorInfo")

class AuthorInfo(models.Model):
    addr = models.CharField(max_length=32)
# 查
# 正向查询：.字段名.关联表的字段
# 需求：查看每个作者的地址
authors = models.Author.objects.all()
for author in authors:
    print(author.name, author.authorinfo.addr)

# 反向查询：.关联表名.关联表字段
# 需求：查看住在上海的作者姓名
authors_info = models.AuthorInfo.objects.filter(addr="上海")
for author_info in authors_info:
    print(author_info.author.name)

# 在ORM操作方法内使用跨表查询，主要方法filter，values, values_list等
# 正向查询：字段名__关联表字段
# 需求：直接拿到作者sun的住址
author_addr = models.Author.objects.filter(name="sun").values("authorinfo__addr")
print(author_addr)
# 结果：<QuerySet [{'authorinfo__addr': 'aaaaaa'}]>

# 反向查询：关联表名__字段名
# 需求：查看住在上海的作者姓名
authors_name = models.AuthorInfo.objects.filter(addr="上海").values("author__name")


# 删除
# 由于是关联表，所以删除主表记录，从表相关记录也会删除
models.AuthorInfo.objects.filter(pk=6).delete()  # pk是主键primary key


# 添加（修改也一样）把create换成update
# 先添加主表AuthorInfo，再添加Author
# 第一种方法：
author_info = models.AuthorInfo.objects.create(addr="上海浦东新区")
author = models.Author.objects.create(name="sun", authorinfo=author_info)

# 第二种方法：
author_info = models.AuthorInfo(addr="上海浦东新区")
author_info.save()

author = models.Author(name="sun", authorinfo=author_info)
author.save()

2、一对多或多对一(ForeignKey)

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish = models.ForeignKey(to='Publish')

class Publish(models.Model):
    name = models.CharField(max_length=32)
    email = models.EmailField()
# 查
# 正向查询：.表字段.关联表字段
# 需求：查找每本书的出版社名
books = models.Book.objects.all()
for book in books:
    print(book.name, book.publish.name)

# 反向查询：.关联表名_set
# 查询id为1的出版社出版的书的书名
publish = models.Publish.objects.filter(id=1).first() # publish 是表对象
books = publish.book_set.all() # books是QuerySet对象
for book in books:
    print(book.name)

# 在ORM操作方法内使用跨表查询，主要方法filter，values, values_list等
# 正向查询：.字段名__关联表字段
# 需求：查找每本书的出版社名
books = models.Book.objects.values("publish__name")
print(books)

# 反向查询：关联表名__字段名
# 查询id为1的出版社出版的书的书名
book_name = models.Publish.objects.filter(id=1).values("book__name")
print(book_name)


# 删除
# 由于是关联表，所以删除主表记录，从表相关记录也会删除
models.Publish.objects.filter(pk=4).delete()  # pk是主键primary key


# 添加（修改也一样）把create换成update
# 先添加主表Publish，再添加Book
# 第一种方法：
publish = models.Publish.objects.create(name="xxx出版社", email="123@123.com")
models.Book.objects.create(name="三体", price=35, publish=publish)

# 或
publish = models.Publish.objects.filter(name="xxx出版社").first()
models.Book.objects.create(name="三体", price=35, publish_id=publish.pk)

# 第二种方式：
publish = models.Publish(name="xxx出版社")
publish.save()

book = models.Book(name="三体",price=35, publish=publish)
book.save()

3、多对多

　　3.1 ManyToManyField

class Book(models.Model):
    name = models.CharField(max_length=32)
    authors = models.ManyToManyField(to='Author')

class Author(models.Model):
    name = models.CharField(max_length=32)
# 创建表时，会自动创建第三张表"app01_book_authors"，
# 跨表查询时，就相当于隐藏了第三张表，直接到跨到另外张表，然后查询

# 查
# 正向查询：.表字段(得到QUerySet对象)
# 查看id为1的书籍都有哪些作者
book = models.Book.objects.filter(pk=1).first()
print(book.authors.all())
结果：<QuerySet [<Author: Author object>, <Author: Author object>]>

# 反向查询：.关联表名_set
# 查看id=1的作者写了哪些书
author = models.Author.objects.filter(pk=1).first()
print(author.book_set.all())
# 结果：<QuerySet [<Book: Book object>, <Book: Book object>]>

# 在ORM操作方法内使用跨表查询，主要方法filter，values, values_list等
# 正向查询：.字段名__关联表字段
# 查看id为1的书籍都有哪些作者
authors = models.Book.objects.filter(pk=1).values("authors__name")
print(authors)
# 结果：<QuerySet [{'authors__name': 'sss'}, {'authors__name': 'aaa'}]>

# 反向查询：关联表名__字段名
# 查看id=4的作者写了哪些书
books = models.Author.objects.filter(pk=1).values("book__name")
print(books)
#结果：<QuerySet [{'book__name': '三体'}, {'book__name': '白夜行'}]>
# 对ManyToManyField字段的增删改的方法
# 表内的其他字段按照正常的方法操作

# 添加 add
# 特点：
#     1. 无返回值
#     2. 如果数据存在，则不插入

# 正向插入：表对象.字段名.add()
# 可以直接添加关联表的id，(如果添加一个不存在的id，也能添加上去)
# add(2)、add(2,4)、add(*[2,4])
book = models.Book.objects.filter(id=1).first()
book.authors.add(2)

# 也可以添加对象，(必须插入关联表内已有的数据记录对应的对象)
# add(obj)、add(obj1, obj2)、add(*[obj1, obj2])
book = models.Book.objects.filter(id=1).first()
authors = models.Author.objects.filter(id__in=[2,3,4])
book.authors.add(*authors)


# 反向插入：表对象.关联表名_set.add()
author = models.Author.objects.filter(id=1).first()
author.book_set.add(2)

author = models.Author.objects.filter(id=1).first()
books = models.Book.objects.filter(id__in=[3,4])
author.book_set.add(*books)

# 删除 remove (用法同add)
# 正向删除：表对象.字段名.remove()
# 反向删除：表对象.关联表名_set.remove()

# 清空 clear
# 正向清空：表对象.字段名.clear()
# 反向清空：表对象.关联表名_set.clear()
book = models.Book.objects.filter(id=1).first()
book.authors.clear()

# 修改 set
# 说明：1. 必须传入可迭代对象，列表，元组
# 正向修改：表对象.字段名.set()
book = models.Book.objects.filter(id=1).first()
author = models.Author.objects.filter(id=1).first()
book.authors.set([author])

# 反向修改：表对象.关联表名_set.set()
book = models.Book.objects.filter(id=2).first()
author = models.Author.objects.filter(id=3).first()
author.book_set.set([book])

 

　　3.2 第三张表

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

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

class Book2Author(models.Model):
    """书籍和作者多对多关系表"""
    book = models.ForeignKey(to="Book")
    author = models.ForeignKey(to="Author")

# 表的增删改查和一对多的操作一样，这里的主表是Book2Author, 从表是Book和Author
# 但跨表查询方法有很多：
# 示例
# 需求：找到《三个》书本都有哪些作者
# 第一种方式：先找书籍，反向查询到第三章表book2author, 在正向查询作者名
book = models.Book.objects.filter(name="三个").first()
b_as = book.book2author_set.all()
for b_a in b_as:
    print(b_a.author.name)


# 第二种方式：操作第三张表筛选书本条件，然后正向查到作者姓名
book = models.Book.objects.filter(name="三个").first()
b_as = models.Book2Author.objects.filter(book=book).all()
for b_a in b_as:
    print(b_a.author.name)

# 或者：（使用神奇的双下划线）
b_as = models.Book2Author.objects.filter(book__name="三个").all()
for b_a in b_as:
    print(b_a.author.name)

# 第三种方式：直接在作者表查询，通过下划线跨两次表查询
authors = models.Author.objects.filter(book2author__book__name="三个").values("name")
# 说明：
#     book2author__：跨到第三张表
#     book2author__book__：通过第三张表的book字段跨到book表

 

　　3.3 第三张表+ManyToManyField

class Book(models.Model):
    name = models.CharField(max_length=32
    authors = models.ManyToManyField(to='Author', through="Book2Author", through_fields=("book", "author"))

class Book2Author(models.Model):
    """书籍和作者多对多关系表"""
    book = models.ForeignKey(to="Book")
    author = models.ForeignKey(to="Author")

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

# 说明：
#     1. 查询时可隐藏第三章表，如：Book.objects.first().authors.all()
#     2. 可以使用clear清空，但不能使用set，和remove，add
#     3. 添加，修改，删除使用一对多的方法操作

4、事务

from django.db import transaction
with transaction.atomic():
    # ORM 操作
    pass

 

5、MVC和MTV

 　　MTV(django):

　　　　M: models

　　　　T: templates

　　　　V: views

　　MVC:

　　　　M: models

　　　　V: views

　　　　C: controller (urls+views)

程序哲学
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Django：模型_ORM表关系
不怕猫的耗子z
04-11 413
表关系 1、关系型数据库的表与表之间往往存在一定的关系，由于Django的模型是数据库表与Python类之间的映射，因此Django提供了3种最常用的数据库表之间关系的支持：一对多、一对一、多对多 2、表之间的关系都是通过外键来进行关联的：所以我感觉这里的表关系其实就是对我们前面学习的外键进行的补充(在外键的基础上在进行细分) 一对多 1、一对多关系：是一张数据库表中的一条记录...
python中ORM对应关系查询
yinlingjishu的博客
10-28 355
models.py 在models中模型建立 对应建立表关系（单表） from django.db import models Create your models here. class User(models.Model): name = models.CharField(max_length=32) age = models.IntegerField() register_time = models.DateField() # 年月日 ''' datefie
django ORM中的表关系
weixin_30421525的博客
07-07 95
多对一： 　　为了方便理解，两个表之间使用ForeignKey连接时，使用ForeignKey的字段所在的表为从表，被ForeignKey连接的表为主表。 　　使用场景：书和出版社之间的关系，一本书只能由一个出版社出版，一个出版社却可以出版很多书 　　实现方式：一对多或者说多对一，在Django中是使用ForeignKey实现的，下面是例子： 　　class Publisher(mo...
django 之数据表的关系
weixin_43890188的博客
07-04 210
一对多 # 就是说第一个表一行数据可能与第二个表中的多行数据相关联，但是第二个表中每行数据之能与第一个表中的某一行数据相关联。 # 比如说有两个表：学校表和学生表 class School（models.Model）: name = models.CharField(max_length=20) class Student (mdoels.Model): name = models.CharF...
ORM的对应关系
weixin_30314631的博客
10-30 254
一、 ORM 一对一 1. 什么时候用一对一？ 当 一张表的某一些字段查询的比较频繁，另外一些字段查询的不是特别频繁 把不怎么常用的字段 单独拿出来做成一张表 然后用过一对一关联起来 2. 优势 既保证数据都完整的保存下来，又能保证大部分的检索更快 3. ORM中的用法 OneToOneField(to="") 二、 ORM 多对多的三种方式 多对多的方式： 1...
django --  ORM应用及表关系
Eric 的博客
09-18 275
* 模型常用的字段 * 表的关系 * ORM 应用 ## 复习 ``` ``` ## orm 增删该查 扩展 ``` book = Book.objects.filter(name="三国演义",desc='name').first() books = Book.objects.order_by("-price") #从高到低进行排序 for bo...
Django基于ORM操作数据库的方法详解
09-20
主要介绍了Django基于ORM操作数据库的方法,结合实例形式总结分析了Django使用ORM操作数据库的相关配置、增删改查等相关操作技巧,需要的朋友可以参考下
Django框架ORM数据库操作实例详解
09-18
本篇将详细讲解Django ORM数据库操作的基本概念、实例及常用方法。 一、增加数据 1. `save` 方法：创建一个新的对象并保存到数据库中。首先实例化一个模型类的对象，设置其属性，然后调用 `save()` 方法。例如： `...
Django视图之ORM数据库查询操作API的实例
12-25
查询表记录 查询相关API 操作：models.表名.objects.方法() <BR>all(): 查询所有结果 filter(**kwargs): 它包含了与所给筛选条件相匹配的对象 get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有...
ORM表关系及操作
weixin_58074980的博客
04-28 355
多对一关系 在设置外键时，需要通过on_delete选项指明主表删除数据时，对于外键引用表数据如何处理，在django.db.models中包含了可选常量： CASCADE级联，删除主表数据时连通一起删除外键表中数据 PROTECT保护，通过抛出ProtectedError异常，来阻止删除主表中被外键应用的数据 SET_NULL设置为NULL，仅在该字段null=True允许为null时可用 SET_DEFAULT设置为默认值，仅在该字段设置了默认值时可用 代码： 准备人物列表信息的模型类 class
ORM(关系型数据库与对象映射项目)
08-20
在关系型数据库和对象之间作一个映射，将内存中的数据存储在关系型的数据库中，实现了数据处理层内部的业务逻辑和数据逻辑分离的解耦合。
django之ORM数据库操作
dichengpai8268的博客
10-25 98
一、ORM介绍 映射关系： 　　表名 --------------------》类名 　　字段--------------------》属性 　　表记录-----------------》类实例化对象 ORM的两大功能： 　　操作表： 　　　　- 创建表 　　　　- 修改表 　　　　- 删除表 　　操作数据行： 　　　　- 增删改查 ORM利用pymysql第三方...
深入Django ORM的继承关系
weixin_34025051的博客
03-18 130
ORM中通常将对象引用映射到外键，但是对于继承，关系数据库中没有自然有效的方法来对应。从数据存储的角度来看，在映射继承关系时，可以采用几种方式（参考JPA中的InheritanceType.定义）： 使用单个表，在JPA中称作SINGLE_TABLE。整个继承树共用一张表。使用唯一的表，包含所有基类和子类的字段。 每个具体类一张表，在JPA中称作TABLE_PER_CLASS。这种方式下，...
Django ORM 关系管理对象的创建
z某某的博客
11-05 131
第一种方法自动创建第三张表 from django.db import models class Book(models.Model): title = models.CharField(max_length=32) pub = models.ForeignKey('Publisher', on_delete=models.CASCADE) class Author(mo...
Django---静态文件配置,post提交表单的csrf问题(日后细说),创建app子项目和分析其目录,ORM对象关系映射简介,Django操作orm(重点)...
dayinji1212的博客
08-22 155
Django---静态文件配置,post提交表单的csrf问题(日后细说),创建app子项目和分析其目录,ORM对象关系映射简介,Django操作orm(重点) 一丶Django的静态文件配置 #web服务器映射静态资源文件. static静态资源的别名 STATIC_URL = '/static/' # 别名 # 配置静态资源文件路径. STATICFILES_DIRS 名...
47_Django数据库_创建和映射ORM模型
老芦VIP
02-14 197
在PyCharm中创建一个Project，名为“project477”。 在Navicat里面新建一个数据库，名为“db477”，字符集设置为“utf8 – UTF-8 Unicode”。 配置数据库的连接 打开“settings.py”文件，DATABASES信息修改如下： DATABASES = { 'default': { 'ENGINE': 'django.db...
Django笔记01：什么是对象关系映射（ORM）？
向东的笔记本
01-22 622
Django是一种无需数据库就能使用的高效Web开发框架，因为它使用了对象关系映射器，通过此技术,你可以使用强大的 数据-模型语句 来描述你的数据模型，这解决了数年以来在数据库模式中的难题。那什么是对象关系映射呢？它有什么作用呢？ 一：概念 对象关系映射器（Object Realtion Mapping）是一种代码库，它能自动将存储在关系型数据库表中的数据转化成在应用程序代码中更加常用的对象。...
Django：ORM中ForeignKey外键关系分析
weixin_30699831的博客
07-25 272
假设有两张表，Role和User，因为多个用户会对应一个角色，属于多对一关系，所以User中的rolename字段使用ForeignKey，第一个参数为要关联的表Role,第二个参数related_name是用来反查这个角色下有几个用户时用的。 class Role(models.Model): ''' 角色表 ''' role_nam...
ORM多表外键字段的操作
Yietong的博客
09-05 414
一对一关系., 一对多关系的操作都是一样的, >>> 找到外键字段所在的表, 然后根据该表进行操作多对多关系的表操作. 需要先找到外键字段所在的表, 然后再确定另一张表中需要操作的字段, 最后再根据外键字段所在的表进行操作, 并且操作所使用的方法是不同的。
Django自带的ORM进行数据库操作
最新发布
03-29
Django自带的ORM是一个Python对象关系映射工具，它可以让开发者使用Python语言进行数据库操作，而不需要手写SQL语句。 使用Django自带的ORM进行数据库操作的步骤如下： 1. 定义模型类：在Django应用的models.py...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值