码迷,mamicode.com
首页 > 其他好文 > 详细

Django orm操作

时间:2019-06-12 22:53:51      阅读:95      评论:0      收藏:0      [点我收藏+]

标签:def   auto   div   update   分组查询   delete   字段名   gate   exclude   

一,用一个单独的py文件测试orm操作需要配置的参数

  在应用中新建一个test.py的测试文件来实现orm操作:

import os
if __name__ == "__main__":                    
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "

    day58.settings")  
     # 以上代码实在当前项目的manage.py中copy的
    
    import django
    django.setup()
    from app01 import models

二,单表的创建,数据的修改,删除

  1,创建表:

  在models.py中写下以下代码,并且依次执行python manage.py makemigrations  和 python manage.py migrate

class User(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    register_time = models.DateField()
    def __str__(self):
        return 对象的名字:%s%self.name

  2,新增数据:

    方式一:

# 基于create创建
user_obj = models.User.objects.create(name=tank,age=73,register_time=2019-2-14)

    方式二:

# 基于对象的绑定方法创建
user_obj = models.User(name=kevin,age=30,register_time=2019-1-1)
user_obj.save()

    ps:register_time 字段可以自动格式化时间:

from datetime import datetime
ctime = datetime.now()
models.User.objects.create(name=egon, age=18, register_time=ctime)

   3,修改数据

    方式一:

# 基于对象
user_obj = models.User.objects.filter(name=jason).first()
user_obj.age = 17
user_obj.save()

    方式二:

# 基于queryset
models.User.objects.filter(name=kevin).update(age=66)

  3,删除数据

    方式一:

# 基于对象
user_obj = models.User.objects.filter(name=owen).first()
user_obj.delete()

    方式二:

# 基于queryset
models.User.objects.filter(name=egon).delete()

三,单表的查询

  1,查询所有结果

user_obj = models.User.objects.all()

  2,查询具符合筛选条件的匹配对象

# filter内可以放多个限制条件但是需要注意的是多个条件之间是and关系
models.User.objects.filter(name=jason,age=17)

  3,查询具符合筛选条件的匹配对象,返回的结果有且只有一个,如果筛选条件对象超过一个或者没有都会报错(不推荐使用)

models.User.objects.get(name=jason)

  4,查询到与所选筛选条件不匹配的对象

models.User.objects.exclude(name=jason)

  5,对查询的结果排序

models.User.objects.order_by(age)   # 默认是升序
models.User.objects.order_by(-age)  # 可以在排序的字段前面加一个减号就是降序

  6,对查询的结果反向排序(前面的结果要有排序(order_by))

models.User.objects.order_by(age).reverse()

  7,查询querset对象的数量(对queryset对象使用),

 models.User.objects.all().count() # 此时的models.User.objects.all()是一个queryset对象,查询的结果也是querset对象

  8,查询第一个条记录

models.User.objects.all().first()
models.User.objects.all()[0]  # 不支持负数的索引取值

  9,查询最后一条记录

models.User.objects.all().last()

  10,查询该条数据是否存在

models.User.objects.filter(name=jason,age=3).exists() # 如果QuerySet包含数据,就返回True,否则返回False

  11,返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列model的实例化对象,而是一个可迭代的字典序列

models.User.objects.values(name)  # 列表套字典,字典的键是‘字段名‘,值是对应数据库中的数据

   12,返回一元祖序列

models.User.objects.values_list(name,age)  # 列表套元祖

   13,从返回结果中剔除重复纪录,去重的对象必须是完全相同的数据才能去重

models.User.objects.values(name,age).distinct()

 

四,单表的范围查询(双下划线查询)

  1,查询年轻大于44岁的用户

models.User.objects.filter(age__gt=44) # age > 44

  2,查询年轻小于44岁的用户

models.User.objects.filter(age__lt=44) # age < 44

  3,查询年轻大于等于44岁的用户

models.User.objects.filter(age__gte=44) # age >= 44

  4,查询年轻小于等于44岁的用户

models.User.objects.filter(age__lte=44) # age <= 44

  5,查询年龄是44或者22或者73的用户

models.User.objects.filter(age__in=[44,22,73]) # or 关系

  6,查询年龄在22到44范围内

 models.User.objects.filter(age__range=[22,44])

  7,查询在2017年注册的用户

models.User.objects.filter(register_time__year=2017)

  8,查询名字中包含字母n的用户 

models.Author.objects.filter(name__contains=n) # 区分大小写
models.Author.objects.filter(name__icontains=n)# 无视大小写

  9,查询名字以j开头的用户

models.User.objects.filter(name__startswith=j)

  10,查询名字以j开头的用户

models.User.objects.filter(name__endswith=n)

五,多表的创建,数据的修改和删除

  多表的创建

class Book(models.Model):
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8,decimal_places=2)
    # 配置auto_now_add=True,创建数据记录的时候会把当前时间添加到数据库中。
    # 配置auto_now=True,每次更新数据记录都会更新
    publish_date = models.DateField(auto_now_add=True)
    # 外键关系
    # 默认建立一个publish_id字段 与 Publish表的id字段相连
    # publish_id 必须从Publish的id中选取
    publish = models.ForeignKey(to=Publish,to_field=None) # to_field不指定默认为none
    # 在数据库中会建立一个book_authors表,该表中的book_id 和 Book表的id相连
    # 该表中的author_id 和 Book表的id相连
    # 注意:不会在Book表中建立字段
    authors = models.ManyToManyField(to=Author)  # 虚拟字段,信号字段
    def __str__(self):
        return 书籍对象的名字:%s%self.title

