Django-model进阶

回到顶部

QuerySet

可切片

使用Python 的切片语法来限制查询集记录的数目 。它等同于SQL 的LIMIT 和OFFSET 子句。

1
>>> Entry.objects.all()[:5]      # (LIMIT 5)
>>> Entry.objects.all()[5:10]    # (OFFSET 5 LIMIT 5)

不支持负的索引（例如Entry.objects.all()[-1]）。通常，查询集 的切片返回一个新的查询集 —— 它不会执行查询。

可迭代

articleList=models.Article.objects.all()for article in articleList:print(article.title)

惰性查询

查询集 是惰性执行的 —— 创建查询集不会带来任何数据库的访问。你可以将过滤器保持一整天，直到查询集 需要求值时，Django 才会真正运行这个查询。

1
2
3
4
5
6
queryResult=models.Article.objects.all() # not hits database
print(queryResult) # hits database
for article in queryResult:
    print(article.title)    # hits database

 一般来说，只有在“请求”查询集 的结果时才会到数据库中去获取它们。当你确实需要结果时，查询集 通过访问数据库来求值。 关于求值发生的准确时间，参见何时计算查询集。

缓存机制

每个查询集都包含一个缓存来最小化对数据库的访问。理解它是如何工作的将让你编写最高效的代码。

在一个新创建的查询集中，缓存为空。首次对查询集进行求值 —— 同时发生数据库查询 ——Django 将保存查询的结果到查询集的缓存中并返回明确请求的结果（例如，如果正在迭代查询集，则返回下一个结果）。接下来对该查询集 的求值将重用缓存的结果。

请牢记这个缓存行为，因为对查询集使用不当的话，它会坑你的。例如，下面的语句创建两个查询集，对它们求值，然后扔掉它们：

1
2
print([a.title for a in models.Article.objects.all()])
print([a.create_time for a in models.Article.objects.all()])

这意味着相同的数据库查询将执行两次，显然倍增了你的数据库负载。同时，还有可能两个结果列表并不包含相同的数据库记录，因为在两次请求期间有可能有Article被添加进来或删除掉。为了避免这个问题，只需保存查询集并重新使用它：

1
2
3
queryResult=models.Article.objects.all()
print([a.title for a in queryResult])
print([a.create_time for a in queryResult])

何时查询集不会被缓存?

查询集不会永远缓存它们的结果。当只对查询集的部分进行求值时会检查缓存， 如果这个部分不在缓存中，那么接下来查询返回的记录都将不会被缓存。所以，这意味着使用切片或索引来限制查询集将不会填充缓存。

例如，重复获取查询集对象中一个特定的索引将每次都查询数据库：

1
2
3
>>> queryset = Entry.objects.all()
>>> print queryset[5] # Queries the database
>>> print queryset[5] # Queries the database again

然而，如果已经对全部查询集求值过，则将检查缓存：

1
2
3
4
>>> queryset = Entry.objects.all()
>>> [entry for entry in queryset] # Queries the database
>>> print queryset[5] # Uses cache
>>> print queryset[5] # Uses cache

下面是一些其它例子，它们会使得全部的查询集被求值并填充到缓存中：

1
2
3
4
>>> [entry for entry in queryset]
>>> bool(queryset)
>>> entry in queryset
>>> list(queryset)

注：简单地打印查询集不会填充缓存。

exists()与iterator()方法

exists：

简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些 数据！为了避免这个，可以用exists()方法来检查是否有数据：

 if queryResult.exists():#SELECT (1) AS "a" FROM "blog_article" LIMIT 1; args=()print("exists...")

iterator:

当queryset非常巨大时，cache会成为问题。

处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统 进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法 来获取数据，处理完数据就将其丢弃。

复制代码
objs = Book.objects.all().iterator()
# iterator()可以一次只从数据库获取少量数据，这样可以节省内存
for obj in objs:print(obj.title)
#BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
for obj in objs:print(obj.title)
复制代码

当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使 #用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询。

总结:

queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。 使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能 会造成额外的数据库查询。　

回到顶部

中介模型

处理类似搭配 pizza 和 topping 这样简单的多对多关系时，使用标准的ManyToManyField  就可以了。但是，有时你可能需要关联数据到两个模型之间的关系上。

例如，有这样一个应用，它记录音乐家所属的音乐小组。我们可以用一个ManyToManyField 表示小组和成员之间的多对多关系。但是，有时你可能想知道更多成员关系的细节，比如成员是何时加入小组的。

