Models
django-model
orm
连接数据库，在settings中： DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME':'day70', 'USER': 'eric', 'PASSWORD': '123123', 'HOST': '192.168.182.128', 'PORT': '3306', } }
映射关系：
python的类名对应的SQL语句的表名
python的类属性对应的SQL语句的表名下的字段
python的类属性的约束对应的SQL语句的表名下的字段类型
创建表（建立模型） 实例：我们来假定下面这些概念，字段和关系 作者模型：一个作者有姓名和年龄； 作者详细模型：把作者的详情放到详情表，包含手机号，家庭住址等信息，
作者详情模型和作者模型之间是一对一的关系（one-to-one） 出版商模型：出版商有名称，地址以及email。 书籍模型：书籍有书名、价格和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，
所以作者和书籍的关系就是多对多的关联关系(many-to-many)
一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)。
模型建立如下：
from django.db import models
# Create your models here.
class Publish(models.Model):
nid=models.AutoField(primary_key=True)
name=models.CharField(max_length=10)
addr=models.CharField(max_length=40)
email=models.EmailField(max_length=20)
def __str__(self): #查看对象名称
return self.name
class Book(models.Model):
nid=models.AutoField(primary_key=True)
title=models.CharField(max_length=30)
price=models.DecimalField(max_digits=5,decimal_places=2)
pubdate=models.DateField()
# 与Publish建立一对多的关系,外键字段建立在多的一方
publish=models.ForeignKey("Publish")
#与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个，
自动创建第三张表
authors= models.ManyToManyField("Author")
def __str__(self):
return self.title
class Author(models.Model):
nid = models.AutoField(primary_key=True)
name=models.CharField(max_length=10)
age=models.IntegerField()
# 与AuthorDetail建立一对一的关系
ad= models.OneToOneField("AuthorDetail")
def __str__(self):
return self.name
class AuthorDetail(models.Model):
nid = models.AutoField(primary_key=True)
tel=models.IntegerField()
email=models.EmailField(max_length=40)
# author=models.OneToOneField("Author")
def __str__(self):
return self.tel,self.email
通过logging可以查看翻译成的sql语句，将logging代码放入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', }, } }
1、 表的名称myapp_modelName，是根据 模型中的元数据自动生成的，也可以覆写为别的名称 2、id 字段是自动添加的 3、对于外键字段，Django 会在字段名上添加"_id" 来创建数据库中的列名 4、这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。 5、定义好模型之后，你需要告诉Django _使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称。 6、外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。
添加表记录
普通字段 方式1： s=Book(title=title,price=price,pubdate=pubdate) s.save() 方式2： book_obj=Book.objects.create(title=title,price=price,pubdate=pubdate)
外键字段（一对多） 方式1： Book.objects.create(title=title, price=price, pubdate=pubdate, publish_id=publish_id) 方式2： pub_obj=Publish.objects.get(nid=publish_id[0]) book_obj=Book.objects.create(title=title,price=price,pubdate=pubdate,publish=pub_obj)
外键字段（多对多）
author_id=request.POST.getlist("author_id")
book_obj=Book.objects.create(title=title, price=price, pubdate=pubdate,
publish_id=publish_id)
for a_id in author_id:
auth=Author.objects.get(nid=a_id)
# 绑定关系1
book_obj.authors.add(auth)
# 追加作者也用add方法
ll=Author.objects.get(name="ll")
book_obj.authors.add(ll)
# 删除一个作者
book_obj.authors.remove(ll)
# 清空所有作者
book_obj.authors.clear()
#绑定关系2
author_id=request.POST.getlist("author_id")
book_obj=Book.objects.create(title=title, price=price, pubdate=pubdate,
publish_id=publish_id)
book_obj.authors.add(*author_id)
# 绑定关系3
book_obj.authors.add(1,2)
book_obj.publish:是与某个书籍对象关联的出版社对象(注意，只有一个对象)
book_obj.authors:是与书籍对象关联的作者对象集(注意，是一个Query set类型)
多表关系及参数 ForeignKey(ForeignObject) # ForeignObject(RelatedField) to, # 要进行关联的表名 to_field=None, # 要关联的表中的字段名称 on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为 - models.CASCADE，删除关联数据，与之关联也删除 - models.DO_NOTHING，删除关联数据，引发错误IntegrityError - models.PROTECT，删除关联数据，引发错误ProtectedError - models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空） - models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值） - models.SET，删除关联数据， a. 与之关联的值设置为指定值，设置：models.SET(值) b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象) def func(): return 10 class MyModel(models.Model): user = models.ForeignKey( to="User", to_field="id" on_delete=models.SET(func),) related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件： # 如： - limit_choices_to={'nid__gt': 5} - limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') db_constraint=True # 是否在数据库中创建外键约束 parent_link=False # 在Admin中是否显示关联数据 OneToOneField(ForeignKey) to, # 要进行关联的表名 to_field=None # 要关联的表中的字段名称 on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为 ###### 对于一对一 ###### # 1. 一对一其实就是 一对多 + 唯一索引 # 2.当两个类之间有继承关系时，默认会创建一个一对一字段 # 如下会在A表中额外增加一个c_ptr_id列且唯一： class C(models.Model): nid = models.AutoField(primary_key=True) part = models.CharField(max_length=12) class A(C): id = models.AutoField(primary_key=True) code = models.CharField(max_length=1) ManyToManyField(RelatedField) to, # 要进行关联的表名 related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件： # 如： - limit_choices_to={'nid__gt': 5} - limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') symmetrical=None, # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段 # 做如下操作时，不同的symmetrical会有不同的可选字段 models.BB.objects.filter(...) # 可选字段有：code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=True) # 可选字段有: bb, code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=False) through=None, # 自定义第三张表时，使用字段用于指定关系表 through_fields=None, # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表 from django.db import models class Person(models.Model): name = models.CharField(max_length=50) class Group(models.Model): name = models.CharField(max_length=128) members = models.ManyToManyField( Person, through='Membership', through_fields=('group', 'person'), ) class Membership(models.Model): group = models.ForeignKey(Group, on_delete=models.CASCADE) person = models.ForeignKey(Person, on_delete=models.CASCADE) inviter = models.ForeignKey( Person, on_delete=models.CASCADE, related_name="membership_invites", ) invite_reason = models.CharField(max_length=64) db_constraint=True, # 是否在数据库中创建外键约束 db_table=None, # 默认创建第三张表时，数据库中表的名称
查询相关API
(1)Student.objects.all() #返回的QuerySet类型 查询所有记录
[obj1,obj2...]
(2)Student.objects.filter() #返回的QuerySet类型 查询所有符合条件的记录 (3)Student.objects.exclude()#返回的QuerySet类型 查询所有不符合条件的记录 (4)Student.objects.get() #返回的models对象 查询结果必须有且只有一个，否则报错 (5)Student.objects.all().first() #返回的models对象 查询结果集合中的第一个 (6)Student.objects.filter().last() #返回的models对象 查询结果集合中的最后一个 (7)Student.objects.all().values("name","class_id") #返回的QuerySet类型,
列表中存放的字典 (8)Student.objects.all().values_list("name","class_id") #返回的QuerySet类型,
列表中存放的元组 (9)Student.objects.all().order_by("class_id") # 按指定字段排序，不指定，按主键排序
(10)Student.objects.all().count() # 返回的记录个数 (11)Student.objects.all().values("name").distinct() #去重 (12)Student.objects.all().exist() #优化查询
(13)Student.objects.all().reverse(): #对查询结果反向排
双下划线的单表查询
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
例如：
# (1)查询所有书籍的名称
obj=Book.objects.values("title")
# list=[]
# for i in obj:
# list.append(i["title"])
list=[i["title"] for i in obj]
print(list)
return HttpResponse("OK")
# (2)查询价格大于100的书籍名称以及价格
obj=Book.objects.filter(price__gt=100).values("title","price")
print(obj)
return HttpResponse("OK")
# (3)查询2017年出版的所有以py开头的书籍名称
obj=Book.objects.filter(pubdate__year=2017,title__istartswith="py")
.values("title")
print(obj)
return HttpResponse("OK")
# (4)查询价格为50, 100或者150的所有书籍名称及其出版社名称
obj=Book.objects.filter(price__in=[50.00,100.00,150.00])
.values("title","publisher")
print(obj)
return HttpResponse("OK")
# (5)查询所有主键大于2小于5书籍的价格（去重）
obj=Book.objects.filter(nid__range=[2,5]).values("title").distinct()
.values("title","price")
obj=Book.objects.filter(nid__range=[2,5])
.values("title","price").distinct()
print(obj)
return HttpResponse("OK")
# (6)查询所有人民出版社出版的书籍的价格（从高到低排序，去重）
obj=Book.objects.filter(publisher="人民出版社")
.values("title","price").distinct()
print(obj)
基于对象跨表查询（子查询）
一对多跨表查询 Book(多)--------->Publish(一) book_obj.publish (关联字段) Publish(一)------->Book(多) publish_obj.book_set.all() （表名） 例如： 查询python这本书的出版社的名字 （正向查询，按字段） book_obj=Book.objects.get(title="python") print(book_obj.publish.name) 查询沙河出版社出版过的书籍名称 (反向查询按:表名_set) pub_obj=Publish.objects.get(name="人民出版社") print(pub_obj.book_set.all()) 多对多跨表查询 Book------->Author book_obj.authors.all() (关联字段) Author----->Book author_obj.book_set.all() (表名) 查询python这本书的所有作者的名字 （正向查询，按字段） book_obj=Book.objects.get(title="python") print(book_obj.authors.all()) 查询aa出版过的所有书籍(反向查询按:表名_set) author_obj=Author.objects.get(name="alex") print(author_obj.book_set.all()) # <QuerySet [<Book: 画图>, <Book:画图>]>
一对一跨表查询
Author---------->AuthorDetail author_obj.ad (关联字段)
AuthorDetail---->Author authordetail_obj.author (表名)
例如：
查询email是12333@qq.com的作者的名字 （正向查询，按字段）
authordetail_obj=AuthorDetail.objects.get(email=12333@qq.com)
print(authordetail_obj.ad.name)
查询jenny的email (反向查询按:表名)
jenny=Author.objects.get(name="jenny")
print(jenny.authordetail.email) # 12333@qq.com
# 查询住在沙河的作者出版过的所有书籍的名称以及出版社名称
book_obj=AuthorDetail.objects.get(addr="沙河").nid.book_set.all()
for obj in book_obj:
print(obj.title,obj.publish.name)
基于双下划线查询（join查询）
基于双下划线的查询：正向查询，按字段；反向查询，按表名 例如： # 查询沙河出版社出版过的书籍名称
方式1：
ret=Publish.objects.filter(name="人民出版社").values("book__title") print(ret)
方式2：: Book.objects.filter(publish__name="人民出版社").values("title") # email以456开头的作者出版过的所有书籍名称以及出版社名称 ret=Book.objects.filter(authors__ad__email__startswith="456")
.values("title","publish__name") print(ret)
#查询人民出版社出版过的所有书籍的名字与价格(一对多)
# 正向查询 按字段:publish
queryResult=Book.objects
.filter(publish__name="人民出版社")
.values_list("title","price")
# 反向查询 按表名:book
queryResult=Publish.objects
.filter(name="人民出版社")
.values_list("book__title","book__price")
#查询egon出过的所有书籍的名字(多对多)
# 正向查询 按字段:authors:
queryResult=Book.objects
.filter(authors__name="yuan")
.values_list("title")
# 反向查询 按表名:book
queryResult=Author.objects
.filter(name="yuan")
.values_list("book__title","book__price")
#查询人民出版社出版过的所有书籍的名字以及作者的姓名
# 正向查询
queryResult=Book.objects
.filter(publish__name="人民出版社")
.values_list("title","authors__name")
# 反向查询
queryResult=Publish.objects
.filter(name="人民出版社")
.values_list("book__title","book__authors__age",
"book__authors__name")
#手机号以151开头的作者出版过的所有书籍名称以及出版社名称
queryResult=Book.objects
.filter(authors__authorDetail__telephone__regex="151")
.values_list("title","publish__name"
聚合查询与分组查询
聚合查询 聚合：aggregate(*args, **kwargs) # 计算所有图书的平均价格 from django.db.models import Avg Book.objects.all().aggregate(Avg('price')) 结果：{'price__avg': 34.35}
aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典；
键的名称是聚合值的标识符，值是计算出来的聚合值；
键的名称是按照字段和聚合函数的名称自动生成出来的；
为聚合值指定一个名称：Book.objects.aggregate(average_price=Avg('price'))
如果希望生成不止一个聚合，可以向aggregate()子句中添加另一个参数；
想知道所有图书价格的最大值和最小值，可以这样查询：
from django.db.models import Avg, Max, Min
Book.objects.aggregate(Avg('price'), Max('price'), Min('price')){'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}分组查询：annotate()
为调用的QuerySet中每一个对象都生成一个独立的统计值（统计方法用聚合函数）
# 统计每一本书的作者个数
bookList=Book.objects.annotate(authorsNum=Count('authors')) for book_obj in bookList: print(book_obj.title,book_obj.authorsNum)
SELECT "app01_book"."nid", "app01_book"."title", "app01_book"."publishDate", "app01_book"."price", "app01_book"."publish_id", COUNT("app01_book_authors"."author_id") AS "authorsNum" FROM "app01_book" LEFT OUTER JOIN "app01_book_authors" ON ("app01_book"."nid" = "app01_book_authors"."book_id") GROUP BY "app01_book"."nid", "app01_book"."title", "app01_book"."publishDate", "app01_book"."price", "app01_book"."publish_id"
解析： Book.objects.annotate(authorsNum=Count('authors')) 拆分解析： Book.objects等同于Book.objects.all(),翻译成的sql类似于：
select id,name,.. from Book 这样得到的对象一定是每一本书对象，有n本书籍记录，就分n个组，
不会有重复对象，每一组再由annotate分组统计。
跨表查询示例
# 1、查询人民出版社出版过的价格大于100的书籍的作者的email # 基于对象： # li=[] # pub_obj=Publish.objects.get(name="人民出版社") # book_obj=pub_obj.book_set.filter(price__gt=100) # for book in book_obj: # auth_list=book.authors.all() # for auth in auth_list: # li.append(auth.ad.email) # print(set(li)) # {'12555@qq.com', '25555@qq.com', '12333@qq.com'} # 基于双下划线： # ret=Book.objects.filter(publish__name="人民出版社",price__gt=100).values("authors__ad__email").distinct() # print(ret) # < QuerySet[{'authors__ad__email': '12555@qq.com'}, {'authors__ad__email': '25555@qq.com'}, { # 'authors__ad__email': '12333@qq.com'}] > # 2、查询alex出版过的所有书籍的名称以及书籍的出版社的名称 # 基于对象： # jenny=Author.objects.get(name="jenny") # book_list=jenny.book_set.all() # for book_obj in book_list: # print(book_obj.title,book_obj.publish.name) # 呐喊 人民出版社 # 三国演义 新华出版社 # 狂人日记 人民出版社 # 阿Q正传 人民教育出版社 # 基于双下划线： # ret=Book.objects.filter(authors__name="jenny").values("title","publish__name") # print(ret) # < QuerySet[{'title': '呐喊', 'publish__name': '人民出版社'}, {'title': '三国演义', 'publish__name': '新华出版社'}, {'title': '狂人日记', 'publish__name': '人民出版社'}, { # 'title': '阿Q正传', 'publish__name': '人民教育出版社'}] > # 3、查询2011年出版社过的所有书籍的作者名字以及出版社名称 # 基于对象： # book_list=Book.objects.filter(pubdate__year=2011) # for book_obj in book_list: # print(book_obj.publish.name) # auth_list=book_obj.authors.all() # for auth in auth_list: # print(auth) # 基于双下划线： # ret=Book.objects.filter(pubdate__year=2011).values("publish__name","authors__name") # print(ret) # # < QuerySet[ # {'publish__name': '新华出版社', 'authors__name': 'steven'}, {'publish__name': '新华出版社', 'authors__name': 'jenny'}, { # 'publish__name': '人民教育出版社', 'authors__name': 'steven'}, {'publish__name': '人民教育出版社', # 'authors__name': 'jenny'}, { # 'publish__name': '人民教育出版社', 'authors__name': 'cc'}, {'publish__name': '人民出版社', # 'authors__name': 'steven'}, { # 'publish__name': '人民出版社', 'authors__name': 'cc'}] > # 4、查询(住在沙河)tel以666结尾并且email以123开头的作者写过的所有书籍名称以及书籍的出版社名称 # 基于对象： # auth_obj=AuthorDetail.objects.filter(tel__endswith=666,email__startswith=123)[0].author # book_list=auth_obj.book_set.all() # for book_obj in book_list: # print(book_obj.title,book_obj.publish.name) # 呐喊 人民出版社 # 狂人日记 人民出版社 # 三国演义 新华出版社 # 阿Q正传 人民教育出版社 # 基于双下划线： # ret=Book.objects.filter(authors__ad__email__istartswith=123,authors__ad__tel__endswith=666).values("title","publish__name") # print(ret) # < QuerySet[{'title': '呐喊', 'publish__name': '人民出版社'}, {'title': '狂人日记', 'publish__name': '人民出版社'}, {'title': '三国演义', # 'publish__name': '新华出版社'}, { 'title': '阿Q正传', 'publish__name': '人民教育出版社'}] > # 5、查询年龄大于20岁的作者在哪些出版社出版过书籍 # 基于对象： # auth_list = Author.objects.filter(age__gt=20) # # print(auth_list) # li = [] # for auth in auth_list: # book_list = auth.book_set.all() # for book_obj in book_list: # li.append(book_obj.publish.name) # print(set(li)) # {'新华出版社', '人民出版社', '人民教育出版社'} # 基于双下划线： # ret = Book.objects.filter(authors__age__gt=20).values("publish__name").distinct() # print(ret) # < QuerySet[{'publish__name': '人民出版社'}, {'publish__name': '新华出版社'}, {'publish__name': '人民教育出版社'}] > # 6、查询每一个出版社的名称以及出版过的书籍个数 from django.db.models import Max,Count # ret=Publish.objects.all().annotate(c=Count("book__title")).values("name","c") # print(ret) # < QuerySet[{'name': '人民出版社', 'c': 7}, {'name': '人民教育出版社', 'c': 1}, {'name': '新华出版社', 'c': 1}, {'name': '北京大学出版社', 'c': 1}] > # 7、查询每一个作者的名字以及出版过的所有书籍的最高价格 # ret=Author.objects.all().annotate(pri=Max("book__price")).values("name","pri") # print(ret) # < QuerySet[{'name': 'steven', 'pri': Decimal('120.00')}, {'name': 'jenny', 'pri': Decimal('120.00')}, {'name': 'cc', 'pri': Decimal('110.00')}] > # 8、查询每一本书的名字，对应出版社名称以及作者的个数 ret=Book.objects.all().annotate(counts=Count("authors__nid")).values("title","publish__name","counts") print(ret) return HttpResponse("OK")
F,Q查询
F查询（只对int类型有作用）
F()的实例可以在查询中引用字段，来比较同一个 model 实例中两个不同字段的值。
# 查询评论数大于收藏数的书籍 from django.db.models import F Book.objects.filter(commnetNum__lt=F('keepNum')) Django支持F()对象之间以及 F() 对象和常数之间的加减乘除和取模的操作。
# 查询评论数大于收藏数2倍的书籍 Book.objects.filter(commnetNum__lt=F('keepNum')*2) #修改操作也可以使用F函数,比如将每一本书的价格提高30元：
Book.objects.all().update(price=F("price")+30) Q查询
filter()等方法中的关键字参数查询都是一起进行“AND”的，如果你需要执行更复杂的查询（例如OR语句，可使用Q对象：
from django.db.models import Q Q(title__startswith='Py')Q对象可以使用&和|操作符组合起来，当一个操作符在两个Q对象上使用时，它产生一个新的Q对象：
bookList=Book.objects.filter(Q(authors__name="yuan")|Q(authors__name="egon"))等同于：
WHERE name ="yuan" OR name ="egon"
可以组合&和|操作符以及使用括号进行分组来编写任意复杂的Q对象。同时，Q对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询：
bookList=Book.objects.filter(Q(authors__name="yuan") &
~Q(publishDate__year=2017)).values_list("title")
查询函数可以混合使用Q 对象和关键字参数；
所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起；
如果出现Q对象，它必须位于所有关键字参数的前面；例如：
bookList=Book.objects.filter(Q(publishDate__year=2016) | Q(publishDate__year=2017),title__icontains="python")
修改表记录
第一种方法： author=Author.objects.get(id=2) author.name="aaa" author.save() 第二种方法： Publish.objects.filter(id=2).update(name='American publish') 不能用get(id=2) 结论： （1）第二种方式修改不能用get的原因是：update是QuerySet对象的方法，
get返回的是一个model对象，它没有update方法，而filter返回的
是一个QuerySet对象(filter里面的条件可能有多个条件符合，比如
name＝'alvin',可能有两个name＝'alvin'的行数据)； （2）在“插入和更新数据”中，有提到模型的save()方法，这个方法会更新
一行里的所有列。 而某些情况下，我们只需要更新行里的某几列； （3）update()方法对于任何结果集（QuerySet）均有效，这意味着可以
同时更新多条记录update()方法会返回一个整型数值，表示受影响的
记录条数； （4）update返回的是一个整形，所以没法用query属性；对于每次创建一
个对象，想显示对应的raw sql，需要在settings加上日志记录部分。
删除表记录
删除方法就是 delete()，运行时立即删除对象而不返回任何值： e.delete() 可以一次性删除多个对象,每个QuerySet都有一个delete()方法，
它一次性删除QuerySet中所有的对象;
例如，下面的代码将删除 pub_date 是2017年的Entry对象： Entry.objects.filter(pubdate__year=2017).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() 如果不想级联删除，可以设置为： pubHouse = models.ForeignKey(to='Publisher',
on_delete=models.SET_NULL, blank=True, null=True)
浙公网安备 33010602011771号