django---模型

最新推荐文章于 2024-07-16 23:13:39 发布
最新推荐文章于 2024-07-16 23:13:39 发布
阅读量165 收藏
点赞数
分类专栏： Django
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33722246/article/details/86629563
版权
本文详细介绍了Django中的模型配置、ORM（对象关系映射）基本概念、模型属性、定义与激活模型、如何使用模型进行增删改查操作、模型成员的重命名与自定义管理器，以及模型间的一对一、一对多和多对多关系。通过ORM，开发者可以方便地操作数据库，提高开发效率，但也存在一些缺点。文章提供了实例代码和查询示例，帮助理解Django模型的使用。
摘要由CSDN通过智能技术生成

 

模型使用步骤：

  1. 配置数据库

  2. models.py定义模型类

  3. 激活模型

  4. 使用模型

Django默认使用的是sqlite，但在生产环境中一般会用mysql、postgrsql、oracle等关系型数据库。

1.数据库配置

在项目的 settings.py 文件中找到 DATABASES 配置项，将其信息修改为：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  #mysql数据库引擎
        'NAME': 'test',                        #数据库名
        'HOST':'localhost',                    #数据库服务器地址
        'USER': 'test',                        #mysql数据库用户名
        'PASSWORD': 'test123',                 #密码
        'PORT':3306,                         #端口号，可选
    }
}

在虚拟开发环境中，安装mysql的数据库驱动pymysql

(django) python@ubuntu:~/project/hello$ pip install pymysql

Django默认使用MySQLdb模块链接MySQL，但python3中还无此模块，所以需要使用pymysql来代替，在项目的__init__.py中写入：

import pymysql
pymysql.install_as_MySQLdb()

 

2.ORM

对象关系映射（Oject Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，自动生成sql语句，将程序中的对象自动保存到关系数据库中。优点：

  • 隐藏了数据库访问的细节，简化了sql的使用，提高了开发效率

  • 解耦业务逻辑层（view）和数据处理层（model)，简化了开发流程，提高了系统的可移植性

  • 提高了安全性

缺点：

  • 执行效率低

  • 对复杂sql无能为力

  • 增加了学习成本

2.1 基本概念

面向对象概念面向关系概念
类表
对象记录（一行）
属性字段（属性、列）

  • 一个模型类对应一个表

  • 每个模型类都必须继承django.db.models.Model

2.2 模型属性

模型中的属性和数据库表的字段对应，必须定义。模型的属性需要定义成类属性

#属性定义语法为：
属性 = models.字段类型(选项)

  • 属性命名规则：

    • 不能是python的保留关键字

    • 不允许使用连续的下划线，因为连续下划线在查询中会用到

    • 定义属性时需要指定字段类型

    • 主键一般不用自己定义，django会自动创建自增长主键列，如果你自己定义了主键，则django不会再自动生成主键

2.2.1字段类型

字段名称字段说明参数
AutoField一个根据实际Id自动增长的 IntegerField（通常不指定 自动生成） 
CharField字符串，默认的表单样式是 TextInputmax_length=字符长度
TextField大文本字段，一般超过4000使用，默认的表单控件是Textarea 
IntegerField整数 
DecimalField使用python的Decimal实例表示的十进制浮点数max_digits总位数；decimal_places小数位数
FloatField用Python的float实例来表示的浮点数 
BooleanFieldtrue/false 字段，此字段的默认表单控制是CheckboxInput 
NullBooleanField支持null、true、false三种值 
DateField使用Python的datetime.date实例表示的日期，该字段默认对应的表单控件是一个TextInputauto_now和auto_now_add、default这三个参数不能同时共存
TimeField使用Python的datetime.time实例表示的时间参数同DateField
DateTimeField使用Python的datetime.datetime实例表示的日期和时间参数同DateField
ImageField继承了FileField的所有属性和方法，但对上传的对象进行校验，确保它是个有效的image 

  • auto_now: 每次保存对象时，自动设置该字段为当前时间，用于"最后一次修改"的时间戳，它总是使用当前日期，默认为false

  • auto_now_add: 当对象第一次被创建时自动设置当前时间，用于创建的时间戳，它总是使用当前日期，默认为false