对于这些情况，Django 允许你指定一个中介模型来定义多对多关系。 你可以将其他字段放在中介模型里面。源模型的ManyToManyField 字段将使用through 参数指向中介模型。对于上面的音乐小组的例子，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from django.db import models
class Person(models.Model):
    name = models.CharField(max_length=128)
    def __str__(self):              # __unicode__ on Python 2
        return self.name
class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through='Membership')
    def __str__(self):              # __unicode__ on Python 2
        return self.name
class Membership(models.Model):
    person = models.ForeignKey(Person)
    group = models.ForeignKey(Group)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

既然你已经设置好ManyToManyField 来使用中介模型（在这个例子中就是Membership），接下来你要开始创建多对多关系。你要做的就是创建中介模型的实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> ringo = Person.objects.create(name="Ringo Starr")
>>> paul = Person.objects.create(name="Paul McCartney")
>>> beatles = Group.objects.create(name="The Beatles")
>>> m1 = Membership(person=ringo, group=beatles,
...     date_joined=date(1962, 8, 16),
...     invite_reason="Needed a new drummer.")
>>> m1.save()
>>> beatles.members.all()
[<Person: Ringo Starr>]
>>> ringo.group_set.all()
[<Group: The Beatles>]
>>> m2 = Membership.objects.create(person=paul, group=beatles,
...     date_joined=date(1960, 8, 1),
...     invite_reason="Wanted to form a band.")
>>> beatles.members.all()
[<Person: Ringo Starr>, <Person: Paul McCartney>]

与普通的多对多字段不同，你不能使用add、 create和赋值语句（比如，beatles.members = [...]）来创建关系：

1
2
3
4
5
6
# THIS WILL NOT WORK
>>> beatles.members.add(john)
# NEITHER WILL THIS
>>> beatles.members.create(name="George Harrison")
# AND NEITHER WILL THIS
>>> beatles.members = [john, paul, ringo, george]

为什么不能这样做？ 这是因为你不能只创建 Person和 Group之间的关联关系，你还要指定 Membership模型中所需要的所有信息；而简单的add、create 和赋值语句是做不到这一点的。所以它们不能在使用中介模型的多对多关系中使用。此时，唯一的办法就是创建中介模型的实例。

 remove()方法被禁用也是出于同样的原因。但是clear() 方法却是可用的。它可以清空某个实例所有的多对多关系：

1
2
3
4
5
>>> # Beatles have broken up
>>> beatles.members.clear()
>>> # Note that this deletes the intermediate model instances
>>> Membership.objects.all()
[]
回到顶部

查询优化

表数据

select_related

简单使用

对于一对一字段（OneToOneField）和外键字段（ForeignKey），可以使用select_related 来对QuerySet进行优化。

select_related 返回一个QuerySet，当执行它的查询时它沿着外键关系查询关联的对象的数据。它会生成一个复杂的查询并引起性能的损耗，但是在以后使用外键关系时将不需要数据库查询。

简单说，在对QuerySet使用select_related()函数后，Django会获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了。

下面的例子解释了普通查询和select_related() 查询的区别。

查询id=2的文章的分类名称,下面是一个标准的查询：

1
2
3
4
5
# Hits the database.
article=models.Article.objects.get(nid=2)
# Hits the database again to get the related Blog object.
print(article.category.title)

 如果我们使用select_related()函数：

1
2
3
4
5
6
7
articleList=models.Article.objects.select_related("category").all()
    for article_obj in articleList:
        #  Doesn't hit the database, because article_obj.category
        #  has been prepopulated in the previous query.
        print(article_obj.category.title)

多外键查询

这是针对category的外键查询，如果是另外一个外键呢？让我们一起看下：

1
2
article=models.Article.objects.select_related("category").get(nid=1)
print(article.articledetail)

 观察logging结果，发现依然需要查询两次，所以需要改为：

1
2
article=models.Article.objects.select_related("category","articledetail").get(nid=1)
print(article.articledetail)

 或者：

article=models.Article.objects
　　　　　　　　　　　　　.select_related("category")
　　　　　　　　　　　　　.select_related("articledetail")
　　　　　　　　　　　　　.get(nid=1)  # django 1.7 支持链式操作
print(article.articledetail)

 

深层查询

