前戏
在我们之前操作ORM中，你也许是启动Django项目，通过地址访问固定的函数，或者在pycharm里的python console里执行，第一种比较麻烦，而且每次都要启动项目，写路由，第二种虽然不需要写路由，但是写的东西保存不下来，只要关闭就没有了。今天来通过python脚本的形式来写，既不需要启动项目，也可以保存
在项目下面创建一个python文件，里面写如下代码
import osif __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "项目名.settings")
import django
django.setup() from appTest01 import models # 导入视图函数
obj = models.Person.objects.all()
print(obj)
这样我们就可以写ORM语句，只需要右键运行就可以了
如果想查看ORM转为的SQL语句，只需要在项目的settings.py里写如下代码就可以把SQL语句打印到控制台上
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'handlers': {
'console':{
'level':'DEBUG',
'class':'logging.StreamHandler',
},
},
'loggers': {
'django.db.backends': {
'handlers': ['console'],
'propagate': True,
'level':'DEBUG',
},
}
}
ORM常用查询
数据库里数据如下
import osif __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_project.settings")
import django django.setup() from appTest01 import models # all() 查询所有结果，返回的是对象列表。如果要获取对应的字段值，先取索引，在用.字段名
# 比如下面的要获取第二个姓名，ret[1].name
ret = models.Person.objects.all()
# print(ret) <QuerySet [<Person: Person object>, <Person: Person object>, <Person: Person object>]> # get() 查询到的是对象，有且只能有一个，要不然会报错，要获取对应的字段值直接用.
# 比如下面的要获取姓名，ret.name
ret = models.Person.objects.get(id=1)
# print(ret) Person object # filter() 查询出满足条件的对象，返回的是对象列表，获取对应的值也要使用索引的方式
ret = models.Person.objects.filter(id=1)
# print(ret) <QuerySet [<Person: Person object>]> # exclude() 查询出所有不满足条件的对象，返回的是对象列表，获取对应的值也要使用索引的方式
ret = models.Person.objects.exclude(id=1)[1]
# print(ret.name) 王五 # value() 具体的数据，没有指定参数，获取所有的字段数据，指定参数，获取指定字段数据
ret = models.Person.objects.values()
# for i in ret:
# print(i)
'''
{'id': 1, 'name': 'zouzou', 'age': 25, 'birth': datetime.datetime(2019, 7, 19, 15, 7, 15, 296496, tzinfo=<UTC>)}
{'id': 2, 'name': '张三', 'age': 43, 'birth': datetime.datetime(2019, 7, 20, 14, 4, 4, tzinfo=<UTC>)}
{'id': 3, 'name': '王五', 'age': 23, 'birth': datetime.datetime(2019, 7, 28, 14, 4, 23, tzinfo=<UTC>)}
''' # values_list() 具体的数据，没有指定参数，获取所有的字段数据，指定参数，获取指定字段数据
ret = models.Person.objects.values_list()
# for i in ret:
# print(i)
'''
(1, 'zouzou', 25, datetime.datetime(2019, 7, 19, 15, 7, 15, 296496, tzinfo=<UTC>))
(2, '张三', 43, datetime.datetime(2019, 7, 20, 14, 4, 4, tzinfo=<UTC>))
(3, '王五', 23, datetime.datetime(2019, 7, 28, 14, 4, 23, tzinfo=<UTC>))
''' # order_by() 对查询结果排序,前面加-表示降序，不写表示升序
# 可以指定多个字段，如果第一个字段相同，则以第二个排，以此类推
ret = models.Person.objects.all().order_by('-id')[0]
# print(ret.id) 3 # reverse() 对查询结果反向排序，请注意reverse()通常只能在具有已定义顺序的QuerySet上调用(在model类的Meta中指定ordering或调用order_by()方法)
# ordering=('id',)
ret = models.Person.objects.all().order_by('-id').reverse()[0]
# print(ret.id) 1 # distinct() 去重 从返回结果中剔除重复纪录(如果你查询跨越多个表，可能在计算QuerySet时得到重复的结果。此时可以使用distinct()，注意只有在PostgreSQL中支持按字段去重。) # count() 计数
ret = models.Person.objects.all().count()
# print(ret) 3 # first() 返回第一条记录,取值不需要按索引
ret = models.Person.objects.all().first()
# print(ret.name) zouzou # last() 返回最后一条记录,取值不需要按索引
ret = models.Person.objects.all().last()
# print(ret.name) 王五 # exists() 如果QuerySet包含数据，就返回True，否则返回False
ret = models.Person.objects.filter(name='赵六').exists()
# print(ret) False
总结：
返回QuerySet对象的方法有
all()
filter()
exclude()
order_by()
reverse()
distinct()
特殊的QuerySet
values() 返回一个可迭代的字典序列
values_list() 返回一个可迭代的元组序列
返回具体对象的
get()
first()
last()
返回布尔值的
exists()
返回数字的
count()
双下划线方法
前面的都是查询某个值等于什么什么的。但是我们经常会查询大于多少，比如成绩大于60分的，这时候就要用到双下滑线方法了
ret = models.Person.objects.filter(id__gt=1) # id大于1ret = models.Person.objects.filter(id__gte=1) # id大于等于1ret = models.Person.objects.filter(id__lt=3) # id小于3ret = models.Person.objects.filter(id__lte=3) # id小于等于3ret = models.Person.objects.filter(id__in=[1, 3]) # id为1和3的ret = models.Person.objects.filter(id__gte=1, id__lte=3) # id大于等于1并且小于等于3的
ret = models.Person.objects.filter(id__range=[1,3]) # id大于等于1并且小于等于3的ret = models.Person.objects.filter(name__contains='u') # name里包含字母u的，区分大小写
ret = models.Person.objects.filter(name__icontains='u') # name里包含字母u的，不区分大小写ret = models.Person.objects.filter(name__startswith='z') # 以z开头，区分大小写
ret = models.Person.objects.filter(name__istartswith='z') # 以z开头,不区分大小写
ret = models.Person.objects.filter(name__endswith='u') # 以u结尾，区分大小写
ret = models.Person.objects.filter(name__iendswith='u') # 以u结尾，不区分大小写ret = models.Person.objects.filter(birth__year='') # 查询年份为2019
ForeignKey查询
先来创建几张表
class Press(models.Model):
name = models.CharField(max_length=32) def __str__(self):
return '<Press %s-%s>'%(self.id,self.name)class Book(models.Model):
title = models.CharField(max_length=32)
price = models.IntegerField()
publisher = models.ForeignKey(to='Press') def __str__(self):
return '<Book %s-%s>'%(self.id, self.title)class Author(models.Model):
name = models.CharField(max_length=32)
books = models.ManyToManyField(to='Book')
创建表
往press表和book表里添加一些数据，如下
book_obj = models.Book.objects.get(id=1)
print(book_obj.title) # linux
print(book_obj.price) #
print(book_obj.publisher_id) #
print(book_obj.publisher) # publisher对应的上Press表，所以是press对象---》<Press 2-清华出版社>
print(book_obj.publisher.name) # press里对应的name---》清华出版社
查找上海出版社的书
常规写法
models.Book.objects.filter(publisher_id=models.Press.objects.get(name='上海出版社').id)
结果：
<QuerySet [<Book: <Book 2-python入门到放弃>>, <Book: <Book 3-java直接放弃>>]>
高级写法
obj = models.Book.objects.filter(publisher__name='上海出版社')
publisher__name ，前面的publisher为Book表里的字段，对应的结果是Press这个表对象，__name表示press表里的name字段
反向查询
上面的查询是通过book表查询press表的里数据，因为外键是写在book表里的，我们把这种叫做正向查询
通过press表查询book表里的数据，我们叫做反向查询
通过press里的id查找对应的书
obj = models.Press.objects.get(id=3)
print(obj.book_set.all())
结果：
<QuerySet [<Book: <Book 2-python入门到放弃>>, <Book: <Book 3-java直接放弃>>]>
book_set，表名小写_set得到的是一个管理对象，如果要获取所有的对象，在后面写.all()
还有另一种写法是在表里的字段后面写上related_name
class Book(models.Model):
title = models.CharField(max_length=32)
price = models.IntegerField()
publisher = models.ForeignKey(to='Press', related_name='mybook') def __str__(self):
return '<Book %s-%s>'%(self.id, self.title)
上面的查询就变成
obj = models.Press.objects.get(id=3)
print(obj.mybook.all())
正向查询书名也要用mybook_xxx=’xxx’
根据书名查询出版社
常规写法
obj = models.Press.objects.filter(id=models.Book.objects.get(title='python入门到放弃').publisher_id)
结果：
<QuerySet [<Press: <Press 3-上海出版社>>]>
高级写法
obj = models.Press.objects.filter(book__title='python入门到放弃')
ManyToManyField
在我们创建表的时候，book和author是多对多的关系，先来看一下他们之间的关系
set() 更新model对象的关联对象
obj = models.Author.objects.get(id=1)
# print(obj.name) 孙悟空obj.books.set(models.Book.objects.all())
obj = models.Author.objects.get(id=1)
# print(obj.name) 孙悟空obj.books.set([1,3])
add() 把指定的model对象添加到关联对象集中。
obj = models.Author.objects.get(id=1)
# print(obj.name) 孙悟空obj.books.add(*[2,4])
add还可以这样写
obj.books.add(1,2,3,4)
obj.books.add(*models.Book.objects.all())
remove() 从关系对象中移除执行的model对象
obj = models.Author.objects.get(id=1)
# print(obj.name) 孙悟空
obj.books.remove(1,4)
删除全部
obj = models.Author.objects.get(id=1)
# print(obj.name) 孙悟空obj.books.remove(*models.Book.objects.all())
clear() 从关联对象集中移除一切对象
obj = models.Author.objects.get(id=1)
# print(obj.name) 孙悟空obj.books.clear()
创建书和对应的关系
obj = models.Author.objects.get(id=1)
# print(obj.name) 孙悟空obj.books.create(title='一小时精通Django',price=66,publisher_id=3)
反向查询
class Author(models.Model):
name = models.CharField(max_length=32)
books = models.ManyToManyField(to='Book')
因为books是写在Author表里，所以通过Author查询book表里的是正向查询，通过book表查询author表里的是反向查询
obj = models.Book.objects.get(id=5)
print(obj.author_set.all())
反向查询要使用表名_set
注意：对于ForeignKey对象，clear()和remove()方法仅在null=True时存在。
栗子
ForeignKey字段没设置null=True时
class Book(models.Model):
title = models.CharField(max_length=32)
publisher = models.ForeignKey(to=Publisher)
没有clear()和remove()方法：
>>> models.Publisher.objects.first().book_set.clear()
Traceback (most recent call last):
File "<input>", line 1, in <module>
AttributeError: 'RelatedManager' object has no attribute 'clear'
当ForeignKey字段设置null=True时
class Book(models.Model):
name = models.CharField(max_length=32)
publisher = models.ForeignKey(to=Class, null=True)
此时就有clear()和remove()方法：
models.Publisher.objects.first().book_set.clear()
聚合查询
在sql语句中，我们知道聚合语句，比如查询最大值，最小值，平均值等等。在ORM中，使用aggregate()来进行聚合查询，首先需要导入
from django.db.models import Max, Min, Avg, Sum, Count
查询价格最大是多少
from django.db.models import Max, Min, Avg, Sum, Countret = models.Book.objects.aggregate(Max('price'))
print(ret)ret = models.Book.objects.all().aggregate(Max('price'))
print(ret)
结果：
{'price__max': 66}
{'price__max': 66}
结果是一个字典格式，key为“字段_聚合名”，如果你看它不爽，你也可以自定义
from django.db.models import Max, Min, Avg, Sum, Countret = models.Book.objects.aggregate(最大值=Max('price'),最小值=Min('price'))
print(ret)
结果：
{'最大值': 66, '最小值': 22}
注意：如果你查询了多个，有些聚合你自己定义了名称，有些你没有定义名称，则没有定义名称的要放在前面(位置参数不能在关键字参数后面)
分组查询
先来看一下数据表关系
查询出每本书的作者
from django.db.models import Max, Min, Avg, Sum, Countret = models.Book.objects.annotate(num=Count('author'))
print(ret)
结果是QuerySet
<QuerySet [<Book: Book object>, <Book: Book object>, <Book: Book object>, <Book: Book object>, <Book: Book object>]>
使用.values()获取所有
from django.db.models import Max, Min, Avg, Sum, Countret = models.Book.objects.annotate(num=Count('author')).values()
for i in ret:
print(i)
结果：
{'id': 1, 'title': 'linux', 'price': 22, 'publisher_id': 2, 'num': 1}
{'id': 2, 'title': 'python入门到放弃', 'price': 55, 'publisher_id': 3, 'num': 0}
{'id': 3, 'title': 'java直接放弃', 'price': 22, 'publisher_id': 3, 'num': 1}
{'id': 4, 'title': 'go精通', 'price': 54, 'publisher_id': 1, 'num': 2}
{'id': 5, 'title': '一小时精通Django', 'price': 66, 'publisher_id': 3, 'num': 1}
可以在value里指定参数获取想要的字段
from django.db.models import Max, Min, Avg, Sum, Countret = models.Book.objects.annotate(num=Count('author')).values('title','num')
for i in ret:
print(i)
结果：
num对应的值就是这本书作者的个数
{'title': 'linux', 'num': 1}
{'title': 'python入门到放弃', 'num': 0}
{'title': 'java直接放弃', 'num': 1}
{'title': 'go精通', 'num': 2}
{'title': '一小时精通Django', 'num': 1}
统计每个出版社最便宜的书的价格
from django.db.models import Max, Min, Avg, Sum, Countret = models.Book.objects.values('publisher_id').annotate(min_num=Min('price'))
for i in ret:
print(i)
结果：
{'publisher_id': 1, 'min_num': 54}
{'publisher_id': 2, 'min_num': 22}
{'publisher_id': 3, 'min_num': 22}
因为不分组的结果
from django.db.models import Max, Min, Avg, Sum, Countret = models.Book.objects.values('publisher_id')
for i in ret:
print(i)
结果：
{'publisher_id': 1}
{'publisher_id': 2}
{'publisher_id': 3}
{'publisher_id': 3}
{'publisher_id': 3}
统计不止一个作者的图书
ret = models.Book.objects.annotate(num=Count('author')).filter(num__gt=1).values()
for i in ret:
print(i)
结果：
{'id': 4, 'title': 'go精通', 'price': 54, 'publisher_id': 1, 'num': 2}
查询各个作者出的书的总价格
F查询
在之前的查询中，我们都是拿某个字段对一个固定的值做比较，如果想用字段和字段做比较，就要用到F查询了，先来看下数据表里的数据
需求，查出所有num大于money的
from django.db.models import Fret = models.Book.objects.filter(num__gt=F('money')).values()
for i in ret:
print(i)
结果：
{'id': 1, 'title': 'linux', 'price': 22, 'publisher_id': 2, 'money': 23, 'num': 65}
{'id': 4, 'title': 'go精通', 'price': 54, 'publisher_id': 1, 'money': 33, 'num': 88}
{'id': 5, 'title': '一小时精通Django', 'price': 66, 'publisher_id': 3, 'money': 44, 'num': 99}
需求：给每个num的值*2
之前的都是对某一条数据更新的，如
ret = models.Book.objects.get(id=2)
ret.num=24
ret.save()
上面的这种写法要进行save()，而且要写更新的具体数值
使用update更新
ret = models.Book.objects.filter(id=2).update(num=50)
update就不需要save
ret = models.Book.objects.update(num=50) # 对所有的数据更新
这两种写法都满足不了我们的需求，我们用F来实现，下面两种结果是一样的
from django.db.models import Fret = models.Book.objects.update(num=F('num')*2)ret = models.Book.objects.all().update(num=F('num')*2)
需求：在所有书名后面加上（测试）
ret = models.Book.objects.update(title=Concat(F("title"), Value("("), Value("测试"), Value(")")))
不需要()
ret = models.Book.objects.update(title=Concat(F("title"), Value("测试")))
Q查询
之前我们所有进行的查询都是and关系的，如果要使用or关系的查询，就要用Q查询了。继续看数据表数据
需求：查询id小于3并且大于等于6的
from django.db.models import Qret = models.Author.objects.filter(Q(id__lt=3) | Q(id__gte=6)).values()
for i in ret:
print(i)
结果：管道符（ | ）表示或的关系
{'id': 1, 'name': '孙悟空'}
{'id': 2, 'name': '猪八戒'}
{'id': 6, 'name': '蜘蛛精'}
{'id': 7, 'name': '女儿国'}
{'id': 8, 'name': '紫霞仙子'}
&表示并且的关系
from django.db.models import Qret = models.Author.objects.filter(Q(id__lt=7) & Q(id__gte=6)).values()
for i in ret:
print(i)
结果：
{'id': 6, 'name': '蜘蛛精'}
~表示取反
from django.db.models import Qret = models.Author.objects.filter(~Q(id__lt=7) & Q(id__gte=6)).values()
for i in ret:
print(i)
结果：
{'id': 7, 'name': '女儿国'}
{'id': 8, 'name': '紫霞仙子'}
事务
事务（Transaction）是并发控制的基本单位。所谓的事务，它是一个操作序列，这些操作要么都执行，要么都不执行，它是一个不可分割的工作单位。例如，银行转账工作：从一个账号扣款并使另一个账号增款，这两个操作要么都执行，要么都不执行。所以，应该把它们看成一个事务。事务是数据库维护数据一致性的单位，在每个事务结束时，都能保持数据一致性。
针对上面的描述可以看出，事务的提出主要是为了解决并发情况下保持数据一致性的问题。
事务具有以下4个基本特征。
- Atomic（原子性）：事务中包含的操作被看做一个逻辑单元，这个逻辑单元中的操作要么全部成功，要么全部失败。
- Consistency（一致性）：只有合法的数据可以被写入数据库，否则事务应该将其回滚到最初状态。
- Isolation（隔离性）：事务允许多个用户对同一个数据进行并发访问，而不破坏数据的正确性和完整性。同时，并行事务的修改必须与其他并行事务的修改相互独立。
- Durability（持久性）：事务结束后，事务处理的结果必须能够得到固化。
import osif __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "orm_project.settings")
import django django.setup() from appTest01 import models try:
from django.db import transaction
with transaction.atomic(): 这里写要执行的ORM语句 except Exception as e:
print(str(e))
