django+python 操作数据库

时间：2022-09-12 14:55:17

生成查询

 

你创建完数据模型，django会自动提供给你数据库抽象的API，可以创建,获取,修改,删除对象.本篇文档讲解如何使用API。

 

我们参考下面模型，一个weblog：

Python代码  django+python 操作数据库
  1. class Blog(models.Model):  
  2.     name = models.CharField(max_length=100)  
  3.     tagline = models.TextField()  
  4.   
  5.     def __unicode__(self):  
  6.         return self.name  
  7.   
  8. class Author(models.Model):  
  9.     name = models.CharField(max_length=50)  
  10.     email = models.EmailField()  
  11.   
  12.     def __unicode__(self):  
  13.         return self.name  
  14.   
  15. class Entry(models.Model):  
  16.     blog = models.ForeignKey(Blog)  
  17.     headline = models.CharField(max_length=255)  
  18.     body_text = models.TextField()  
  19.     pub_date = models.DateTimeField()  
  20.     authors = models.ManyToManyField(Author)  
  21.     n_comments = models.IntegerField()  
  22.     n_pingbacks = models.IntegerField()  
  23.     rating = models.IntegerField()  
  24.   
  25.     def __unicode__(self):  
  26.         return self.headline  

 

创建对象

 

用python对象描述数据库表的数据,django使用一个直观的系统，一个模型类描述一个数据表，一个类的实例描述表的一条详细记录。使用模型的save()方法将对象创建到数据库。

Python代码  django+python 操作数据库
  1. >>> from mysite.blog.models import Blog  
  2. >>> b = Blog(name='Beatles Blog', tagline='All the latest Beatles news.')  
  3. >>> b.save()  

 只有执行save方法时，django才会执行sql把对象写入数据库。

 

保存修改的对象

 

保存修改仍然使用save()方法

Python代码  django+python 操作数据库
  1. >> b5.name = 'New name'  
  2. >> b5.save()  

 

保存 ForeignKey 和 ManyToManyField 字段

 

Python代码  django+python 操作数据库
  1. >>> cheese_blog = Blog.objects.get(name="Cheddar Talk")  
  2. >>> entry.blog = cheese_blog  
  3. >>> entry.save()  

为 ManyToManyField 增加记录

 

Python代码  django+python 操作数据库
  1. >> joe = Author.objects.create(name="Joe")  
  2. >> entry.authors.add(joe)  

 

检索对象

 

从数据库里检索对象 ，可以通过模型的Manage来建立QuerySet,一个queryset表现为一个数据库中对象的结合，他可以有0个一个或多个过滤条件，在SQL里QUERYSET相当于SELECT 语句用WHERE 或LIMIT过滤。

你通过模型的manager来获取QUERYSET，每个模型至少有一个manager

Python代码  django+python 操作数据库
  1. <tt class="docutils literal">>>> Blog.objects  
  2. <django.db.models.manager.Manager object at ...>  
  3. >>> b = Blog(name='Foo', tagline='Bar')  
  4. >>> b.objects  
  5. Traceback:  
  6.     ...  
  7. AttributeError: "Manager isn't accessible via Blog instances."  
  8. </tt>  

 

检索所有的对象

 

检索表中所有数据，最简单的方式是用all().

 

 

 

 

 

Python代码  django+python 操作数据库
  1. >>> all_entries = Entry.objects.all()  

 

过滤检索特定对象

 

检索过滤特定查询结果，有两个方法。

filter(**kwargs)  返回一个新的匹配查参数件后的QuerySet 

exclude(**kwargs) 返回一个新的不匹配查询参数后的QuerySet 

 

例如：

Python代码  django+python 操作数据库
  1. Entry.objects.filter(pub_date__year=2006)  

 

 

链接过滤

 

Python代码  django+python 操作数据库
  1. >>> Entry.objects.filter(  
  2. ...     headline__startswith='What'  
  3. ... ).exclude(  
  4. ...     pub_date__gte=datetime.now()  
  5. ... ).filter(  
  6. ...     pub_date__gte=datetime(2005, 1, 1)  
  7. ... )  

 

 

过滤结果集是唯一 

 

每次你完善一个QuerySet，你获得一个全新的结果集，不包括前面的。每次完成的结果集是可以贮存，使用或复用

 

Python代码  django+python 操作数据库
  1. >> q1 = Entry.objects.filter(headline__startswith="What")  
  2. >> q2 = q1.exclude(pub_date__gte=datetime.now())  
  3. >> q3 = q1.filter(pub_date__gte=datetime.now())  

 