1
2
3
4
# 查询id=1的文章的用户姓名
    article=models.Article.objects.select_related("blog").get(nid=1)
    print(article.blog.user.username)

 依然需要查询两次：

 这是因为第一次查询没有query到userInfo表，所以，修改如下：

1
2
article=models.Article.objects.select_related("blog__user").get(nid=1)
print(article.blog.user.username)

总结

  1. select_related主要针一对一和多对一关系进行优化。
  2. select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
  3. 可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。
  4. 没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。
  5. 也可以通过depth参数指定递归的深度，Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段，Django会再次进行SQL查询。
  6. 也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。
  7. Django >= 1.7，链式调用的select_related相当于使用可变长参数。Django < 1.7，链式调用会导致前边的select_related失效，只保留最后一个。

prefetch_related()

对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。

prefetch_related()和select_related()的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。后者是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。若有n个对象，每个对象的多对多字段对应Mi条，就会生成Σ(n)Mi 行的结果表。

prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。

1
2
3
4
5
# 查询所有文章关联的所有标签
    article_obj=models.Article.objects.all()
    for i in article_obj:
        print(i.tags.all())  #4篇文章: hits database 5

改为prefetch_related：

1
2
3
4
5
# 查询所有文章关联的所有标签
    article_obj=models.Article.objects.prefetch_related("tags").all()
    for i in article_obj:
        print(i.tags.all())  #4篇文章: hits database 2
回到顶部

extra

extra(select=None, where=None, params=None, 
      tables=None, order_by=None, select_params=None)

有些情况下，Django的查询语法难以简单的表达复杂的 WHERE 子句，对于这种情况, Django 提供了 extra() QuerySet修改机制 — 它能在 QuerySet生成的SQL从句中注入新子句

extra可以指定一个或多个 参数,例如 select, where or tables. 这些参数都不是必须的，但是你至少要使用一个!要注意这些额外的方式对不同的数据库引擎可能存在移植性问题.(因为你在显式的书写SQL语句),除非万不得已,尽量避免这样做

参数之select

The select 参数可以让你在 SELECT 从句中添加其他字段信息，它应该是一个字典，存放着属性名到 SQL 从句的映射。

queryResult=models.Article
　　　　　　　　　　　.objects.extra(select={'is_recent': "create_time > '2017-09-05'"})

结果集中每个 Entry 对象都有一个额外的属性is_recent, 它是一个布尔值，表示 Article对象的create_time 是否晚于2017-09-05.

练习：

复制代码
# in sqlite:article_obj=models.Article.objects
　　　　　　　　　　　　　　.filter(nid=1)
　　　　　　　　　　　　　　.extra(select={"standard_time":"strftime('%%Y-%%m-%%d',create_time)"})
　　　　　　　　　　　　　　.values("standard_time","nid","title")print(article_obj)# <QuerySet [{'title': 'MongoDb 入门教程', 'standard_time': '2017-09-03', 'nid': 1}]>
复制代码

参数之where / tables

您可以使用where定义显式SQL WHERE子句 - 也许执行非显式连接。您可以使用tables手动将表添加到SQL FROM子句。

where和tables都接受字符串列表。所有where参数均为“与”任何其他搜索条件。

举例来讲：

queryResult=models.Article
　　　　　　　　　　　.objects.extra(where=['nid in (1,3) OR title like "py%" ','nid>2'])
回到顶部

整体插入

创建对象时，尽可能使用bulk_create()来减少SQL查询的数量。例如：

Entry.objects.bulk_create([Entry(headline="Python 3.0 Released"),Entry(headline="Python 3.1 Planned")
])

...更优于：

Entry.objects.create(headline="Python 3.0 Released")
Entry.objects.create(headline="Python 3.1 Planned")

注意该方法有很多注意事项，所以确保它适用于你的情况。

这也可以用在ManyToManyFields中，所以：

my_band.members.add(me, my_friend)

...更优于：

my_band.members.add(me)
my_band.members.add(my_friend)

...其中Bands和Artists具有多对多关联。

转载于:https://www.cnblogs.com/wangmo/p/8360397.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/251043.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

ES6-2 块级作用域与嵌套、let、暂行性死区

ES6-2 块级作用域与嵌套、let、暂行性死区

注意&#xff0c;写在开头 function test(x 1) {var x // 不报错console.log(x) } function test1(x 1) {let x 10 // 报错console.log(x) }let的变量名不可以和参数中的名称相同。而var并不限制&#xff0c;说白了就是希望你规范使用变量名。 形参原则上数组函数内部的临…
阅读更多...
常用的操作系统知识

