python自动化学习笔记之DAY19

Django-model基础

表的创建（模型建立）

例1：
from django.db import models
#书籍
class Book(models.Model):
    id=models.AutoField(primary_key=True)
    title=models.CharField(max_length=32)
    pubDate=models.DateField()
    price=models.DecimalField(max_digits=6,decimal_places=2)

    # 书籍与出版社： 一对多
    publisher=models.ForeignKey(to="Publish",related_name="bookList")

    # 书籍与作者： 多对多
    authors=models.ManyToManyField("Author")

#出版社
class Publish(models.Model):
    name=models.CharField(max_length=32)
    addr=models.CharField(max_length=32)
    tel=models.BigIntegerField()

#作者
class Author(models.Model):
    name=models.CharField(max_length=32)
    age=models.IntegerField()
tel=models.CharField(max_length=32)

#作者详细信息
class AuthorDetail(models.Model):
addr=models.CharField(max_length=32)
#作者与作者详细信息：一对一的
author=models.OneToOneField("Author")

说明：

（1）、id字段是自动添加的

（2）、对于外键字段，Django会在字段名上添加“_id”来创建数据库中的列名

（3）、外键字段ForeignKey有一个null=True的设置，他可以为空置NULL，可以赋值None

1、  查询表记录

all（）：查询所有结果，例如：查询所有书籍信息：models.Book.objects.all（）

filter（**kwargs）：过滤的出的是对象集合（QuerySet） 例如：过滤名称为Python的书籍，models.Book.objects.filter（title=“Python”）

get（**kwargs）：返回结果为对象，有且只有一个，如果有多个会报错

values（**kwargs）:返回一个ValueQuerySet，一个特殊的QuerySet，运行后得到的是一个可迭代的字典序列，而不是model的实例化对象

value_list（**field）：与values（）类似，它返回的是一个元祖序列，values返回的是一个字典序列

exclude（**kwargs）:返回给筛选条件不匹配的对象

distinct（）：删除重复记录

count（）：返回数据库中匹配查询（QuerySet）的对象数量

first（）/last（）：返回第一条/最后一条记录

exists（）：返回布尔值，如果QuerySet有数据，返回True，没有则返回False

order_by（*field）/reverse（）：对查询结果排序/反向排序

2、  添加表记录

普通字段：

方式1：

models.Book.objects.create(title="python",price=122,pubDate="2012-12-12")

方式2：

obj=models.Book(title="python",price=122,pubDate="2012-12-12")

obj.save()

外键字段：

方式1：

publish_obj=models.Publish.objects.get(name="renmin")

book_obj=models.Book.objects.create(title="python",price=122,pubDate="2012-12-12",publisher=publish_obj)

方式2：

book_obj=models.Book.objects.create(title=titles,price=price,pubDate=pubdate,publisher_id=publish_id)

多对多字段

book_obj=models.Book.objects.create(title=title,pubDate=pubdate,price=price,publisher_id=publish_id)

绑定关系

print(book_obj.authors.all())         #  <QuerySet []>

book_obj.authors.add(obj,obj2,...)

book_obj.authors.add(*[])

解除关系

book_obj.authors.remove(obj,obj2,...)

book_obj.authors.remove(*[])

清空

book_obj.authors.clear()

3、  class RelatedManager

add（[obj1，obj2，…]）：把指定的模型对象添加到关联对象集中。

create（**kwargs）:创建一个新的对象，保存对象，并将它添加到关联对象集之中，返回新创建的对象

remove（[obj1，obj2，…]）：从关联对象集中移除执行的模型对象

clear（）：从关联对象集中移除一切对象

set（）：先清空，在设置，编辑替换可以用到

4、  ORM跨表查询

（1）、基于对象的跨表查询

#############################一对多查询###########################

正向查询：按字段

例如：查询python这本书的出版社的名称和地址

book_python=models.Book.objects.filter(title="python").first()

book_python.publisher            # Publish object : 与这本书关联的

book_python.publisher.name   出版社的名称

book_python.publisher.addr    出版社的地址

反向查询：按关联的表名（小写）_set

例如：查询人民出版社出版过的所有书籍名称及价格

pub_obj=models.Publish.objects.get(name="renmin")

book_list=pub_obj.book_set.all()   # QuerySet 与这个出版社关联的所有书籍对象

for obj in book_list:

           print(obj.title,obj.price)

#############################一对一查询###########################

正向查询：按字段

例如：查询addr在沙河的作者

authorDetail=models.AuthorDetail.objects.get(addr="shahe")