三个QuerySets 是分开的，第一个是headline以"What"单词开头的结果集，第二个是第一个的子集，即pub_date不大于现在的，第三个是第一个的子集 ，pub_date大于现在的

 

结果集是延迟的 

 

QuerySets 是延迟的，创建QuerySets 不会触及到数据库动作，你可以多个过滤合并到一起，直到求值的时候django才会开始查询。如：

Python代码  django+python 操作数据库
  1. >>> q = Entry.objects.filter(headline__startswith="What")  
  2. >>> q = q.filter(pub_date__lte=datetime.now())  
  3. >>> q = q.exclude(body_text__icontains="food")  
  4. >>> print q  

 

虽然看起来执行了三个过滤条件，实际上最后执行printq的时候，django才开始查询执行SQL到数据库。 

 

其他的QuerySet方法

 

大多数情况你使用all(),filter() 和exclude()

限制 QuerySets

使用python的数组限制语法限定QuerySet,如：

取前5个

Python代码  django+python 操作数据库
  1. <tt class="docutils literal">>>> Entry.objects.all()[:5]  
  2. </tt>  

 

取第五个到第十个

 

 

 

 

Python代码  django+python 操作数据库
  1. >>> Entry.objects.all()[5:10]  

 

一般的，限制QuerySet返回新的QuerySet，不会立即求值查询，除非你使用了"step"参数

 

 

Python代码  django+python 操作数据库
  1. >>> Entry.objects.all()[:10:2]  

 

 

 

 

 

 

Python代码  django+python 操作数据库
  1. >>> Entry.objects.order_by('headline')[0]  
  2.   
  3. >>> Entry.objects.order_by('headline')[0:1].get()  

 

 

字段查找

 

字段查找是指定SQL语句的WHERE条件从句，通过QuerySet 的方法filter(),exclude() 和get()指定查询关键字

基本查询field__lookuptype=value

例如：

Python代码  django+python 操作数据库
  1. <tt class="docutils literal">Entry.objects.filter(pub_date__lte='2006-01-01')</tt>  

 

转换为SQL：

 

 

 

 

 

 

Sql代码  django+python 操作数据库
  1. SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';  

 

如果你传了无效的参数会抛异常

 

数据库API 支持一些查询类型，下面体验一下

 

exact

 

Python代码  django+python 操作数据库
  1. Entry.objects.get(headline__exact="Man bites dog")  

 转化为SQL：

Sql代码  django+python 操作数据库
  1. SELECT ... WHERE headline = 'Man bites dog';  

 

 

如果查询没有提供双下划线，那么会默认 __exact=

Python代码  django+python 操作数据库
  1. >>> Blog.objects.get(id__exact=14)  # Explicit form  
  2. >>> Blog.objects.get(id=14)         # __exact is implied  

 

iexact

 

忽略大小写

Python代码  django+python 操作数据库
  1. Blog.objects.get(name__iexact="beatles blog")  

 

blog title会匹配  "Beatles Blog", "beatles blog", 甚至 "BeAtlES blOG". 

 

contains 

 

包含查询，区分大小写

Python代码  django+python 操作数据库
  1. Entry.objects.get(headline__contains='Lennon')  

 转化为SQL

Python代码  django+python 操作数据库
  1. SELECT ... WHERE headline LIKE '%Lennon%';  

 icontains 不区分大小写

 

startswith,endswith，istartswith ，iendswith

前模糊匹配，后模糊匹配

跨关系查询

 

 

Python代码  django+python 操作数据库
  1. Entry.objects.filter(blog__name__exact='Beatles Blog')  

这个可以跨越你想要的深度。

反向跨关系查询

 

 

Python代码  django+python 操作数据库
  1. Blog.objects.filter(entry__headline__contains='Lennon')  

 如果跨越多层关系查询，中间模型没有值，django会作为空对待不会发生异常