常用的操作系统知识

为什么要有操作系统 现代计算机系统是由一个或者多个处理器&#xff0c;主存&#xff0c;磁盘&#xff0c;打印机&#xff0c;键盘&#xff0c;鼠标显示器&#xff0c;网络接口以及各种其他输入&#xff0c;输出设备组成的复杂系统&#xff0c;每位程序员不可能掌握所有系统实现…
阅读更多...
vue --- 使用中央事件总线(bus)实现跨组件通信

vue --- 使用中央事件总线(bus)实现跨组件通信

使用Bus实现跨组件传输须注意以下3点: 1.需要创建一个空的Vue实例(bus),来作为中间站 2.使用bus.emit来发送事件3.使用bus.emit来发送事件 3.使用bus.emit来发送事件3.使用bus.on来监听事件(在钩子created中监听) 代码如下: <!DOCTYPE html> <html> <head>…
阅读更多...
vue --- 获取子组件数据的一个应急方案$refs

vue --- 获取子组件数据的一个应急方案$refs

使用$refs需要注意以下2点: 1.html方法使用子组件时,需使用ref “xxx” 声明. 2.在父组件中使用,this.refs.xxx.msg 获取数据 <!DOCTYPE html> <html> <head> <meta charset"utf-8"> </head> <body><div id"app"…
阅读更多...
ES6-4/5 解构赋值、函数默认值、数组解构、对象解构

ES6-4/5 解构赋值、函数默认值、数组解构、对象解构

ES-4 解构赋值、函数默认值、数组解构、对象解构 ES-5 隐式转换、函数参数解构、解构本质、()用法 一 解构赋值 1 虚值 含义&#xff1a;在Boolean转换结果为假的值falsy 2 函数默认值 ES6 内部使用严格相等运算符&#xff08;&#xff09;&#xff0c;判断一个位置是否有值…
阅读更多...
echarts --- 多折线图按段显示颜色规则订制

echarts --- 多折线图按段显示颜色规则订制