2.2.2 字段选项

适用于任何字段，可以实现字段的约束，在生成字段时通过方法的关键字参数指定。

可选参数说明
null如果True，Django将NULL在数据库中存储空值。默认是False。不要在字符串字段上使用。null是数据库范畴的概念
blank如果True，该字段允许为空。默认是False。同null不同， 如果字段有blank=True，则表单验证将允许输入空值。如果字段有blank=False，则需要该字段。
db_column用于此字段的数据库列的名称。如果没有给出，Django将使用该字段的名称。
db_index如果True，将为此字段创建数据库常规索引。
unique如果True，该字段在整个表格中必须是唯一的。
primary_key如果True，此字段是模型的主键。
default默认值 当前字段如果不给值则执行默认值

3.定义模型

我们可以在应用的models.py中定义模型：

from django.db import models
​
class 模型名(models.Model):
    属性名 = models.字段名(字段选项/参数)
    .....
    class Meta:   #可选，任何非字段的设置可以写到Meta中
        db_table = 'user'   #指定表名为uesr

  • 数据库的表名等于：应用名_模型名，如果想指定表名，可以在Meta中使用db_table指定

  • 如果没有指定主键，Django将自动给表创建一个自增长主键id

    id = models.AutoField(primary_key=True)

下面我们定义几个模型类

from django.db import models
from django.utils import timezone
​
#用户类
class User(models.Model):
    uid = models.AutoField(primary_key=True)  #自增主键
    uname = models.CharField(max_length=60)
    password = models.CharField(max_length=32)
    user_type = ((1,'超级管理员'),(2,'普通用户'))  #用户自定义类型对应mysql的enum类型
    type = models.IntegerField(default=2,choices=user_type)
    regtime = models.DateTimeField(default=timezone.now)  #缺省值是当前时间
    ip = models.IntegerField(null=True)
    login_type = ((1,'允许登录'),(2,'禁止登录'))   #用户自定义类型对应mysql的enum类型
    allowed = models.IntegerField(default=1,choices=login_type)
    email = models.CharField(max_length=100,null=True)
    memo = models.CharField(max_length=1000,null=True)
​
    class Meta:
        db_table = 'user'   #表名

 

4.激活模型

  • 创建迁移文件 （此刻表并没有创建到库中）

    $ python3 manage.py makemigrations

  • 执行迁移 （将模型创建到库中）

    $ python3 manage.py migrate

然后在应用的migrations目录中应该生成了迁移文件

├── app
│   ├── admin.py
│   ├── apps.py
│   ├── __init__.py
│   ├── migrations
│   │   ├── 0001_initial.py
│   │   ├── __init__.py

生成的表结构如下：

CREATE TABLE `user` (
  `uid` int(11) NOT NULL AUTO_INCREMENT,
  `uname` varchar(60) NOT NULL,
  `password` char(32) NOT NULL,
  `type` enum('超级管理员','普通用户') DEFAULT '普通用户',
  `regtime` datetime DEFAULT NULL,
  `ip` int(11) DEFAULT NULL,
  `allowed` enum('允许登录','禁止登录') DEFAULT '允许登录',
  `email` varchar(100) DEFAULT NULL,
  `memo` varchar(1000) DEFAULT NULL,
  PRIMARY KEY (`uid`)
)

注意：

  • 任何对字段或表的修改都需要重新迁移

5.模型的使用

我们可以再交互式Python shel环境中，使用Django提供的免费API。要调用Python shell，请使用以下命令：

$ python manage.py shell
Python 3.6.4 (default, Sep 13 2018, 02:27:17) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>>

5.1 增删改

>>> from app.models.User import User   #导入User模型
>>> from  hashlib import md5
>>> user = User(uname='admin',password=md5(b'123').hexdigest())  #实例化一个新对象
>>> user.save()   #insert 插入数据库
>>> user.uid      #显示uid的值
 4