class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)
    email = models.EmailField()  # 对应就是varchar类型

    def __str__(self):
        return 出版社对象的名字:%s%self.name

class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    # AuthorDetail 相当于Author表的延伸
    # 在author表中会有一个authorDetail_id字段,必须从AuthorDetail的id中选取
    authordetail = models.OneToOneField(to=AuthorDetail)

    def __str__(self):
        return  作者对象的名字:%s%self.name

class AuthorDetail(models.Model):
    phone = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)

   插入数据

    方式一:

# 直接写id 
models.Book.objects.create(title=红楼梦,price=66.66,publish_id=1)

    方式二:

# 传数据对象
publish_obj = models.Publish.objects.filter(pk=2).first() # 首先创建一个Publish对象
models.Book.objects.create(title=三国演义,price=199.99,publish=publish_obj)

  修改数据

    queryset修改

# 方式一
models.Book.objects.filter(pk=1).update(publish_id=3)
# 方式二
publish_obj = models.Publish.objects.filter(pk=2).first()
models.Book.objects.filter(pk=1).update(publish=publish_obj)

    对象修改

# 方式一
book_obj = models.Book.objects.filter(pk=1).first()
book_obj.publish_id = 3  # 点表中真实存在的字段名
book_obj.save()
# 方式二
publish_obj = models.Publish.objects.filter(pk=2).first()
book_obj.publish = publish_obj  # 点orm中字段名 传该字段对应的表的数据对象
book_obj.save()

  删除数据

# 删除后Publish的数据不会改变
models.Book.objects.filter(pk=1).delete()
# 删除后Book里面与Publish外键管理的字段全部清除
models.Publish.objects.filter(pk=1).delete()

  给书籍绑定与作者之间的关系(给book_authors表中添加字段)

    方式一:add支持传数字,一个或多个

book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.add(1)
book_obj.authors.add(2,3) # 书籍序号为3的作者是序号为2和3的作者

    方式二:add支持传对象,一个或多个

author_obj = models.Author.objects.filter(pk=1).first()
author_obj1 = models.Author.objects.filter(pk=3).first()
book_obj.authors.add(author_obj)
book_obj.authors.add(author_obj,author_obj1)

  修改数据与作者的关系

    方式一:

book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.set((1,)) # 将序号为3的书籍作者修改为序号为1的作者
book_obj.authors.set((1,2,3)) # set传的必须是可迭代对象!!!

    方式二:

author_list = models.Author.objects.all()
book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.set(author_list) # author_list是一个列表里有多个对象

   删除数据与作者的绑定关系

    方式一:

 book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.remove(1)
book_obj.authors.remove(2,3)

    方式二:

book_obj = models.Book.objects.filter(pk=3).first()
author_obj = models.Author.objects.all().first()
author_list = models.Author.objects.all()
book_obj.authors.remove(author_obj)
book_obj.authors.remove(*author_list)

  清空当前表记录对应的绑定关系:

book_obj = models.Book.objects.filter(pk=3).first()
book_obj.authors.clear()

 

六,多表查询

  多表查询是基于对象的表查询

  正向查询案例:

    本质是通过点语法得到与之关联的表对象,从而取值(通过字段来用句点符取值)

    查询书籍是三国演义的出版社邮箱:

book_obj = models.Book.objects.filter(title=三国演义).first()
# book_obj.publish相当于从Book表到了Publish表中了
print(book_obj.publish.email)

    查询书籍是三国演义的作者的所有信息:

book_obj = models.Book.objects.filter(title=三国演义).first()
print(book_obj.authors)  # app01.Author.None
print(book_obj.authors.all())

    查询作者为jason电话号码