Python代码  django+python 操作数据库
  1. Blog.objects.filter(entry__author__name='Lennon'  

 

Python代码  django+python 操作数据库
  1. Blog.objects.filter(entry__author__name__isnull=True)  
  2.   
  3. Blog.objects.filter(entry__author__isnull=False,  
  4.         entry__author__name__isnull=True)  

 

过滤器可参考模型字段

 

目前给的例子里，我们建立了过滤，比照模型字段值和一个固定的值，但是如果我们想比较同一个模型里的一个指端和另一个字段的值，django提供F()

 

Python代码  django+python 操作数据库
  1. >>> from django.db.models import F  
  2. >>> Entry.objects.filter(n_pingbacks__lt=F('n_comments'))  

 

django支持加减乘除和模计算

Python代码  django+python 操作数据库
  1. Entry.objects.filter(n_pingbacks__lt=F('n_comments') * 2)  

 

Python代码  django+python 操作数据库
  1. Entry.objects.filter(rating__lt=F('n_comments') + F('n_pingbacks'))  

 

Python代码  django+python 操作数据库
  1. Entry.objects.filter(author__name=F('blog__name'))  

 

主键查询捷径

 

Python代码  django+python 操作数据库
  1. Blog.objects.get(id__exact=14) # Explicit form  
  2. Blog.objects.get(id=14) # __exact is implied  
  3. Blog.objects.get(pk=14) # pk implies id__exact  

 

不仅限于__exact查询

Python代码  django+python 操作数据库
  1. # Get blogs entries with id 1, 4 and 7  
  2. >>> Blog.objects.filter(pk__in=[1,4,7])  
  3.   
  4. # Get all blog entries with id > 14  
  5. >>> Blog.objects.filter(pk__gt=14)  

 跨越查询

Python代码  django+python 操作数据库
  1. >>> Entry.objects.filter(blog__id__exact=3) # Explicit form  
  2. >>> Entry.objects.filter(blog__id=3)        # __exact is implied  
  3. >>> Entry.objects.filter(blog__pk=3)        # __pk implies __id__exact  

 

like 语句转义百分号

Python代码  django+python 操作数据库
  1. Entry.objects.filter(headline__contains='%')  

 转义为

Sql代码  django+python 操作数据库
  1. SELECT ... WHERE headline LIKE '%\%%';  

 

缓存查询集

 

每个QuerySet都包含一个缓存，以尽量减少对数据库的访问。理解他的工作原理很重要，可以写出最高效的代码。

在最新创建的QuerySet里，缓存是空的。在第一次QuerySet被取值，因此数据库查询发生，django把查询结果放入缓存，并返回给请求，随后的查询取值会复用缓存中的结果。

 

保持缓存的思想习惯，因为如果你不正确使用查询缓存会有麻烦。例如下面例子会创建两个QuerySet

Python代码  django+python 操作数据库
  1. >>> print [e.headline for e in Entry.objects.all()]  
  2. >>> print [e.pub_date for e in Entry.objects.all()]  

 这样意味着数据库查询会执行两次，实际两次数据库加载

为了避免这个问题，简单保存QuerySet复用

Python代码  django+python 操作数据库
  1. >>> queryset = Poll.objects.all()  
  2. >>> print [p.headline for p in queryset] # Evaluate the query set.  
  3. >>> print [p.pub_date for p in queryset] # Re-use the cache from the evaluation.  

 

通过Q对象进行复合查询

 

关键字查询使用filter 是 and集合，如果你想要执行更多的复合查询如“or”可以Q对象。

Q对象（django.db.models.Q）是一个关键字集合封装的参数。

例如

Python代码  django+python 操作数据库
  1. Q(question__startswith='What')  

 Q对象可以使用 & 和 |链接

例如一个OR查询

Python代码  django+python 操作数据库
  1. Q(question__startswith='Who') | Q(question__startswith='What')  

 相当于下面的SQL

Sql代码  django+python 操作数据库
  1. WHERE question LIKE 'Who%' OR question LIKE 'What%'  

 取消一个Q对象使用~

Python代码  django+python 操作数据库
  1. Q(question__startswith='Who') | ~Q(pub_date__year=2005)  

 可以传入多个Q对象

Python代码  django+python 操作数据库
  1. Poll.objects.get(  
  2.     Q(question__startswith='Who'),  
  3.     Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))  
  4. )  

 翻译成SQL

Python代码  django+python 操作数据库
  1. SELECT * from polls WHERE question LIKE 'Who%'  
  2.     AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')  
 

 

比较对象

 

比较两个模型实例，使用python标准的运算符，两个等号==

 

Python代码  django+python 操作数据库
  1. >>> some_entry == other_entry  
  2. >>> some_entry.id == other_entry.id  
  3. >>> some_obj == other_obj  
  4. >>> some_obj.name == other_obj.name  

 

删除对象

 

删除方法是很方便的，方法名为delete()，这个方法直接删除对象没有返回值

例如

Python代码  django+python 操作数据库
  1. e.delete()  

 你也可以批量删除对象，每个QuerySet有一个delete()方法，能删除QuerySet里所有对象