#在mysql中查询新插入的记录
mysql> select uid,uname,password,type,allowed from user;
+-----+--------------+----------------------------------+--------------+--------------+
| uid | uname        | password                         | type         | allowed      |
+-----+--------------+----------------------------------+--------------+--------------+
|   1 | dddddksdf    | bc9858af5f37d3cf147a3923c8b9a3d9 | 普通用户     | 允许登录     |
|   2 | tom123       | 59f2443a4317918ce29ad28a14e1bdb7 | 普通用户     | 允许登录     |
|   3 | 隔壁老王     | 1e9ce4a8f8c6b2baa00b1783de4b0ef0 | 普通用户     | 允许登录     |
|   4 | admin        | 202cb962ac59075b964b07152d234b70 | 普通用户     | 允许登录     |
+-----+--------------+----------------------------------+--------------+--------------+
4 rows in set (0.00 sec)
​
>>> u1 = User.objects.get(pk=1)  #获取uid=1的记录
>>> u1.uid
1
>>> u1.delete()       #删除该记录
(1, {'app.Comment': 0, 'app.User': 1})
​
#查询mysql
mysql> select uid,uname,password,type,allowed from user;
+-----+--------------+----------------------------------+--------------+--------------+
| uid | uname        | password                         | type         | allowed      |
+-----+--------------+----------------------------------+--------------+--------------+
|   2 | tom123       | 59f2443a4317918ce29ad28a14e1bdb7 | 普通用户     | 允许登录     |
|   3 | 隔壁老王      | 1e9ce4a8f8c6b2baa00b1783de4b0ef0 | 普通用户     | 允许登录     |
|   4 | admin        | 202cb962ac59075b964b07152d234b70 | 普通用户     | 允许登录     |
+-----+--------------+----------------------------------+--------------+--------------+
3 rows in set (0.00 sec)
​
# 修改单条记录
>>> u2 = User.objects.get(pk=2)
>>> u2.uname = '小甜甜'     #update  更新
>>> u2.save()
​
# 修改多条记录
>>> users = User.objects.all()
>>> users.update(password=md5(b'345').hexdigest())
​
#查询mysql
mysql> select uid,uname,password,type,allowed from user;
+-----+--------------+----------------------------------+--------------+--------------+
| uid | uname        | password                         | type         | allowed      |
+-----+--------------+----------------------------------+--------------+--------------+
|   2 | 小甜甜       | 59f2443a4317918ce29ad28a14e1bdb7 | 普通用户     | 允许登录     |
|   3 | 隔壁老王     | 1e9ce4a8f8c6b2baa00b1783de4b0ef0 | 普通用户     | 允许登录     |
|   4 | admin        | 202cb962ac59075b964b07152d234b70 | 普通用户     | 允许登录     |
+-----+--------------+----------------------------------+--------------+--------------+
3 rows in set (0.00 sec)

  • 数据的逻辑删除

    对于重要数据，一般不会直接删除，会在表中增加一个字段比如：is_deleted，如果删除的话，将这个字段置为True，以后查询的时候不在查询，这种操作称为逻辑删除

5.2 数据查询

要从数据库检索数据，首先要获取一个查询集(QuerySet)，查询集表示从数据库获取的对象集合，它可以有零个，一个或多个过滤器。返回查询集的方法，称为过滤器，过滤器根据给定的参数缩小查询结果范围，相当于sql语句中where或limit。

  • 在管理器上调用过滤器方法会返回查询集

  • 查询集经过过滤器筛选后返回新的查询集，因此可以写成链式过滤

  • 惰性执行：创建查询集不会带来任何数据库的访问，直到调用数据时，才会访问数据库

  • 以下对查询集求值：迭代、切片、序列化、与if合用、repr()/print()/len()/list()/bool()

管理器的方法返回类型说明
模型类.objects.all()QuerySet返回表中所有数据
模型类.objects.filter()QuerySet返回符合条件的数据
模型类.objects.exclude()QuerySet返回不符合条件的数据
模型类.objects.order_by()QuerySet对查询结果集进行排序
模型类.objects.values()QuerySet返回一个列表 每个元素为一个字典
模型类.objects.reverse()QuerySet对排序的结果反转
模型类.objects.get()模型对象返回一个满足条件的对象； 如果没有找到符合条件的对象，会引发模型类.DoesNotExist异常; 如果找到多个，会引发模型类.MultiObjectsReturned 异常
模型类.objects.count()int返回查询集中对象的数目
模型类.objects.first()模型对象返回第一条数据
模型类.objects.last()模型对象返回最后一条数据
模型类.objects.exists()bool判断查询的数据是否存在

