• Django之ORM


    一、创建表之前的准备工作

    一、自己创建数据库

    二、在settings里面配置mysql数据库链接

      sqlite3------改为mysql

    # 修改django默认的数据库的sqlite3为mysql
    DATABASES = {
        'default': {
                'ENGINE': 'django.db.backends.mysql', #通过这个去链接mysql
                'NAME': 'djangotsgl',
                'USER':'root',
                'PASSWORD':'123456',
                'HOST':'localhost',
                'PORT':'3306',
            }
        }

    三、根目录的 __init___中,添加

    import pymysql
    pymysql.install_as_MySQLdb()

    四、创建数据库表

    class Class(models.Model):
        caption = models.CharField(max_length=64)
        grade = models.ForeignKey('ClassGrade', on_delete=models.CASCADE) #一对多
    
    class Student(models.Model):
        sname = models.CharField(max_length=32)
        gender = models.CharField(max_length=32)
        cls = models.ForeignKey('Class', on_delete=models.CASCADE)
    
    class Teacher(models.Model):
        cls = models.ManyToManyField("Class")
        tname = models.CharField(max_length=32)
    
    class Course(models.Model):
        cname = models.CharField(max_length=64)
        teacher = models.ForeignKey('Teacher', on_delete=models.CASCADE)
    
    class Score(models.Model):
        student = models.ForeignKey("Student", on_delete=models.CASCADE)
        course = models.ForeignKey("Course", on_delete=models.CASCADE)
        score = models.IntegerField()
    
    class ClassGrade(models.Model):
        gname = models.CharField(max_length=64)

     执行命令创建:(需要记住的!!!)

    python3 manage.py makemigrations   创建脚本
    python3 manage.py migrate   迁移

    五、查看数据库执行的sql语句(加在settings.py)

    查看数据库执行代码
    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'handlers': {
            'console':{
                'level':'DEBUG',
                'class':'logging.StreamHandler',
            },
        },
        'loggers': {
            'django.db.backends': {
                'handlers': ['console'],
                'propagate': True,
                'level':'DEBUG',
            },
        }
    }

    django之数据库表的单表查询

    一、添加表记录

    对于单表有两种方式

    Frank_obj = models.Student(name ="海东",course="python",birth="2000-9-9",fenshu=80)
        Frank_obj.save()
        # 方式二:
        models.Student.objects.create(name ="海燕",course="python",birth="1995-5-9",fenshu=88)

    二、查询表记录

    # 查询相关API
        # 1、all():查看所有
        student_obj = models.Student.objects.all()
        print(student_obj)  #打印的结果是QuerySet集合
        # 2、filter():可以实现且关系,但是或关系需要借助Q查询实现。。。
        #              查不到的时候不会报错
        print(models.Student.objects.filter(name="Frank"))  #查看名字是Frank的
        print(models.Student.objects.filter(name="Frank",fenshu=80))  #查看名字是Frank的并且分数是80的
        # 3、get():如果找不到就会报错,如果有多个值,也会报错,只能拿有一个值的
        print(models.Student.objects.get(name="Frank"))  #拿到的是model对象
        print(models.Student.objects.get(nid=2))  #拿到的是model对象
        # 4、exclude():排除条件
        print( models.Student.objects.exclude(name="海东")) #查看除了名字是海东的信息
        # 5、values():是QuerySet的一个方法 (吧对象转换成字典的形式了,)
        print(models.Student.objects.filter(name="海东").values("nid","course")) #查看名字为海东的编号和课程
        #打印结果:<QuerySet [{'nid': 2, 'course': 'python'}, {'nid': 24, 'course': 'python'}]>
        # 6、values_list():是queryset的一个方法 (吧对象转成元组的形式了)
        print(models.Student.objects.filter(name="海东").values_list("nid", "course"))
        #打印结果:< QuerySet[(2, 'python'), (24, 'python')] >
        # 7、order_by():排序
        print(models.Student.objects.all().order_by("fenshu"))
        # 8、reverse():倒序
        print(models.Student.objects.all().reverse())
        # 9、distinct():去重(只要结果里面有重复的)
        print(models.Student.objects.filter(course="python").values("fenshu").distinct())
        # 10、count():查看有几条记录
        print(models.Student.objects.filter(name="海东").count())
    
        # 11、first()
        # 12、last()
        return render(request,"test.html",{"student_obj":student_obj})
        # 13、esits:查看有没有记录,如果有返回True,没有返回False
            #         并不需要判断所有的数据,
            # if models.Book.objects.all().exists():

    双下方法之单表查询

    Book.objects.filter(price__in=[100,200,300])
    Book.objects.filter(price__gt=100)
    Book.objects.filter(price__lt=100)
    Book.objects.filter(price__range=[100,200])
    Book.objects.filter(title__contains="")
    Book.objects.filter(title__icontains="python")  # 不区分大小写
    Book.objects.filter(title__startswith="")
    Book.objects.filter(pub_date__year=2018)

     三、修改表记录

    stu = models.Publisher.objects.filter(id=2).update(name="alex")

    四、删除表记录

    删除方法就是 delete()。它运行时立即删除对象而不返回任何值

    def delstudent(request,id):
        # 删除数据
        models.Student.objects.filter(nid=id).delete()
        return redirect("/index/")

    在 Django 删除对象时,会模仿 SQL 约束 ON DELETE CASCADE 的行为,换句话说,删除一个对象时也会删除与它相关联的外键对象

    多表操作

    创建表

    创建一对一的关系:OneToOne("要绑定关系的表名")

    创建一对多的关系:ForeignKey("要绑定关系的表名",on_delete=models.CASCADE)

    创建多对多的关系:ManyToMany("要绑定关系的表名")  会自动创建第三张表

    基于对象的查询记录(相当于sql语句的where子查询)

    一对一查询记录:author和authordetile是一对一的关系

    正向查询(按字段author)

    反向查询(按表名authordeital):因为是一对一的关系了,就不用_set了

    # 一对一的查询
        # 正向查询:手机号为13245的作者的姓名
        deital_obj = models.AuthorDeital.objects.filter(tel="13245").first()
        print(deital_obj.author.name)
        # 反向查询:查询egon的手机号
        egon_obj = models.Author.objects.filter(name="egon").first()
        print(egon_obj.authordeital.tel)

    一对多查询记录:

    正向查询(按字段:publish):

    反向查询(按表名:book_set)

    # 正向查询:查询真正的勇士这本书的出版社的地址
        book_obj = models.Book.objects.filter(title="真正的勇士")[0]  # 找对象
        print("======", book_obj.publish)  # 拿到的是关联出版社的对象
        print(book_obj.publish.addr)
      # 反向查询:查询人民出版社出版过的所有的书的价格和名字
        pub_obj = models.Publish.objects.filter(name="人民出版社")[0]
        book_dic = pub_obj.book_set.all().values("price", "title")[0]
        print(book_dic)
        print(book_dic["price"])
       # 查询 人民出版社出版过的所有书籍
        publish=models.Publish.objects.get(name="人民出版社")   #get得到的直接是一个对象,不过get只能查看有一条记录的
        book_list=publish.book_set.all()  # 与人民出版社关联的所有书籍对象集合
         for book_obj in book_list:
          print(book_obj.title)
    注意这里用for循环或是用values,vauleslist都是可以的。

    多对多查询记录:

    正向查询(按字段authorlist)

    反向查询(按表名book_set)

    # 多对多的查询
        # 正向查询:查询追风筝的人的这本书的所有的作者的姓名和年龄
        book_obj = models.Book.objects.filter(title="红楼梦")[0]
        print(book_obj.authorlist.all().values("name", "age"))  # 这本书关联的所有作者对象的集合
        # 反向查询:查询作者是haiyan的这个人出了哪几本书的信息
        haiyan_obj = models.Author.objects.filter(name="haiyan")[0]
        print("bookinfo====", haiyan_obj.book_set.all().first().title)  # 与该作者关联的所有书对象的集合
        return HttpResponse("ok")

    四、基于双下划线的跨表查询

    一对多查询:

    # 练习1、查询人民出版社出版过的所有的书的价格和名字
    #
    基于双下划线的方式查询1================一对多 # 第一种查法 ret = models.Publish.objects.filter(name="人民出版社").values("book__price","book__title") print(ret) # 第二种查法 ret2 = models.Book.objects.filter(publish__name="人民出版社").values("price","title") print(ret2)

    多对多查询:

    练习1、查询egon出过的所有书的名字
    #方式一    
        ret = models.Author.objects.filter(name="egon").values("book__title")
        print(ret)
    #方式二:两种方式也就是逻辑不一样
        ret2 = models.Book.objects.filter(authorlist__name="egon").values("title")
        print(ret2)
    练习2、查询手机号以151开头的作者出版过的所有书的名称以及出版社的名称
    # 方式一:
    author_obj = models.AuthorDeital.objects.filter(tel__startswith="151").first()
    print(author_obj.author.book_set.all().values("title","publish__name"))
    # 方式二:
    ret=models.Book.objects.filter(authorlist__author_deital__tel__startswith="151").values("title","publish__name")
        print(ret)

    五、聚合查询与分组查询(很重要!!!)

    聚合查询:aggregate(*args, **kwargs),只对一个组进行聚合

    from django.db.models import Avg,Sum,Count,Max,Min
    # 1、查询所有图书的平均价格
    print(models.Book.objects.all().aggregate(Avg("price")))

    aggregate()QuerySet 的一个终止子句(也就是返回的不再是一个QuerySet集合的时候),意思是说,它返回一个包含一些键值对的字典。键的名称是聚合值的标识符,值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定一个名称,可以向聚合子句提供它

    如果你希望生成不止一个聚合,你可以向aggregate()子句中添加另一个参数。所以,如果你也想知道所有图书价格的最大值和最小值,可以这样查询:

    print(models.Book.objects.all().aggregate(Avg("price"),Max("price"),Min("price")))
    #打印的结果是:  {'price__avg': 174.33333333333334, 'price__max': Decimal('366.00'), 'price__min': Decimal('12.00')}

    分组查询 :annotate():为QuerySet中每一个对象都生成一个独立的汇总值。

    是对分组完之后的结果进行的聚合

     # 19、查询每门课程的平均成绩,结果按平均成绩升序排列,平均成绩相同时,按课程号降序排列;
        # stu = models.Score.objects.values("course_id").annotate(c=Avg("score")).order_by("c")
        # print(stu)
    values("course_id"):表示以course_id分组
    order_by('-score') : 排序/倒序
    annotate(c=Avg("score"),b=Max('scors')) 可以加多个条件
    1、统计每一本书的作者个数
    #
    方式一: print(models.Book.objects.all().annotate(authorNum = Count("authorlist__name")).values("authorNum")) # 方式二: booklist =models.Book.objects.all().annotate(authorNum=Count("authorlist__name")) for book_obj in booklist: print(book_obj.title,book_obj.authorNum)
    # 2、统计每一个出版社的最便宜的书
        # 方式一:
        print(models.Book.objects.values("publish__name").annotate(nMinPrice=Min('price')))  注意:values内的字段即group by的字段,,也就是分组条件
        # 方式二:
        print(models.Publish.objects.all().annotate(minprice=Min("book__price")).values("name","minprice"))
        # 方式三
        publishlist = models.Publish.objects.annotate(minprice = Min("book__price"))
        for publish_obj in publishlist:
            print(publish_obj.name,publish_obj.minprice)
    3、统计每一本以py开头的书籍的作者个数:
    print(models.Book.objects.filter(title__startswith="py").annotate(authNum = Count("authorlist__name")).values("authNum"))
    (4)统计不止一个作者的图书:
    print(models.Book.objects.annotate(num_authors=Count('authorlist__name')).filter(num_authors__gt=1).values("title","num_authors"))
    (5)根据一本图书作者数量的多少对查询集QuerySet进行排序:
    print(models.Book.objects.all().annotate(authorsNum=Count("authorlist__name")).order_by("authorsNum"))
    (6)查询各个作者出的书的总价格:
    # 方式一
        print(models.Author.objects.all().annotate(priceSum = Sum("book__price")).values("name","priceSum"))
     # 方式二
        print(models.Book.objects.values("authorlist__name").annotate(priceSum=Sum("price")).values("authorlist__name","priceSum"))
    六、F查询和Q查询

    F查询:

    在上面所有的例子中,我们构造的过滤器都只是将字段值与某个常量做比较。如果我们要对两个字段的值做比较,那该怎么做呢?

    Django 提供 F() 来做这样的比较。F() 的实例可以在查询中引用字段,来比较同一个 model 实例中两个不同字段的值。

    1、查看评论数大于阅读数的书
     from django.db.models import F,Q
     print(models.Book.objects.filter(commentNum__gt=F("readNum")))
    2、修改操作也可以使用F函数,比如将id大于1的所有的书的价格涨价100元
    print(models.Book.objects.filter(nid__gt=1).update(price=F("price")+100))
    3、Django 支持 F() 对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
    # 查询评论数大于收藏数2倍的书籍
        models.Book.objects.filter(commnetNum__gt=F('keepNum')*2)
    Q查询:
    filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询(例如OR 语句),你可以使用对象
    1、查询id大于1并且评论数大于100的书
    
     print(models.Book.objects.filter(nid__gt=1,commentNum__gt=100))
     print(models.Book.objects.filter(nid__gt=1).filter(commentNum__gt=100))
     print(models.Book.objects.filter(Q(nid__gt=1)&Q(commentNum__gt=100)))
    2、查询评论数大于100或者阅读数小于200的书
    print(models.Book.objects.filter(Q(commentNum__gt=100)|Q(readNum__lt=200)))
    Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时,它产生一个新的Q 对象。
    3、查询年份等于2017年或者价格大于200的书
     print(models.Book.objects.filter(Q(publishDdata__year=2017)|Q(price__gt=200)))
    4、查询年份不是2017年或者价格大于200的书
    print(models.Book.objects.filter(~Q(publishDdata__year=2017)&Q(price__gt=200)))

    注意:

    查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数(关键字参数或Q 对象)都将"AND”在一起。但是,如果出现Q 对象,它必须位于所有关键字参数的前面。例如:

    bookList=models.Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017), title__icontains="python" )






















  • 相关阅读:
    【BZOJ1123】 [POI2008]BLO (tarjan)
    【距离GDKOI:44天&GDOI:107天】【BZOJ1040】[ZJOI2008] 骑士 (环套树DP)
    【距离GDOI:128天】【POJ2778】DNA Sequence(AC自动机+矩阵加速)
    【BZOJ1030】[JSOI2007]文本生成器
    【距离GDOI:130天】 AC自动机ing
    【距离GDOI:131天】 后缀数组完毕
    【SPOJ220】Relevant Phrases of Annihilation (SA)
    【POJ3294】 Life Forms(SA)
    【POJ3415】 Common Substrings (SA+单调栈)
    笔记本
  • 原文地址:https://www.cnblogs.com/echo2019/p/10591137.html
Copyright © 2020-2023  润新知