例如：删除pub_date为2005年的对象

 

一次修改多个对象

 

有时候你想给QuerySet里所有对象的一个字段赋予特定值，你可以使用update()方法

例如

Python代码  django+python 操作数据库
  1. # Update all the headlines with pub_date in 2007.  
  2. Entry.objects.filter(pub_date__year=2007).update(headline='Everything is the same')  
 

这个方法只能用于无关联字段和外键

Python代码  django+python 操作数据库
  1. >>> b = Blog.objects.get(pk=1)  
  2.   
  3. # Change every Entry so that it belongs to this Blog.  
  4. >>> Entry.objects.all().update(blog=b)  
 

update()方法不返回任何值，QuerySet不支持save方法，如果要执行save，可以如下：

Python代码  django+python 操作数据库
  1. for item in my_queryset:  
  2.     item.save()  
 

update也可以使用F()

 

Python代码  django+python 操作数据库
  1. # THIS WILL RAISE A FieldError  
  2. >>> Entry.objects.update(headline=F('blog__name'))  
 

关系对象

 

当你在model里定义一个关系时，模型实例会有一个方便的API来访问关系对象。用本页上面的模型举个例子，一个Entry

对象可以得到blog对象，访问blog属性e.blog。

django也创建API来访问关系对象的另一边，一个blog对象访问Entry列表b.entry_set.all().

 

One-to-many关系

 

如果一个对象有ForeignKey，这个模型实例访问关系对象通过简单的属性

Python代码  django+python 操作数据库
  1. >>> e = Entry.objects.get(id=2)  
  2. >>> e.blog # Returns the related Blog object.  

 你可以凭借外键属性获取和赋值，修改外键值知道执行save()方法才会保存到数据库

 

Python代码  django+python 操作数据库
  1. >>> e = Entry.objects.get(id=2)  
  2. >>> e.blog = some_blog  
  3. >>> e.save()  

如果ForeignKey  设置了null=True 你可以赋值为None

 

Python代码  django+python 操作数据库
  1. >>> e = Entry.objects.get(id=2)  
  2. >>> e.blog = None  
  3. >>> e.save() # "UPDATE blog_entry SET blog_id = NULL ...;"  

 

Python代码  django+python 操作数据库
  1. >>> e = Entry.objects.get(id=2)  
  2. >>> print e.blog  # Hits the database to retrieve the associated Blog.  
  3. >>> print e.blog  # 不会在向数据库取; 使用缓存中的值.  
  Python代码  django+python 操作数据库
  1. >>> e = Entry.objects.select_related().get(id=2)  
  2. >>> print e.blog  # 不会在向数据库取; 使用缓存中的值.  
  3. >>> print e.blog  # 不会在向数据库取; 使用缓存中的值.  
   Python代码  django+python 操作数据库
  1. >>> b = Blog.objects.get(id=1)  
  2. >>> b.entry_set.all() # 返回所有blog的关联对象.  
  3.   
  4. # b.entry_set is a Manager that returns QuerySets.  
  5. >>> b.entry_set.filter(headline__contains='Lennon')  
  6. >>> b.entry_set.count()  
  7.   
  8.   
  9. >>> b = Blog.objects.get(id=1)  
  10. >>> b.entries.all() # 返回所有blog的关联对象  
  11.   
  12. # b.entries is a Manager that returns QuerySets.  
  13. >>> b.entries.filter(headline__contains='Lennon')  
  14. >>> b.entries.count()  
 

add(obj1, obj2, ...)增加多个关系对象

create(**kwargs)建立新对象

remove(obj1, obj2, ...)去除多个关系对象

clear()清理所有关系对象

 

Python代码  django+python 操作数据库
  1. b = Blog.objects.get(id=1)  
  2. b.entry_set = [e1, e2]  
 

Many-to-many关系

Python代码  
  1. e = Entry.objects.get(id=3)  
  2. e.authors.all() # 返回Entry所有authors .  
  3. e.authors.count()  
  4. e.authors.filter(name__contains='John')  
  5.   
  6. a = Author.objects.get(id=5)  
  7. a.entry_set.all() # 返回Author所有entry .  
 

One-to-one关系

 

Python代码  
  1. class EntryDetail(models.Model):  
  2.     entry = models.OneToOneField(Entry)  
  3.     details = models.TextField()  
  4.   
  5. ed = EntryDetail.objects.get(id=2)  
  6. ed.entry # 返回 Entry 对象.  
标签：

相关文章