5.2.1 返回查询集

  • all()

    # 获取所有数据，对应SQL：select * from User
User.objects.all()

  • filter(**kwargs) 返回QuerySet包含与给定查找参数匹配的新查询集。

    #等价sql：select * from User
User.objects.filter()
​
#等价sql：select * from User where uname = 'admin'
User.objects.filter(uname='admin')
​
#等级sql：select * from User where uid > 1 and type = 2
User.objects.filter(uid__gt=1,type=2)
​
#链式调用，等价于User.objects.filter(uid__gt=1,type=2)
User.objects.filter(uid__gt=1).filter(type=2)

  • exclude(**kwargs)

    # 不匹配，对应SQL：select * from User where name != 'admin'
User.objects.exclude(name='admin')

  • order_by(*fields)

    • 参数是字段名，可以有多个字段名，默认是升序。

    • 如果要按某个字段降序，在字段名前加'-'： "-uid"表示按uid降序排列

  #按uid升序排列  等价于 order by uid
  User.objects().order_by('uid')
​
  #按uid降序排列  等价于 order by uid desc
  User.objects.order_by('-uid')
​
  #多列排序 等价于 order by password,uid desc
  User.objects.order_by('password','-uid')

  • values()

    #返回所有字段
User.objects.values()
#返回数据：
[{'uid': 2, 'uname': '小甜甜', 'password': '59f2443a4317918ce29ad28a14e1bdb7'type': '普通用户', 'regtime': None, 'ip': None, 'allowed': '允许登录', 'email': None, None},...]
 
#返回指定字段
User.objects.values('uname','password')
[{'uname': '小甜甜', 'password': '59f2443a4317918ce29ad28a14e1bdb7'},...]

  • reverse()

    User.objects.order_by('id').reverse()  降序
User.objects.order_by('-id').reverse()  升序

  • distinct() 去重

    User.objects.values('password').distinct()

    ​

5.2.2 返回单个值

下面这些方法后面不能再跟其他过滤方法，因为他们不返回查询集

  • get() 只匹配一条数据

    u = User.objects.get(pk=1)  #正常
u = User.objects.get(uid__gt=20) #MultipleObjectsReturned 匹配到了多条数据
u = User.objects.get(uid__lt=-1) #DoesNotExist 匹配失败

  • first()和last()

    User.objects.all().first()  #返回结果集中第一条数据
User.objects.all().last()   #返回结果集中最后一条数据

  • count()

    • 返回结果集记录数目，等价于select count(*)

    • 不会返回整个结果集，相比len方法更有效

    User.objects.count()

  • exists()

    • 判断查询集中是否有记录，有返回True，否则返回False

      User.objects.filter(uid=3).exists()

5.2.3查询集限制

查询集类似列表，可以使用下标进行限制，类似sql语句中的limit子句。但索引不能是负数

  • 索引

  • 切片

User.objects.all()[0]  #等同于：limit 0,1
User.objects.all()[2]  #等同于：limit 2,1
User.objects.all()[0:2] #等同于limit 2
User.objects.all()[:2] #等同于limit 2
User.objects.all()[::2]

5.2.4 字段查询

相当于sql语句中where子句，它可以为filter、exclude和get方法提供参数。

属性名称__比较运算符=值   #是两个下划线

 

操作符说明示例
exact/=精确判等uname = 'admin' uname__exact = 'admin' uname__exact = None #uname is null
iexact不区分大小写判等name__iexact = 'admin'
contains模糊查询，等价like '%值%'uname__contains = 'admin'
contains不区分大小写的模糊查询uname__icontains = 'Admin'
startswith以..开头uname__startswith = 'a'
istartswith（不区分大小写)以...开头uname__istartswith = 'a'
endswith以...结尾uname__endswith = 'm'
iendswith（不区分大小写)以...结尾uname__iendswith = 'm'
isnull判空(等价 = None)uname__isnull = True #等价 uname is null unam__isnull = False #等价 uname is not null
in包含uid__in = [1,2,3] #in后面必须是可迭代对象
range范围测试（相当between and)uid__range = [2,5] #uid >=2 and cid <=5
gt/gte大于/大于等于uid__gt = 2
lt/lte小于/小于等于uid__lte = 2
regex正则匹配uname__regex= r'^a'
iregex不区分大小写的正则匹配uname__iregex= r'^a'

  • in后面可以跟一个子查询，但要求子查询只能返回一个字段

    User.objects.filter(uid__in = (2,3,4))