描述: 图中有4个序列,序列1和序列2在同一个x轴下,显示不同的颜色.(如,在-40到-30,序列一是红色,而序列2是黑色) 关键: VisualMap中的seriesIndex属性(根据不同的系列,制定不同的颜色规则). 下面是代码,可以直接复制到 echart实例 中进行调试 var symbolSize 20; var data [[…
阅读更多...
ES6-6 - this指向、箭头函数基本形式、rest运算符

ES6-6 - this指向、箭头函数基本形式、rest运算符

一 chrome断点调试 观察函数调用栈 // 25min var x 1; function foo(x, y function () { x 2; console.log(2) }) {var x 3;y();console.log(x) } foo() console.log(x) // 2 3 1var x 1; function foo(x, y function () { x 2; console.log(x) }) {x 3;y();console.…
阅读更多...
ES6-7 - 箭头函数的实质、箭头函数的使用场景

ES6-7 - 箭头函数的实质、箭头函数的使用场景

箭头函数返回对象 // 这种情况要要用(),否则会将对象的{}解释为块 const fn (a, b) > ({a:1, b:2})箭头函数的特点 this指向由外层函数的作用域来决定&#xff0c;它本身没有this&#xff0c;不能通过call、apply、bind改变不能作为构造函数使用不可以使用arguments对象&…
阅读更多...
javasript --- 一个日期规范(x秒前,x分前...)

javasript --- 一个日期规范(x秒前,x分前...)

Time函数(通俗易懂,自己根据实际需求修改吧- -) // time.js var Time {// 获取当前时间戳getUnix: function () {var date new Date();return date.getTime();},// 获取今天0点0分0秒的时间戳getTodayUnix: function () {var date new Date();date.setHours(0);date.setMin…
阅读更多...
ES6-8 - 函数名/对象拓展、描述符、getter/setter

ES6-8 - 函数名/对象拓展、描述符、getter/setter

函数名 有两种特殊情况&#xff1a;bind方法创造的函数&#xff0c;name属性返回bound加上原函数的名字&#xff1b;Function构造函数创造的函数&#xff0c;name属性返回anonymous。 bind函数名 // 以bound开头 function foo() { } const fnName foo.bind().name console.lo…
阅读更多...
javascript --- 再识闭包

javascript --- 再识闭包

看下面一个例子: function zipCode(code, location) {let _code code;let _location location || ;return {code: function () {return _code;},location: function() {return _location;}} }再上述封闭的函数中,code的匿名函数根据作用域链可以访问到外面的_code变量. con…
阅读更多...
ES6-9 对象密封4种方式、assign、取值函数的拷贝

ES6-9 对象密封4种方式、assign、取值函数的拷贝

一 对象密封 1 Object.preventExtensions 禁止对象拓展&#xff0c;仍可删除 严格模式下报错 const origin {a: 1 } const fixed Object.preventExtensions(origin) console.log(origin fixed) // true console.log(Object.isExtensible(origin)) // false 不可拓展 orig…
阅读更多...
javascript --- 使用ajax与服务器进行通信

javascript --- 使用ajax与服务器进行通信

Ajax: (Asynchronous JavaScript and XML,异步JavaScript与XML技术)是一种有效利用JavaScript和DOM的操作. 与传统HTTP请求的区别: Ajax允许只更新页面的一部分,因此减少了响应中传输的数据量 Ajax的API: Ajax与服务器进行通信,可以使用JavaScript中原生的XMLHttpRequest对象…
阅读更多...
ES6-10 super、4种遍历方式、原型、symbol遍历

ES6-10 super、4种遍历方式、原型、symbol遍历

由于现代 JavaScript 引擎优化属性访问所带来的特性的关系&#xff0c;更改对象的 [[Prototype]]即__proto__在各个浏览器和 JavaScript 引擎上都是一个很慢的操作。 一 Object原型方法 1 Object.setPrototypeOf(obj, proto) 用该方法而不是直接修改__proto__返回值是设置好原…
阅读更多...
IntelliJ IDEA使用

IntelliJ IDEA使用

1&#xff1a;下载 ideaIU-2017.2.exe&#xff0c;JetbrainsCrack-2.6.2.jar(补丁) 2&#xff1a;安装ideaIU-2017.2.exe&#xff0c;将补丁放在D:\java\intellij\IntelliJ IDEA 2017.2\bin 目录下 3&#xff1a;在安装的idea下面的bin目录下面有2个文件 &#xff1a; 一个是id…
阅读更多...
js中如何删除json对象的某一个选项

js中如何删除json对象的某一个选项

我有一个这样一个对象&#xff0c;getData, 但是我不想要每一项的id&#xff0c;那怎么去删除呢(使用delete)? getData.map((item) >{delete item["id"];});console.log(getData);转载于:https://www.cnblogs.com/mmykdbc/p/8386407.html
阅读更多...
ES6-11 Symbol、iterator、forOf、typeArray

ES6-11 Symbol、iterator、forOf、typeArray

…剩余运算符 const obj1 {a: 1,b: 2 } const obj2 {a: 100,b: 2,c: 300 } const obj {...obj1,...obj2 } console.log(obj) // 和Object.assign(obj, obj1, obj2)结果相同[Symbol.hasInstance] Symbol构造函数上的属性&#xff0c;默认调用了方法 iterator迭代器 对数…
阅读更多...
node --- 游走在客户端和服务器间的http

node --- 游走在客户端和服务器间的http

本篇文章,讲述了一个很简单的上传图片(/start)到本地服务器,然后路由跳转到/upload. 写这个程序的目的是为了帮助理解HTTP的一些基本概念及node对于http api的实现以及程序的设计模式. IP: 计算机之间的通信 TCP: 应用程序之间的通信 HTTP: 基于TCP实现的应用层协议,设计之初是…
阅读更多...
redis配置环境变量

redis配置环境变量

直接上图不解释 redis安装路径&#xff0c;我的电脑右击属性 窗口R键&#xff0c;输入cmd回车&#xff0c;输入redis-server.exe 回车 再开一个命令窗口&#xff0c;窗口R键&#xff0c;输入cmd回车&#xff0c;输入 redis-cli.exe -h 127.0.0.1 -p 6379 回车 转载于:https:/…
阅读更多...
对转义字符的思考

对转义字符的思考

ASCII码 计算机存储文字时用的是二进制&#xff0c;ASCII码就是一张对照表&#xff0c;什么字符对应什么码&#xff0c;将二进制码存储下来0-127位表示基础的ASCII码0-31&#xff0c;和127表示非打印控制字符&#xff08;如换行、回车、响铃、文头、文尾&#xff09;32-126表示…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023