python-django-ORM，常用查询方式

介绍django model 的一些常用查询方式

首先是一些文档性的帮助

__exact 精确等于 like ‘aaa’
__iexact 精确等于 忽略大小写 ilike ‘aaa’
__contains 包含 like ‘%aaa%’
__icontains 包含 忽略大小写 ilike ‘%aaa%’，但是对于sqlite来说，contains的作用效果等同于icontains。
__gt 大于
__gte 大于等于
__lt 小于
__lte 小于等于
__in 存在于一个list范围内
__startswith 以…开头
__istartswith 以…开头 忽略大小写
__endswith 以…结尾
__iendswith 以…结尾，忽略大小写
__range 在…范围内
__year 日期字段的年份
__month 日期字段的月份
__day 日期字段的日
__isnull=True/False
__isnull=True 与 __exact=None的区别

然后是列一些实例：

 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
22     def __unicode__(self):
23         return self.headline

　　这里一个Entry关联一个blog和多个Authors

　　对对象的一些操作：

增加：

　　通过save()方法

from mysite.blog.models import Blog

b = Blog(name=’Beatles Blog’, tagline=’All the latest Beatles news.’)
b.save()

修改：

　　也可通过save方法

1  b5.name = ‘New name’
2  b5.save()

　　关于有外键的，可以直接通过参数列表或者赋值后save.

1 cheese_blog = Blog.objects.get(name=”Cheddar Talk”)
2 entry.blog = cheese_blog
3 entry.save()

　　关于有多对多关系的，不能直接更新，需要model实例.多对多关系的成员名.add(model)。

joe = Author.objects.create(name=”Joe”)
entry.authors.add(joe)

查找：

　　检索所有对象：

 all_entries = Entry.objects.all()

　　检索特定的对象
　　　　使用以下两个方法：
　　　　fileter(**kwargs)
　　　　返回一个与参数匹配的QuerySet,相当于等于(=).
　　　　exclude(**kwargs)
　　　　返回一个与参数不匹配的QuerySet,相当于不等于(!=)。

　　QuerySet方法

1 # 这是查找前5个entry表里的数据
2 Entry.objects.all()[:5]
3 # 这是查找从第5个到第10个之间的数据。
4 Entry.objects.all()[5:10]
5 # 这是查询从第0个开始到第10个，步长为2的数据。
6 Entry.objects.all()[:10:2]
7 # 模糊查询
8 Entry.objects.get(headline__contains=’Lennon’)  

　　接下来是一些ORM提供的比较酷的方法：

 1 Entry.objects.filter(blog__name__exact=’Beatles Blog’)
 2 # 查找entry表中外键关系blog_name=’Beatles Blog’的Entry对象。
 3 Blog.objects.filter(entry__headline__contains=’Lennon’)
 4 # 查找blog表中外键关系entry表中的headline字段中包含Lennon的blog数据。
 5 Blog.objects.filter(entry__author__name=’Lennon’)
 6 # 查找blog表中外键关系entry表中的author字段中包含Lennon的blog数据。
 7 Blog.objects.filter(entry__author__name__isnull=True)
 8 Blog.objects.filter(entry__author__isnull=False,entry__author__name__isnull=True)
 9 # 查询的是author_name为null的值
10
11 Blog.objects.filter(entry__headline__contains=’Lennon’,entry__pub_date__year=2008)
12 Blog.objects.filter(entry__headline__contains=’Lennon’).filter( entry__pub_date__year=2008)
13 # 这两种查询在某些情况下是相同的，某些情况下是不同的。第一种是限制所有的blog数据的，而第二种情况则是第一个filter是
14 # 限制blog的，而第二个filter则是限制entry的
15
16  Blog.objects.filter(pk__in=[1,4,7])
17  # id in 1,4,7
18  Blog.objects.filter(pk__gt=14)
19  # id = 14

　　Q对象的复杂查询　

1 Q(question__startswith=’Who’) | Q(question__startswith=’What’)
2
3 Poll.objects.get(Q(question__startswith=’Who’),
4         Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
5         )

删除:

Entry.objects.filter(pub_date__year=2005).delete()
Entry.objects.all().delete()

反向查询:

　　先展示一个model

 1 from django.db import models
 2
 3 class Publisher(models.Model):
 4
 5     name = models.CharField(max_length=30)
 6     address = models.CharField(max_length=50)
 7     city = models.CharField(max_length=60)
 8     state_province = models.CharField(max_length=30)
 9     country = models.CharField(max_length=50)
10     website = models.URLField()
11
12     def __unicode__(self):
13         return self.name
14
15 class Author(models.Model):
16
17     first_name = models.CharField(max_length=30)
18     last_name = models.CharField(max_length=40)
19     email = models.EmailField()
20
21     def __unicode__(self):
22         return u‘%s %s‘ % (self.first_name, self.last_name)
23 class Book(models.Model):
24
25     title = models.CharField(max_length=100)
26     authors = models.ManyToManyField(Author)
27     publisher = models.ForeignKey(Publisher)
28     publication_date = models.DateField()
29
30     def __unicode__(self):
31     return self.title

　　一个作者一本书和一个出版社，一本书可以被多个作者撰写，但是只属于一个出版社

　　反向查询方法：

p = Publisher.objects.get(name=‘Apress Publishing‘)
p.book_set.filter(name__icontains=‘django‘)
# 属性名称book_set是由模型名称的小写 ( 如 book) 加_set组成的。
# 通过出版社，得到与它有外键关联的书籍名称叫django的书

　　访问多对多：

1 b = Book.objects.get(id=50)2 b.authors.all()