User.objects.filter(uid__in = [2,3,4])
res = User.objects.filter(uid__gt = 1).values('uid')  #查询集中只有一个字段uid
User.objects.filter(uid__in = res

  • 日期查询

    • year、month、day、week_day、hour、minute、second

     #等价sql: select * from User where year(regtime) = 2018
 User.objects.filter(regtime__year = 2018)

5.2.5 统计查询

需要先导入模块：

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

  • 聚合查询：对多行查询结果的一列进行操作

#统计记录总数： select count(*) from user
User.objects.aggregate(Count('uid'))    #{'uid__count': 4}
User.objects.aggregate(Max('uid'))      #{'uid__max': 5}
User.objects.aggregate(Min('uid'))      #{'uid__min': 2}

  • 分组统计

#等价sql: select type,count(*) from user group by type
res = User.objects.values('type').annotate(Count('uid'))
#统计结果： [{'type': '普通用户', 'uid__count': 3}, {'type': '超级管理员', 'uid__count': 1}]

#查看生成的sql语句
print(res.query)
#SELECT `user`.`type`, COUNT(`user`.`uid`) AS `uid__count` FROM `user` GROUP BY `user`.`type` ORDER BY NULL

 

5.2.6 Q对象和F对象

需要先导入模块：

from django.db.models import Q,F

  • Q对象可以对关键字参数进行封装，从而更好的应用多个查询，可以组合&(and)、|(or)、~(not)操作符。

#原生sql:select * from user where uid = 2 or uid = 3
User.objects.filter(Q(uid=2)|Q(uid=3))
User.objects.filter(Q(uid__gte=2) & Q(uid__lte=3))
User.objects.filter(~Q(uid__gte=2))

  • F对象：用于比较表中两个字段

#等价sql：select * from user where uid < type
User.objects.filter(uid__lte = F('type'))

 

6.模型成员

模型类和数据库中表对应，模型类的对象和记录对象，模型类本身没有数据库访问功能，但模型类中有一个Manager类的对象，通过管理器对象可以实现和数据库的访问。

当我们没有为模型类定义管理器时，Django会为模型类生成一个名为objects的管理器，自定义管理器后，Django不再生成默认管理器objects。

管理器是Django的模型进行数据库操作的接口，Django应用的每个模型都拥有至少一个管理器。Django支持自定义管理器类，继承自models.Manager。

自定义管理器类主要用于两种情况：

  • 修改原始查询集

  • 向管理器类中添加额外的方法，如向数据库中插入数据。

6.1 重命名管理器

在模型类中自定义一个新的管理器，则原有的objects管理器不会存在，以后对数据库的操作使用自己定义的管理器

#模型类
class Artical(models.Model):
    aid = models.AutoField(primary_key=True)
    title = models.CharField(max_length=100,null=False)
    content = models.TextField(max_length=10000,null=True)
    ....
    art_manager = models.Manager()  #自定义了一个新的管理器，名字为art_manager
    
#views
def article_get(request):
    articles = Artical.art_manager.all()   #使用art_manager进行查询
    return render(request,"articlelist.html",context={'articls':articles})

6.2 自定义管理器

  • 修改原始查询集（由all()获取的查询集）

    • 修改管理器的get_queryset方法，可以改变all方法返回的原始查询集

    #首先自定义Manager的子类
class ArticleManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(ispublished=True)  #获取已发表的文章
#模型类
class Artical(models.Model):
   ....
    objects = models.Manager()  #可以有多个管理器
    publishManager = ArticleManager()
    
#views
def article_publish(request):
    published = Artical.publishManager.all()
    return HttpResponse("已经发表{}".format(published[0].title))

 

 

1.模型对应关系

关系数据库最强大的地方在于“关系”，也即表和表之间是有关联的，这种关联有三种类型：

  • 一对一

  • 一对多

  • 多对多

1.1 一对一

一个学生有一个档案，一个档案属于一个学生，那么学生表和档案表就是一对一关系。学生表是主表，档案表是从表，从表中有一个外键和学生表关联，并且要求外键取值唯一。对应关键字为：OneToOneField

#创建模型
class Student(models.Model):
    sno = models.CharField(max_length=6,primary_key=True)
    sname = models.CharField(max_length=100,null=False)
    ssex = models.CharField(max_length=2,default='男',null=True)
    sage = models.IntegerField(null=True)
    sclass = models.CharField(max_length=10,null=True)
​
    def __str__(self):
        return "no:{},name:{}".format(self.sno,self.sname)
​
    class Meta:
        db_table = 'student'
​
class Archives(models.Model):
    idcard = models.CharField(max_length=18, unique=True)
    address = models.CharField(max_length=200,null=True)
    # on_delete=models.CASCADE 级联删除，删除学生会连同档案一块删除
    student = models.OneToOneField(Student, on_delete=models.CASCADE)
​
    def __str__(self):
        return "{},{}".format(self.idcard,self.address)
​
    class Meta:
        db_table = 'archives'

  • 增加数据

def addstudent(request):
    student = Student()
    student.sno = '180502'
    student.sname = '杨康'
    student.sage = 22
    student.save()
    return HttpResponse("增加了一个学生")
​
def addarchives(request):
    stu = Student.objects.get(pk='180503')
    arc = Archives()
    arc.idcard = '130098384893838953'
    arc.student = stu   #学生对象必须已经保存到数据库，否认错误
    arc.save()
    return HttpResponse("增加档案")

  • 删除数据

def deletestudent(request):
    student = Student.objects.get(pk='180503')
    student.delete()
    return HttpResponse("删除学生")

  • 正向查询

def findstudent(request):
    # 获取学生信息
    student = Student.objects.first()
    print(student)
    # 通过学生对象获取档案信息
    archive = student.archives
    print(archive)
    return  HttpResponse(student)

  • 反向查询

def findarchives(request):
    #获取档案记录
    archive = Archives.objects.first()
    #通过档案获取关联学生信息
    student = archive.student
    return HttpResponse(student)

  • 跨关系查询

def lookup(request):
    #根据档案查学生
    # student = Student.objects.get(archives__pk=1)
    student = Student.objects.get(archives__idcard='13009488384383838')
    #根据学生查档案
    archive = Archives.objects.get(student__sno='180501')
    return HttpResponse(archive)

  • on_delete

    • CASECADE 默认，默认级联删除数据

    • PROTECT 保护模式，当从表中存在级联记录的时候，删除主表记录会抛出保护异常，从表中不存在级联数据的时候，是允许删除的

    • SET_XXX

      • NULL 字段本身允许为空

      • DEFAULT 字段本身有默认值

    • DO_NOTHING 什么都不做

1.2 一对多

一个出版社可以出版多本书，一本书只能被一个出版社出版。出版社和图书表属于一对多，一对多一般将主表中的主键并到从表中做外键。在模型中用ForeignKey表示多对一

class Publisher(models.Model):
    pname = models.CharField(max_length=100,null=True)
​
    def __str__(self):
        return self.pname
​
    class Meta:
        db_table = 'publisher'
​
class Book(models.Model):
    bname = models.CharField(max_length=200,null=True)
    #多对一模型通过ForeignKey表示多对一
    #如果publisher定义在book之后，第一个参数应该用字符串'Publisher'
    publisher = models.ForeignKey(Publisher,on_delete=models.CASCADE,null=True)
​
    def __str__(self):
        return self.bname
    class Meta:
        db_table = 'book'

  • 正向查询

def findpublisher(req):
    pub = Publisher.objects.first()
    print(pub)
    # pub = Publisher()
    book = pub.book_set.all()
    print(book)
    return HttpResponse("查询出版社")

  • 反向查询

def findbook(req):
    book = Book.objects.first()
    return HttpResponse(book.publisher.pname)

  • 跨关系查询

def loopup(req):
    # 根据图书获取出版社
    pub = Publisher.objects.get(book__bname='花样年华927937')
    print(pub)
​
    # 根据出版社获取图书
    books = Book.objects.filter(publisher__pname='科技出版社5829')
    print(books)
    return HttpResponse("跨关系查询")

1.3 多对多

一个买家可以购买多件商品，一件商品可以被多个买家购买，买家和商品之间构成多对多关系，多对多关系必然会生成一张中间表：买家-商品表，记录商品和买家的关系，该表包含商品表主键和买家表的主键

from django.db import models
​
# Create your models here.
class Buyer(models.Model):
    bname = models.CharField(max_length=30)
    level = models.IntegerField(default=1)
​
class Goods(models.Model):
    gname = models.CharField(max_length=100)
    price = models.FloatField()
    buyer = models.ManyToManyField(Buyer)
    def __str__(self):
        return self.gname +"  "+ str(self.price)
​

  • 购买商品

def sellgoods(req):
    goods = Goods.objects.get(pk=randint(1,Goods.objects.count()))
    goods.buyer.add(Buyer.objects.get(pk=randint(1,Buyer.objects.count())))
    goods.save()
    return HttpResponse("剁手成功")

  • 正向查询

def findgoods_by_buyer(req):
    buyer = Buyer.objects.get(pk=13)
    res = buyer.goods_set.all()
    print(res)
    return HttpResponse("由买家查询商品")

  • 反向查询

def findbuyer_by_goods(request):
    goods = Goods.objects.last()
    buyer = goods.buyer.all()
    print(buyer)
    return HttpResponse("由商品查询买家")

 

2.模型继承

django中的数据库模块提供了一个非常不错的功能，就是支持models的面向对象，可以在models中添加Meta，指定是否抽象，然后进行继承

class Animal(models.Model):
        xxx
        class Meta:
            abstract = True/False
    
class Dog(Animal):
        xxx
​

默认模型就是允许继承的，但是默认的继承处理方式不是很合理：

  • 默认在父类中定义的字段会存在父类的表中，子类的数据通用部分会存在父表中，子类特有数据会在子表中，子类通过外键进行级联

  • 默认方式比较垃圾，效率比较低

开发中，需要将父类抽象化，在元信息中使用abstract=True

  • 抽象化的父类不会再数据库生成表了

  • 子类会将父类中的通用数据，复制到子表中

浮东源
关注
专栏目录
Django shell 使用方法
qq_52890159的博客
01-07 2177
Django shell 简单操作
django-filter的使用
奔跑的豆子的专栏
03-03 1645
django-filter是一个通用的、可重用的应用程序，它可以减轻视图代码的编写工作量。具体来说，它允许用户根据模型的字段筛选查询集，并显示表单让他们这样做
Django shell
实践求真知
12-02 760
一 什么是Django Shell 它是一个Python的交互命令行程序 它自动引入了我们项目环境 我们可以使用它与我们的项目进行交互 二 如何使用Django Shell PS E:\Django\myblog&gt; python manage.py shell Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MS...
（三）Django shell 使用方法
热门推荐
aganliang的专栏
07-22 1万+
  Django shell 可以在终端中，通过交互式终端会话以编程方式查看这些数据。 如上图所示，虚拟环境激活后，通过命令 python manage.py shell 启动shell 如何输入应用程序的一个模块的类Topic，然后把这个类的所有实例显示出来。 上图是通过外键关系获取数据，语法是： 模型的小写_set.all()，即model ：entry_set.al...
django-filter使用
qinshi501的博客
02-15 1099
在 Django 中，django-filter 是一个第三方库，它提供了易于使用和灵活的过滤功能，用于 Django 的视图和 API。使用 django-filter，你可以轻松地为你的模型创建查询集过滤器，并将其应用于你的视图和 API 端点，从而为用户提供强大的搜索和过滤功能。在你的 Django 应用中，创建一个新的 Python 文件（例如 filters.py），然后定义一个继承自 django_filters.FilterSet 的类。在你的视图中，你可以使用创建的过滤器类来过滤查询集。
Django-filter
shanshan的博客
06-12 720
如果是自定义动作，除非过滤条件比较复杂，不然不需要用django-filter，因为还要手动指定，比较复杂。
django-vue-admin项目运行
NLP工程化
07-16 858
文本主要对django-vue-admin项目进行了简要介绍，并且对前后端进行了源码安装和运行。在此基础上可作为管理系统二次开发的基础框架。
Django-filter 使用详解
qq_44213653的博客
09-07 3352
Django-filter 初次使用
django-guardian基础教程一
weixin_42935779的博客
03-05 2029
文章目录前言一、django-guardian是什么？二、使用步骤1.安装2.配置总结 前言 Django默认提供的权限控制是基于模型级的，但是如果一个系统对于权限的控制比较复杂，模型级的权限控制是不满足需求的。django-guardian弥补了Django的权限控制的不足，它是基于对象级的权限控制，可能把权限控制得更加细致，从而应对复杂的系统。 一、django-guardian是什么？ Django默认提供的权限控制方式是基于模型级，而django-guardian提供了对象级的权限控制。 二、
django-comment-migrate 模型注释的使用
u010674101的专栏
03-14 1584
django-comment-migrate 是一款方便易用的工具，可以帮助您保持数据库表注释与模型定义的一致性。建议您在您的 Django 项目中使用它。
django-mptt-admin：Django-mptt-admin为Mptt模型提供了一个不错的Django Admin界面
02-04
**Django-mptt-admin** 是一个专门为Django框架中的MPTT（Modified Preorder Tree Traversal）模型设计的扩展，旨在改善MPTT模型在Django管理后台（Django Admin）中的显示和操作体验。这个工具使得开发人员能够更...
django-registration：Django-registration（redux）为Django网站提供用户注册功能
02-05
为了确保安全，`django-registration-redux`使用Django的内置模型`User`或其替代品（如`AbstractBaseUser`），并提供了处理密码哈希的安全方法。此外，它还支持限制同一IP地址的注册频率，防止恶意注册。 ### 错误...
django-code-generator:从Django模型生成代码以加快开发速度
05-19
从Django模型生成代码以加快开发速度。 该项目可以为您的应用生成Django Rest Framework API或管理员。 您还可以创建自己的模板，以便可以根据需要生成代码。 要安装django-code-generator，请在终端中运行以下...
django-lb-workflow：适用于Django的可重用工作流库
02-04
5. **API接口**：提供丰富的API接口，方便在Django视图、模板和模型中集成和操作工作流。 6. **扩展性**：`django-lb-workflow` 设计为高度可扩展，允许开发者根据需求添加自定义行为和逻辑。 **如何使用：** 1. **...
django-advanced-filters：向Django管理员添加高级过滤功能
02-05
在Django框架中，内置的管理后台（admin site）提供了一种便捷的方式来管理和查看数据库模型的记录。然而，对于复杂的数据筛选需求，Django默认的过滤选项可能显得较为有限。`django-advanced-filters`是一个扩展库...
【java毕业设计】应急救援物资管理系统源码（springboot+vue+mysql+说明文档）.zip
11-06
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
基于java的音乐网站答辩PPT.pptx
11-06
基于java的音乐网站答辩PPT.pptx
基于Flexsim的公路交通仿真系统.zip
最新发布
11-06
基于Flexsim软件开发的仿真系统，可供参考学习使用
weixin073智慧旅游平台开发微信小程序+ssm后端毕业源码案例设计.zip
11-06
weixin073智慧旅游平台开发微信小程序+ssm后端毕业源码案例设计 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
Django-Widgy：高效CMS开发框架
"django-widgy 是一个用于CMS（内容管理系统）开发的框架组件，它能够极大地简化开发流程。这个框架是针对Django设计的，提供了一个异构树编辑器，适用于构建复杂的内容管理系统。异构树意味着每个节点都可以是不同...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值