print(authorDetail.author.name) # alex

反向查询：按表名（小写）

查询 alex混迹在哪里

alex=models.Author.objects.get(name="alex")

print(alex.authordetail.addr) # shahe

#############################多对多查询###########################

正向查询：按字段

例如：查询 python这本书的所有作者的姓名和年龄

book_python=models.Book.objects.get(title="python")

author_list=book_python.authors.all()

for obj in author_list:

           print(obj.name,obj.age)

book_pythons = models.Book.objects.filter(title="python")

for book_python in book_pythons:

           author_list = book_python.authors.all()

           for obj in author_list:

                             print(obj.name, obj.age)

反向查询：按关联的表名（小写）_set

例如：alex出版过的所有书籍的明显名称

alex=models.Author.objects.get(name="alex")

book_list=alex.book_set.all()

for i in book_list:

                    print(i.title,i.price)

（2）基于双下划线的跨表查询

正向查询：按字段

反向查询：按表名

例1：查询python这本书的价格

ret=models.Book.objects.filter(title="python").values("price","title")
print(ret) # <QuerySet [{'price': Decimal('122.00')}]>

例2：查询python这本书的出版社的名称和地址

正向查询 按字段 基于book表
 ret2=models.Book.objects.filter(title="python").values_list("publisher__name")

 反向查询 按表名 if 设置了related_name: 按设置值
 ret3=models.Publish.objects.filter(bookList__price=333).values_list("name","addr").distinct()

 例3：查询人民出版社出版过的所有书籍名称及价格

 ret4=models.Book.objects.filter(publisher__name="renmin").values("title","price")

 ret5=models.Publish.objects.filter(name="renmin").values("bookList__title","bookList__price")

 例4：查询egon出过的所有书籍的名字(多对多)

 ret6=models.Author.objects.filter(name="egon").values_list("book__title")

 ret7=models.Book.objects.filter(authors__name__contains="eg").values("title")

  例5：地址以沙河开头的的作者出版过的所有书籍名称以及出版社名称

 ret8=models.Book.objects.filter(authors__authordetail__addr__startswith="sha").values("title","publisher__name")

 （3）回顾聚合与分组

①、 聚合函数 SUM AVG MIN MAX COUNT
②、聚合函数可以单独使用，不一定要和分组配合使用；只不过聚合函数与group by 搭配
③、 统计每一个部门有多少人： select COUNT(name) from emp group by dep_id
                                                     select book.id ,book.title,count(1) from book join bookAuthor on book.id=bookAuthor.book_id group by book.id,book.title,

单纯聚合函数
计算所有图书的平均价格
ret=models.Book.objects.all().aggregate(priceSum=Sum("price"))
print(ret) # {'priceSum': Decimal('2158.00')}

统计每一本书的作者个数

ret2=models.Book.objects.all().annotate(authors_num=Count("authors")) # QuerySet
print(ret2) # [book_obj1,book_obj2,book_obj3,book_obj4,....]

 for obj in ret2:
　　print(obj.nid,obj.title,obj.authors_num)

查询每一个出版社出版过的所有书籍的总价格

方式1：
 ret3=models.Publish.objects.all().annotate(priceSum=Sum("bookList__price"))

for obj in ret3:
　　 print(obj.id,obj.name,obj.priceSum)

ret4 = models.Publish.objects.all().annotate(priceSum=Sum("bookList__price")).values("name","priceSum")
 print(ret4)

方式2：
ret5=models.Book.objects.all().values("publisher__name").annotate(priceSum=Sum("price")).values("publisher__name","priceSum")
 print(ret5)

（4）F与Q查询

from django.db.models import F,Q

F查询：F（）的实例可以在查询中引用字段，来比较同一个model实例中两个不同字段的值

###################################F查询

ret1=models.Book.objects.filter(comment_num__gt=50)

ret2=models.Book.objects.filter(comment_num__gt=F("read_num")*2)

print(ret2)

models.Book.objects.all().update(price=F("price")+10)

Q查询：在执行复杂的查询语句时使用Q对象比较多

Q对象可以组合&、|、~（取反）等操作符以及使用括号进行分组来编写复杂的对象

################################## Q查询
ret3=models.Book.objects.filter(comment_num__gt=50,read_num__gt=50)

ret3=models.Book.objects.filter(Q(comment_num__gt=100)|Q(read_num__gt=100))

print(ret3)

注意事项

ret3=models.Book.objects.filter(price__lt=100,(Q(comment_num__gt=100)|Q(read_num__gt=100)))