django（七）之数据库表的单表-增删改查QuerySet，双下划线
https://www.cnblogs.com/haiyan123/p/7738435.html
https://www.cnblogs.com/yuanchenqi/articles/6083427.htm
一、添加表记录
对于单表有两种方式
# 添加数据的两种方式 # 方式一：实例化对象就是一条表记录 Frank_obj = models.Student(name ="海东",course="python",birth="2000-9-9",fenshu=80) Frank_obj.save() # 方式二： models.Student.objects.create(name ="alex",course="python",birth="1995-5-9",fenshu=88)
二、查询表记录
查询相关API
# 查询相关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():
双下划线之单表查询
models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id小于1 且 大于10的值 models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据 models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in models.Tb1.objects.filter(name__contains="ven") #包括ven的 models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and startswith，istartswith, endswith, iendswith
对象可以调用自己的属性，用一个点就可以 还可以通过双下划线。。。 models.Book.objects.filter(price__gt=100) 价格大于100的书 models.Book.objects.filter(author__startwith= "张") 查看作者的名字是以张开头的 主键大于5的且小于2 price__gte=99大于等于 publishDate__year =2017,publishDate__month = 10 查看2017年10月份的数据
from django.shortcuts import render,HttpResponse # Create your views here. from app01.models import * def index(request): return render(request,"index.html") def addbook(request): # b=Book(name="python基础",price=99,author="yuan",pub_date="2017-12-12") # b.save() Book.objects.create(name="老男孩linux",price=78,author="oldboy",pub_date="2016-12-12") #Book.objects.create(**dic) return HttpResponse("添加成功") def update(request): Book.objects.filter(author="yuan").update(price=999) # b=Book.objects.get(author="oldboy") # b.price=120 # b.save() # print(b)#<QuerySet [<Book: Book object>]> # print(type(b)) return HttpResponse("修改成功！") def delete(req): Book.objects.filter(author="oldboy").delete() return HttpResponse("success") def select(req): # book_list=Book.objects.all() # print(book_list) # print(book_list[0])#Book object # book_list = Book.objects.filter(id=2) # book_list = Book.objects.all()[::2] # 步长 # book_list = Book.objects.all()[::-1] # 倒序 # book_list = Book.objects.first() # book_list = Book.objects.last() # book_list = Book.objects.get(id=2)#只能取出一条记录时才不报错 # ret1=Book.objects.filter(author="oldboy").values("name") # ret2=Book.objects.filter(author="yuan").values_list("name","price") # book_list=Book.objects.exclude(author="yuan").values("name","price") # print(ret1) # print(ret2) # book_list= Book.objects.all().values("name").distinct() # book_count= Book.objects.all().values("name").distinct().count() # print(book_count) #万能的 __ # book_list=Book.objects.filter(price__gt=50).values("name","price") book_list=Book.objects.filter(name__contains="P").values_list("name","price") return render(req,"index.html",{"book_list":book_list})
表(模型)的创建：
实例：我们来假定下面这些概念，字段和关系
作者模型：一个作者有姓名。
作者详细模型：把作者的详情放到详情表，包含性别，email地址和出生日期，作者详情模型和作者模型之间是一对一的关系（one－to－one）（类似于每个人和他的身份证之间的关系），在大多数情况下我们没有必要将他们拆分成两张表，这里只是引出一对一的概念。
出版商模型：出版商有名称，地址，所在城市，省，国家和网站。
书籍模型：书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系（many－to－many），一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系（one－to－many），也被称作外键。
from django.db import models<br> class Publisher(models.Model): name = models.CharField(max_length=30, verbose_name="名称") address = models.CharField("地址", max_length=50) city = models.CharField('城市',max_length=60) state_province = models.CharField(max_length=30) country = models.CharField(max_length=50) website = models.URLField() class Meta: verbose_name = '出版商' verbose_name_plural = verbose_name def __str__(self): return self.name class Author(models.Model): name = models.CharField(max_length=30) def __str__(self): return self.name class AuthorDetail(models.Model): sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),)) email = models.EmailField() address = models.CharField(max_length=50) birthday = models.DateField() author = models.OneToOneField(Author) class Book(models.Model): title = models.CharField(max_length=100) authors = models.ManyToManyField(Author) publisher = models.ForeignKey(Publisher) publication_date = models.DateField() price=models.DecimalField(max_digits=5,decimal_places=2,default=10) def __str__(self): return self.title
分析代码：
<1> 每个数据模型都是django.db.models.Model的子类，它的父类Model包含了所有必要的和数据库交互的方法。并提供了一个简介漂亮的定义数据库字段的语法。
<2> 每个模型相当于单个数据库表（多对多关系例外，会多生成一张关系表），每个属性也是这个表中的字段。属性名就是字段名，它的类型（例如CharField）相当于数据库的字段类型（例如varchar）。大家可以留意下其它的类型都和数据库里的什么字段对应。
<3> 模型之间的三种关系：一对一，一对多，多对多。
一对一：实质就是在主外键（author_id就是foreign key）的关系基础上，给外键加了一个UNIQUE＝True的属性；
一对多：就是主外键关系；（foreign key）
多对多：(ManyToManyField) 自动创建第三张表(当然我们也可以自己创建第三张表：两个foreign key)
-------------------------------------增(create , save) -------------------------------
from app01.models import * #create方式一: Author.objects.create(name='Alvin') #create方式二: Author.objects.create(**{"name":"alex"}) #save方式一: author=Author(name="alvin") author.save() #save方式二: author=Author() author.name="alvin" author.save()
重点来了－－－－－－－>那么如何创建存在一对多或多对多关系的一本书的信息呢？(如何处理外键关系的字段如一对多的publisher和多对多的authors)
#一对多(ForeignKey): #方式一: 由于绑定一对多的字段,比如publish,存到数据库中的字段名叫publish_id,所以我们可以直接给这个 # 字段设定对应值: Book.objects.create(title='php', publisher_id=2, #这里的2是指为该book对象绑定了Publisher表中id=2的行对象 publication_date='2017-7-7', price=99) #方式二: # <1> 先获取要绑定的Publisher对象: pub_obj=Publisher(name='河大出版社',address='保定',city='保定', state_province='河北',country='China',website='http://www.hbu.com') OR pub_obj=Publisher.objects.get(id=1) # <2>将 publisher_id=2 改为 publisher=pub_obj #多对多(ManyToManyField()): author1=Author.objects.get(id=1) author2=Author.objects.filter(name='alvin')[0] book=Book.objects.get(id=1) book.authors.add(author1,author2) #等同于: book.authors.add(*[author1,author2]) book.authors.remove(*[author1,author2]) #------------------- book=models.Book.objects.filter(id__gt=1) authors=models.Author.objects.filter(id=1)[0] authors.book_set.add(*book) authors.book_set.remove(*book) #------------------- book.authors.add(1) book.authors.remove(1) authors.book_set.add(1) authors.book_set.remove(1) #注意: 如果第三张表是通过models.ManyToManyField()自动创建的,那么绑定关系只有上面一种方式 # 如果第三张表是自己创建的: class Book2Author(models.Model): author=models.ForeignKey("Author") Book= models.ForeignKey("Book") # 那么就还有一种方式: author_obj=models.Author.objects.filter(id=2)[0] book_obj =models.Book.objects.filter(id=3)[0] s=models.Book2Author.objects.create(author_id=1,Book_id=2) s.save() s=models.Book2Author(author=author_obj,Book_id=1) s.save()
-----------------------------------------删（delete） ---------------------------------------------
删除方法就是 delete()。它运行时立即删除对象而不返回任何值。例如：e.delete()
def delstudent(request,id): # 删除数据 models.Student.objects.filter(nid=id).delete() return redirect("/test/")
你也可以一次性删除多个对象。每个 QuerySet 都有一个 delete() 方法，它一次性删除 QuerySet 中所有的对象。
例如，下面的代码将删除 pub_date 是2005年的 Entry 对象：
Entry.objects.filter(pub_date__year=2005).delete()
要牢记这一点：无论在什么情况下，QuerySet 中的 delete() 方法都只使用一条 SQL 语句一次性删除所有对象，而并不是分别删除每个对象。如果你想使用在 model 中自定义的 delete() 方法，就要自行调用每个对象的delete 方法。(例如，遍历 QuerySet，在每个对象上调用 delete()方法)，而不是使用 QuerySet 中的 delete()方法。
在 Django 删除对象时，会模仿 SQL 约束 ON DELETE CASCADE 的行为，换句话说，删除一个对象时也会删除与它相关联的外键对象。例如：
b = Blog.objects.get(pk=1) # This will delete the Blog and all of its Entry objects. b.delete()
要注意的是： delete() 方法是 QuerySet 上的方法，但并不适用于 Manager 本身。这是一种保护机制，是为了避免意外地调用 Entry.objects.delete() 方法导致 所有的 记录被误删除。如果你确认要删除所有的对象，那么你必须显式地调用：
Entry.objects.all().delete()
-----------------------------------------改（update和save） ----------------------------------------
实例：
注意：
<1> 第二种方式修改不能用get的原因是：update是QuerySet对象的方法，get返回的是一个model对象，它没有update方法，而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合，比如name＝'alvin',可能有两个name＝'alvin'的行数据)。
<2>在“插入和更新数据”小节中，我们有提到模型的save()方法，这个方法会更新一行里的所有列。 而某些情况下，我们只需要更新行里的某几列。
#---------------- update方法直接设定对应属性---------------- models.Book.objects.filter(id=3).update(title="PHP") ##sql: ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3) #--------------- save方法会将所有属性重新设定一遍,效率低----------- obj=models.Book.objects.filter(id=3)[0] obj.title="Python" obj.save() # SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", # "app01_book"."color", "app01_book"."page_num", # "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; # # UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556, # "publisher_id" = 1 WHERE "app01_book"."id" = 3;
在这个例子里我们可以看到Django的save()方法更新了不仅仅是title列的值，还有更新了所有的列。 若title以外的列有可能会被其他的进程所改动的情况下，只更改title列显然是更加明智的。更改某一指定的列，我们可以调用结果集（QuerySet）对象的update()方法,与之等同的SQL语句变得更高效，并且不会引起竞态条件。
此外，update()方法对于任何结果集（QuerySet）均有效，这意味着你可以同时更新多条记录update()方法会返回一个整型数值，表示受影响的记录条数。
注意，这里因为update返回的是一个整形，所以没法用query属性；对于每次创建一个对象，想显示对应的raw sql，需要在settings加上日志记录部分
LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console':{ 'level':'DEBUG', 'class':'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'propagate': True, 'level':'DEBUG', }, } } LOGGING
---------------------------------------查（filter，value等) -------------------------------------
---------->查询API：
# 查询相关API： # <1>filter(**kwargs): 它包含了与所给筛选条件相匹配的对象 # <2>all(): 查询所有结果 # <3>get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。 #-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()-------- # <4>values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列 # <5>exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象 # <6>order_by(*field): 对查询结果排序 # <7>reverse(): 对查询结果反向排序 # <8>distinct(): 从返回结果中剔除重复纪录 # <9>values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列 # <10>count(): 返回数据库中匹配查询(QuerySet)的对象数量。 # <11>first(): 返回第一条记录 # <12>last(): 返回最后一条记录 # <13>exists(): 如果QuerySet包含数据，就返回True，否则返回False。
补充：
#扩展查询,有时候DJANGO的查询API不能方便的设置查询条件，提供了另外的扩展查询方法extra: #extra(select=None, where=None, params=None, tables=None,order_by=None, select_params=None (1) Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"}) (2) Blog.objects.extra( select=SortedDict([('a', '%s'), ('b', '%s')]), select_params=('one', 'two')) (3) q = Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"}) q = q.extra(order_by = ['-is_recent']) (4) Entry.objects.extra(where=['headline=%s'], params=['Lennon']) extra
--------->惰性机制：
所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。
QuerySet特点：
<1> 可迭代的
<2> 可切片
#objs=models.Book.objects.all()#[obj1,obj2,ob3...] #QuerySet: 可迭代 # for obj in objs:#每一obj就是一个行对象 # print("obj:",obj) # QuerySet: 可切片 # print(objs[1]) # print(objs[1:4]) # print(objs[::-1])
QuerySet的高效使用：
<1>Django的queryset是惰性的 Django的queryset对应于数据库的若干记录（row），通过可选的查询来过滤。例如，下面的代码会得 到数据库中名字为‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave") 上面的代码并没有运行任何的数据库查询。你可以使用person_set，给它加上一些过滤条件，或者将它传给某个函数， 这些操作都不会发送给数据库。这是对的，因为数据库查询是显著影响web应用性能的因素之一。 <2>要真正从数据库获得数据，你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql. 为了验证这些,需要在settings里加入 LOGGING(验证方式) obj=models.Book.objects.filter(id=3) # for i in obj: # print(i) # if obj: # print("ok") <3>queryset是具有cache的 当你遍历queryset时，所有匹配的记录会从数据库获取，然后转换成Django的model。这被称为执行 （evaluation）.这些model会保存在queryset内置的cache中，这样如果你再次遍历这个queryset， 你不需要重复运行通用的查询。 obj=models.Book.objects.filter(id=3) # for i in obj: # print(i) ## models.Book.objects.filter(id=3).update(title="GO") ## obj_new=models.Book.objects.filter(id=3) # for i in obj: # print(i) #LOGGING只会打印一次 <4> 简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些 数据！为了避免这个，可以用exists()方法来检查是否有数据： obj = Book.objects.filter(id=4) # exists()的检查可以避免数据放入queryset的cache。 if obj.exists(): print("hello world!") <5>当queryset非常巨大时，cache会成为问题 处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统 进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法 来获取数据，处理完数据就将其丢弃。 objs = Book.objects.all().iterator() # iterator()可以一次只从数据库获取少量数据，这样可以节省内存 for obj in objs: print(obj.name) #BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了 for obj in objs: print(obj.name) #当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使 #用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询 总结: queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。 使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能 会造成额外的数据库查询。
---------->对象查询，单表条件查询，多表条件关联查询
#--------------------对象形式的查找-------------------------- # 正向查找 ret1=models.Book.objects.first() print(ret1.title) print(ret1.price) print(ret1.publisher) print(ret1.publisher.name) #因为一对多的关系所以ret1.publisher是一个对象,而不是一个queryset集合 # 反向查找 ret2=models.Publish.objects.last() print(ret2.name) print(ret2.city) #如何拿到与它绑定的Book对象呢? print(ret2.book_set.all()) #ret2.book_set是一个queryset集合 #---------------了不起的双下划线(__)之单表条件查询---------------- # models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 # # models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # # models.Tb1.objects.filter(name__contains="ven") # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感 # # models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and # # startswith，istartswith, endswith, iendswith, #----------------了不起的双下划线(__)之多表条件关联查询--------------- # 正向查找(条件) # ret3=models.Book.objects.filter(title='Python').values('id') # print(ret3)#[{'id': 1}] #正向查找(条件)之一对多 ret4=models.Book.objects.filter(title='Python').values('publisher__city') print(ret4) #[{'publisher__city': '北京'}] #正向查找(条件)之多对多 ret5=models.Book.objects.filter(title='Python').values('author__name') print(ret5) ret6=models.Book.objects.filter(author__name="alex").values('title') print(ret6) #注意 #正向查找的publisher__city或者author__name中的publisher,author是book表中绑定的字段 #一对多和多对多在这里用法没区别 # 反向查找(条件) #反向查找之一对多: ret8=models.Publisher.objects.filter(book__title='Python').values('name') print(ret8)#[{'name': '人大出版社'}] 注意,book__title中的book就是Publisher的关联表名 ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors') print(ret9)#[{'book__authors': 1}, {'book__authors': 2}] #反向查找之多对多: ret10=models.Author.objects.filter(book__title='Python').values('name') print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}] #注意 #正向查找的book__title中的book是表名Book #一对多和多对多在这里用法没区别
注意：条件查询即与对象查询对应，是指在filter，values等方法中的通过__来明确查询条件。
编辑表格中的内容的涉及到的语法
编辑操作涉及到的语法 分析： 1、点击编辑，让跳转到另一个页面，拿到我点击的那一行 两种取id值的方式 方式一： 利用数据传参数（作为数据参数传过去了） <a href="/edit/?book_id = {{book_obj.nid}}"></a> #相当于发了一个键值对 url里面就不用写匹配的路径了， id = request.GET.get("book_id") #取值 方式二： 利用路径传参，得在url里面加上（\d+）,就得给函数传个参数，无名分组从参数里面取值 <a href="/{{book_obj.nid}}"></a> 2、拿到id，然后在做筛选 id = request.GET.get("book_id") book_obj = models.Book.objects.filter(nid=id) #拿到的是一个列表对象 注意： 1.取[0]就拿到对象了，，然后对象.属性就可以取到值了 2.用get，你取出来的数据必须只有一条的时候，，如果有多条用get就会报错，，，但是用get就不用加[0]了 book_obj = models.Book.objects.filter(nid=id)[0] 3、当点击编辑的时候怎么让input框里显示文本内容 value = "{{book_obj.title}}" 4、改完数据后重新提交 当提交的时候走action...../edit/} 隐藏一个input, <input type="hidden" name = "book_id" value="{{book_obj.nid}}"> 判断post的时候： 修改数据 方式一：save（这种方式效率是非常低的，不推荐使用，了解就行了） 修改的前提是先取(拿到要编辑的id值) id = request.POST.get("book_id") bk_obj = models.Book.objects.filter(nid=id)[0] bk_obj.title = "hhhhhh" #这是写死了，不能都像这样写死了 bk_obj.save() 只要是用对象的这种都要.save 方式二：update title = request.POST.get("title") models.Book.objects.filter(nid=id).update(title=title,......) 跳转到index 如果是post请求的时候怎么找到id呢， 一、如果是数据传参：(也就是get请求的时候) 可以通过一个隐藏的input框，给这个框给一个name属性，value属性。通过request.POST.get("键")，，就可以得到id的值 二、如果是路径传参 可以通过传参的形式，当正则表达式写一个(\d+)的时候，就给函数传一个id,可通过这个id知道id.
