博客园 首页 私信博主 显示目录 隐藏目录 管理 动画

Django orm操作

一,用一个单独的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

  导入聚合函数:

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

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

# 用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)

 

 

   

 

 

 

 

    

  

      

    

    

    

    

    

 

posted @ 2019-06-12 22:31  monsterc4t  阅读(112)  评论(0编辑  收藏  举报

消失在风中的少年 -mashiro