user_obj = models.Author.objects.filter(name=jason).first()
print(user_obj.authordetail.phone)

  反向查询案例:

    本质是因为被关联表的并没有明显的字段显示与另一张表的关系,然而实际上有,通过点小写的被关联的表名来取值(通过表名来用句点符取值)

    一对多字段的反向查询:

      查询出版社是东方出版社出版的书籍

 publish_obj = models.Publish.objects.filter(name=东方出版社).first()
# 按表名小写_set.all() 因为一个出版社对应着多个图书
print(publish_obj.book_set)  # app01.Book.None
print(publish_obj.book_set.all())

    一对一字段的反向查询:

      查询作者电话号码是110的作者姓名    

authordetail_obj = models.AuthorDetail.objects.filter(phone=110).first()
print(authordetail_obj.author.name)

    多对多字段的反向查询:

      查询作者jason写过的所有的书

author_obj = models.Author.objects.filter(name=jason).first()
print(author_obj.book_set)  # app01.Book.None
print(author_obj.book_set.all())

七,多表基于双下划线的查询(跨表查询)  

  正向查询案例:

    查询书籍为三国演义的出版社地址:

# publish__addr 拿到Publish的addr字段
res = models.Book.objects.filter(title=三国演义).values(publish__addr,title)
print(res)

    查询书籍为红楼梦的作者的姓名:

res = models.Book.objects.filter(title=红楼梦).values("authors__name",title)
print(res)

    查询作者为jason的家乡:

res = models.Author.objects.filter(name=jason).values(authordetail__addr)
print(res)

   反向查询案例

、   查询南方出版社出版的书名:

res = models.Publish.objects.filter(name=南方出版社).values(book__title)
print(res)

    查询电话号码为120的作者姓名:

res = models.AuthorDetail.objects.filter(phone=120).values(author__name)
print(res)

    查询作者为jason的写的书的名字:

res = models.Author.objects.filter(name=jason).values(book__title)
print(res)

    查询书籍为三国演义的作者的电话号码:

# authors__authordetail__phone:连续跨表,先到author表,再到authordetail表
res = models.Book.objects.filter(title=三国演义).values(authors__authordetail__phone)
print(res)

  正反两种方式查询数据

    查询jason作者的手机号:

# 正向
res = models.Author.objects.filter(name=jason).values(authordetail__phone)
print(res)
# 反向
# filter(author__name=‘jason‘):在filter中跨表筛选条件
res = models.AuthorDetail.objects.filter(author__name=jason).values(phone)
print(res)

    查询出版社为东方出版社的所有图书的名字和价格:

# 正向
res = models.Publish.objects.filter(name=东方出版社).values(book__title,book__price)
print(res)
# 反向
res = models.Book.objects.filter(publish__name=东方出版社).values(title,price)
print(res)

    查询东方出版社出版的价格大于400的书:

# 正向
res = models.Publish.objects.filter(name="东方出版社",book__price__gt=400).values(book__title,book__price)
 print(res)
# 反向
res = models.Book.objects.filter(price__gt=400,publish__name=东方出版社).values(title,price)
print(res)

八,聚合查询 (aggregate)

  查询某个书籍的作者个数:

res = models.Book.objects.filter(pk=3).aggregate(count_num=Count(authors))
print(res)

  查询所有出版社出版的书的平均价格:

res = models.Publish.objects.aggregate(avg_price=Avg(book__price))
print(res)

  统计东方出版社出版的书籍的个数:

res = models.Publish.objects.filter(name=东方出版社).aggregate(count_num=Count(book__id))
print(res)

九,分组查询 (annotate) 就是sql语句中的group_by

  统计每个出版社出版的书的平均价格:

# 用Publish来分组(因为条件是每个出版社,所以以出版社来分组)
res = models.Publish.objects.annotate(avg_price=Avg(book__price)).values(name,avg_price)
 print(res)

  统计每一本书的作者个数:

res = models.Book.objects.annotate(count_num=Count(authors)).values(title,count_num)
print(res)

  统计出每个出版社卖的最便宜的书的价格:

res = models.Publish.objects.annotate(min_price=Min(book__price)).values(name,min_price)
print(res)

  查询每个作者出的书的总价格:

res = models.Author.objects.annotate(sum_price=Sum(book__price)).values(name,sum_price)
print(res)

 

 

   

 

 

 

 

    

  

      

    

    

    

    

    

 

Django orm操作

标签:def   auto   div   update   分组查询   delete   字段名   gate   exclude   

原文地址:https://www.cnblogs.com/ay742936292/p/11011556.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!