DJANGO 数据库API (转) 很有用

DJANGO 数据库API (转)

数据库 API 参考

作者:

Django 团队

译者:

weizhong2004@gmail.com

翻译开始日期:

2006-04-04

翻译完成日期:

2006-04-05

更新日期:

2006-04-19

原文版本:

2741

一旦 数据模型 创建完毕, 自然会有存取数据的需要.本文档介绍了由 models 衍生而来的数据库抽象API,及如何创建,得到及更新对象.

贯穿本参考, 我们都会引用下面的民意测验(Poll)应用程序:

class Poll(models.Model):
    slug = models.SlugField(unique_for_month='pub_date')
    question = models.CharField(maxlength=255)
    pub_date = models.DateTimeField()
    expire_date = models.DateTimeField()

    def __repr__(self):
        return self.question

    class Meta:
        get_latest_by = 'pub_date'

class Choice(models.Model):
    poll = models.ForeignKey(Poll, edit_inline=models.TABULAR,
        num_in_admin=10, min_num_in_admin=5)
    choice = models.CharField(maxlength=255, core=True)
    votes = models.IntegerField(editable=False, default=0)

    def __repr__(self):
        return self.choice

及下面的简单会话:

>>> from datetime import datetime
>>> p1 = Poll(slug='whatsup', question="What's up?",
...     pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 4, 20))
>>> p1.save()
>>> p2 = Poll(slug='name', question="What's your name?",
...     pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 3, 25))
>>> p2.save()
>>> Poll.objects.all()
[What's up?, What's your name?]

查询如何运作

Django 的数据查询基于构建结果集及对结果集进行取值.结果集是独立于数据库的符合某个查询条件的一组数据对象的集合.这是一个惰性集合:在对该集合取值之前,无法知道该集合有哪些成员.

要生成一个满足你需求的结果集,首先要得到一个描述给定类型的所有对象的初始结果集.这个初始结果集可以通过一系列函数进行更精细的优化处理.当经 过处理后的结果集符合你的要求时, 就可以对它进行取值操作(使用迭代操作,slicing操作,或一系列其它技术),以得到一个你需要的对象或对象的列表.

获得初始结果集

每个 Django model 都有一个与生俱来的管理器对象 objects, 管理器最重要的角色就是作为初始结果的来源. 一个管理器就是一个描述给定类型所有对象的特殊的初始结果集. Poll.objects就是包含所有 Poll 对象的一个初始结果集. 它唯一特殊之处在于它不能被取值. 要克服此限制, 管理器对象有一个 all()方法. 该方法生成一个 可以 被取值的初始结果集的拷贝:

all_polls = Poll.objects.all()

参阅 Model API 的 Managers小节以了解管理器的定位及创建细节.

优化定制结果集

管理器提供的初始结果集描述了给定类型的所有对象.不过通常你只需要这个对象集合中的一小部分(一个子集).

要生这样一个结果集,你需要对初始结果集进行优化定制处理, 增加一些限制条件直到描述的子集满足你的需要.最常用的两个定制结果集的方法是:

filter(**kwargs)返回一个匹配查询参数的新的结果集. exclude(**kwargs)返回一个不匹配查询参数的新的结果集.

参数格式在下面 "字段查询" 小节有描述.

这两个方法的返回值都是结果集对象,因此结果集可以进行链式处理:

Poll.objects.filter(
    question__startswith="What").exclude(
        pub_date__gte=datetime.now()).filter(
            pub_date__gte=datetime(2005,1,1))

...以一个初始结果集作为参数, 然后进行过滤, 再进行排除, 再进行另一个过滤. 这样得到的最 终结果就一个问题开头单词是 "What", 发布日期在 2005年1月1日至今的所有民意测验的集合.

每个结果集都是一个独一无二的对象. 以上操作的每一步都生成了一个新的结果集:

q1 = Poll.objects.filter(question__startswith="What")
q2 = q1.exclude(pub_date__gte=datetime.now())
q3 = q1.filter(pub_date__gte=datetime.now())

这三步生成了三个结果集; 一个初始结果集包含所有的以"What"开头的民意测验, 两个初始结果集的子集(一个排除条件,一个过滤条件).对原始结果集的改进过程并没有影响到原始的结果集.

值得注意的是结果集的创建根本没有访问数据库.只有当对结果集取值时才会访问数据库.

字段查询

以 field__lookuptype (注意是双下线)形式进行基本的字段查询,举例来说:

polls.objects.filter(pub_date__lte=datetime.now())

该查询翻译成SQL就是:

SELECT * FROM polls_polls WHERE pub_date <= NOW();

实现细节

Python 能够在定义函数时接受任意的 name-value(names和values均可以在运行时通过计算得到)参数. 要了解更多信息,参阅官方 Python 教程中的 关键字参数.

DB API 支持下列查找类型:

类型 描述

exact	精确匹配: polls.get_object(id__exact=14).
iexact	忽略大小写的精确匹配:polls.objects.filter(slug__iexact="foo")匹配 foo, FOO,fOo, 等等.
contains	大小写敏感的内容包含测试:polls.objects.filter(question__contains="spam")返回question 中 包含 "spam" 的所有民意测验.(仅PostgreSQL 和 MySQL支持. SQLite的LIKE 语句不支持大小写敏感特性. 对Sqlite 来说, contains等于 icontains.)
icontains	大小写不敏感的内容包含测试:
gt	大于: polls.objects.filter(id__gt=4).
gte	大于等于.
lt	小于.
lte	小于等于.
ne	不等于.
in	位于给定列表中: polls.objects.filter(id__in=[1,3,4])返回一个polls 列表(ID 值分别是 1或3或4).
startswith	大小写敏感的 starts-with:polls.objects.filter(question__startswith="Would").(仅PostgreSQL和MySQL支持. SQLite 的LIKE 语句不支持大小写敏感特性. 对Sqlite来说,``startswith`` 等于 istartswith)
endswith	大小写敏感的 ends-with. (仅PostgreSQL 和 MySQL)
istartswith	大小写不敏感的 starts-with.
iendswith	大小写不敏感的 ends-with.
range	范围测试:polls.objects.filter(pub_date__range=(start_date,end_date))返回 pub_date 位于 start_date和 end_date (包括)之间的 所有民意测验
year	对 date/datetime 字段, 进行精确的 年 匹配:polls.get_count(pub_date__year=2005).
month	对 date/datetime 字段, 进行精确的 月 匹配:
day	对 date/datetime 字段, 进行精确的 日 匹配:
isnull	True/False; 做 IF NULL/IF NOT NULL 查询:polls.objects.filter(expire_date__isnull=True).

如果未提供查找类型, 系统就认为查找类型是 exact . 下面两个语句是等价的:

Poll.objects.get(id=14)
Poll.objects.get(id__exact=14)

查询允许多个条件参数, 逗号分隔的多个条件参数会被 "AND" 起来使用:

polls.objects.filter(
    pub_date__year=2005,
    pub_date__month=1,
    question__startswith="Would",
)

...得到2005年1月公布的带有一个"Would"开头的问题的所有民意测验.

为了使用更加方便, 还提供有一个 pk查找类型, 可以翻译成 (primary_key)__exact. 在这个民意测试的例子里, 下面两个语句是等价的.:

polls.get_object(id__exact=3)
polls.get_object(pk=3)

pk也可以通过连接进行查询. 在这个民意测试的例子里, 下面两个语句是等价的:

choices.objects.filter(poll__id__exact=3)
choices.objects.filter(poll__pk=3)

如果传递的关键字参数非法, 将引发 TypeError异常.

OR 查询

关键字参数查询的各个条件都是 "AND" 关系. 如果你需要一个复杂的查询(举例来说,你需要一个 OR语句), 你需要使用 Q对象.

Q对象是 django.core.meta.Q的实例, 用来装载一系列关键字参数. 这些关键字参数就象指定给 get() 和 filter() 函数的关键字参数一样. 举例来说:

Q(question__startswith='What')

Q对象可以使用 &和 |运算符进行组合. 当两个Q对象进行 & 或 | 运算时,会生成一个新的Q对象.举例来说语句:

Q(question__startswith='Who') | Q(question__startswith='What')

... 生成一个新的 Q对象表示这两个 "question__startswith" 查询条件的 "OR" 关系. 等同于下面的 SQL WHERE 子句:

... WHERE question LIKE 'Who%' OR question LIKE 'What%'

通过对多个 Q对象的 &和 |运算你能得到任意复杂的查询语句. 也可以使用圆括号分组.

查询函数可以接受一个或多个 Q对象作为参数.如果提供有多个 Q对象参数, 它们将被 "AND" 到一起.举例来说:

polls.get_object(
    Q(question__startswith='Who'),
    Q(pub_date__exact=date(2005, 5, 2)) | Q(pub_date__exact=date(2005, 5, 6))
)

... 翻译成 SQL 就是这样:

SELECT * from polls WHERE question LIKE 'Who%'
    AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

如果需要,查询函数可以混合使用 Q对象参数和关键字参数. 所有提供给查询函数的参数(不管是关键字参数还是Q对象)都被 "AND" 到一起.如果提供了 Q对象作为参数,它就必须在其它关键字参数(如果有的话)的前面.举例来说:

polls.get_object(
    Q(pub_date__exact=date(2005, 5, 2)) | Q(pub_date__exact=date(2005, 5, 6)),
    question__startswith='Who')

... 这是一个合法的查询, 等价于前一个例子,不过:

# INVALID QUERY
polls.get_object(
    question__startswith='Who',
    Q(pub_date__exact=date(2005, 5, 2)) | Q(pub_date__exact=date(2005, 5, 6)))

... 这个查询则不符合我们的规则,会引发异常.

Q对象也可以以 complex关键字参数的形式使用. 举例来说:

polls.get_object(
    complex=Q(question__startswith='Who') &
        (Q(pub_date__exact=date(2005, 5, 2)) |
         Q(pub_date__exact=date(2005, 5, 6))
    )
)

参阅 OR 查询示例 以阅读更多实例.

从结果集中取值

只有通过取值操作才能得到结果集包含的对象.取值操作可以通过迭代,切片,或其它专门的函数来实现.

一个结果集就是一个可迭代对象.因此,可以通过一个循环来取出它的值:

for p in Poll.objects.all():
    print p

将使用 Poll 对象的 __repr__()方法打印出所有的 Poll 对象.

一个结果集也可以被切片, 使用数组符号操作:

fifth_poll = Poll.objects.all()[4]
all_polls_but_the_first_two = Poll.objects.all()[2:]
every_second_poll = Poll.objects.all()[::2]

结果集对象是惰性对象 - 也就是说,他们不是 真正的 包含他们表示对象的集合 (或列表). Python 的协议魔法让结果集看起来是一个可迭代,可切片的对象. 事实上在幕后, Django 使用了缓存技术..

如果你真的需要一个列表, 你可以强制对一个惰性对象取值:

querylist = list(Poll.objects.all())

不过,最好不要这么做,尤其当一个结果集相当大时. 由于 Django 要创建每一个对象的内存表示,这将占用相当大的内存.

结果集及其缓存行为

每个结果集都包含一个 cache. 对一个新创建的结果集来说, 缓存区是空的.当一个结果集第一次被取值, Django 会进行一次数据库查询,并将查询结果放入缓存中, 之后返回用户需要的数据. 后面的取值操作会使用缓存中的数据而不用再次访问数据库.

必须时刻记住:结果集具有缓存行为. 下面两行语句生成了两个临时的结果集,并进行了取值,之后舍弃:

print [p for p in Poll.objects.all()] # Evaluate the Query Set
print [p for p in Poll.objects.all()] # Evaluate the Query Set again

对一个小型的,低流量的站点来说,这不会造成严重问题.不过,对一个高访问量的站点来说,它双倍增加了数据库服务器的负担.另外,由于在两次操作之间可能有其它的用户增加或删除了投票,因此这两次操作得到结果可能并不相同.

要避免这个问题, 保存这个结果集并在后面重用该结果集:

queryset = Poll.objects.all()
print [p for p in queryset] # Evaluate the query set
print [p for p in queryset] # Re-use the cache from the evaluation

专门的结果集取值函数

下面这些函数也可以用来从一个结果集中取值.不同于迭代及切片操作,这些方法不具有缓存行为.每次使用这些函数,都会访问数据库.

get(**kwargs)

以下文描述的 "字段查询" 格式返回匹配查找参数的对象.如果没有找到符合给定参数的对象,会引发一个模块级的 DoesNotExist异常.如果找到不止一个对象,引发 AssertionError异常.

count()

返回结果集的行数.``count()`` 永远不会引发异常.

根据你使用的数据库引擎 (比如 PostgreSQL vs. MySQL), 它可能返回一个长整数而不是普通整数.

in_bulk(id_list)

接受一个 ID 列表作为参数, 返回一个字典(每个ID映射一个具有给定ID的对象实例). 也接受可选的关键字查询参数(参数格式在下面 "字段查询" 小节有描述),这里有一个例子,使用上面定义的 Poll model.

>>> Poll.objects.in_bulk([1])
{1: What's up?}
>>> Poll.objects.in_bulk([1, 2])
{1: What's up?, 2: What's your name?}
>>> Poll.objects.in_bulk([])
{}

latest(field_name=None)

根据 model 的 'get_latest_by' 选项或可选的字段名参数返回最新的对象.例子:

>>> Poll.objects.latest()
What's up?
>>> Poll.objects.latest('expire_date')
What's your name?

关系 (连接)

当你在 model 中定义了一个关系字段(也就是,一个ForeignKey, OneToOneField, 或 ManyToManyField). Django 使用关系字段的名字为 model 的每个实例添加一个 描述符. 在访问对象或关联对象时, 这个描述符就象一个常规属性. 举例来说, mychoice.poll会返回 Choice实例对象关联的 Poll对象.

通过下面的关系,连接可以以非显式的方式进行:choices.objects.filter(poll__slug="eggs")得到一个 Choice对象列表, 这些对象关联的 Poll 对象的 slug 字段值为 eggs.允许多级连接.

通过一个对象实例的便利函数(convenience functions)就可直接查询该对象的关联对象. 举例来说, 如果 p是一个 Poll实例, p.choice_set()将返回所有关联的 Choice 对象列表. 聪明的读者会注意到它等价于 choices.objects.filter(poll__id=p.id), 只是更加清晰.

每一种关系类型会为关系中的每个对象自动创建一系列便利方法(类似 choice_set()这样的方法).这些方法被双向创建, 这样被关联的对象就不需要明确的定义反向关系, 这一切都是自动完成的.

One-to-one relations

one-to-one 关系中的每个对象拥有一个 get_relatedobjectname()方法. 举例来说:

class Place(meta.Model):
    # ...

class Restaurant(meta.Model):
    # ...
    the_place = meta.OneToOneField(places.Place)

在上面的例子里, 每个 Place会自动拥有一个 get_restaurant()方法, 且每个 Restaurant会自动拥有一个 get_the_place()方法.

Many-to-one relations

在 many-to-one 关系中, 关联对象(Many)会自动拥有一个 get_relatedobject()方法. 被关联的对象(one)会自动拥有 get_relatedobject(), get_relatedobject_list(), 和 get_relatedobject_count()方法 (功能与模块级的 get_object(), filter(), 和 get_count()相同).

在上面的民意测试例子里, 一个 Poll对象 p自动拥有下列方法:

p.get_choice()
p.get_choice_list()
p.get_choice_count()

Choice对象 c则自动拥有下面的方法:

c.get_poll()

Many-to-many 关系

Many-to-many 关系类似`Many-to-one relations`_, 它生成同样的方法集.例外的是关联对象的 get_relatedobject_list()方法返回一个实例的列表而不是一个仅一个实例.因此,若 Poll和 Choice是 many-to-many 关系, choice.get_poll_list()将返回一个列表.

专门的结果集

除 filter和 exclude()之外, Django 提供了一系列结果集处理方法, 修改结果的类型, 或修改 sql 查询在数据库执行的方式.

order_by(*fields)

根据 model 中提供 ordering tuple, 结果集会被自动排序. 不过, 排序也可以通过 order_by方法显式的进行:

Poll.objects.filter(pub_date__year=2005,
    pub_date__month=1).order_by('-pub_date', 'question')

结果集将按降序排列 pub_date, 然后按升序排列 question."-pub_date" 中的负号表示降序(递减).要取随机序,使用"?", 象下面这样:

Poll.objects.order_by=('?')

要按另一个表中的字段排序, 添加另一个表的名字和一个句点,象下面这样:

Choice.objects.order_by=('Poll.pub_date', 'choice')

无法指定排序是否大小写敏感, 不管你的数据库后端如何排序, Django都会以大小写敏感的方式重新排序结果集.. (这样是不是会降低效率? 不能关掉这个特性么?)

distinct()

默认的, 一个结果集不会自动除去重复的行. 尤其当你进行跨关系查询时, 很容易出现重复的行.

distinct()返回一个除去了重复行的新的结果集,它等价于 SELECTDISTINCT SQL 语句.

values(*fields)

类似 filter(), 不过它返回一个字典的列表而不是 model 实例对象的列表.

它接受一个可选参数: fields, 这是一个字段名列表或tuple.如果你没有指定 fields, 每个字段都会返回.否则就只返回你指定的字段名和值.这里有一个例子,使用上面定义的 Poll model

>>> from datetime import datetime
>>> p1 = Poll(slug='whatsup', question="What's up?",
...     pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 3, 20))
>>> p1.save()
>>> p2 = Poll(slug='name', question="What's your name?",
...     pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 4, 20))
>>> p2.save()
>>> Poll.objects.all()
[What's up?, What's your name?]
>>> Poll.objects.values()
[{'id': 1, 'slug': 'whatsup', 'question': "What's up?", 'pub_date': datetime.datetime(2005, 2, 20), 'expire_date': datetime.datetime(2005, 3, 20)},
 {'id': 2, 'slug': 'name', 'question': "What's your name?", 'pub_date': datetime.datetime(2005, 3, 20), 'expire_date': datetime.datetime(2005, 4, 20)}]
>>> Poll.objects.values(fields=['id', 'slug'])
[{'id': 1, 'slug': 'whatsup'}, {'id': 2, 'slug': 'name'}]

当你知道你要取得哪些字段的值时并且你不需要那些 model实例对象的功能时,使用 values()函数.它具有上佳的效率..

dates(field, kind, order='ASC')

每个管理器拥有一个 dates()方法, 它返回一个 datetime.datetime对象的列表, 表示经过给定的过滤器(由 kind参数定义)过滤后的所有可用的 dates .

field是 model 模块中的一个 DateField或 DateTimeField属性名.

kind是 "year", "month"或 "day"中的一个. 结果列表中的每个 datetime.datetime对象被截短为给定的 type形式.

• "year"返回一个该字段的不重复的年的列表.
• "month"返回一个该字段的不重复的年/月的列表.
• "day"返回一个该字段的不重复的年/月/日的列表.

order只能是 "ASC"或 "DESC", 默认值是 'ASC'. 它指定如何排序结果.

这里有一个例子, 使用上面定义的 Poll model

>>> from datetime import datetime
>>> p1 = Poll(slug='whatsup', question="What's up?",
...     pub_date=datetime(2005, 2, 20), expire_date=datetime(2005, 3, 20))
>>> p1.save()
>>> p2 = Poll(slug='name', question="What's your name?",
...     pub_date=datetime(2005, 3, 20), expire_date=datetime(2005, 4, 20))
>>> p2.save()
>>> Poll.objects.dates('pub_date', 'year')
[datetime.datetime(2005, 1, 1)]
>>> Poll.objects.dates('pub_date', 'month')
[datetime.datetime(2005, 2, 1), datetime.datetime(2005, 3, 1)]
>>> Poll.objects.dates('pub_date', 'day')
[datetime.datetime(2005, 2, 20), datetime.datetime(2005, 3, 20)]
>>> Poll.objects.dates('pub_date', 'day', order='DESC')
[datetime.datetime(2005, 3, 20), datetime.datetime(2005, 2, 20)]
>>> Poll.objects.filter(question__contains='name').dates('pub_date', 'day')
[datetime.datetime(2005, 3, 20)]

select_related()

关系是数据库的根本, select_related()方法"追踪" 所有的关系对象, 并将它们预先存放到一个简单的缓存中.这样当需要调用一个具有一对多关系的对象时就不必再次访问数据库.要做到这一点, 只需对一个结果集使用 select_related()方法.这可能导致(某些时候相当)大的(有可能是不必要的)查询, 但这却意味着后续的关系使用会快很多.(俺的建议:对一个频繁变化的多用户数据库,不要使用该参数)

举例来说, 上面的 Poll 和 Choice models 中, 如果你这样做:

c = Choice.objects.select_related().get(id=5)

那么后面的 c.poll()将不用访问数据库.

注意这个 select_related方法会尽可能远的追踪外键. 如果你有下面的 models:

class Poll(models.Model):
    # ...

class Choice(models.Model):
    # ...
    poll = models.ForeignKey(Poll)

class SingleVote(meta.Model):
    # ...
    choice = models.ForeignKey(Choice)

那么调用 SingleVotes.objects.select_related().get(id=4)会缓存相关的 choice 和 相关的 poll:

>>> sv = SingleVotes.objects.select_related().get(id=4)
>>> c = sv.choice        # Doesn't hit the database.
>>> p = c.poll           # Doesn't hit the database.

>>> sv = SingleVotes.objects.get(id=4)
>>> c = sv.choice        # Hits the database.
>>> p = c.poll           # Hits the database.

extra(params, select, where, tables)

有时候, Django 提供的查询语法不太够用. 为了满足这些边缘需求, Django 提供了 extra()结果集修改器 - 一种提供额外查询参数的机制.

要注意这些额外的方式对不同的数据库引擎可能存在移植性问题.(因为你在显式的书写SQL语句),除非万不得已,尽量避免这样做:

params

下面描述的所有 额外-SQL 参数都必须是标准 Python 字符串格式(数据库引擎会自动用引号将它引起).``params`` 参数可以包含任意多个的SQL参数.

select

select关键字参数允许你选择特定的字段. 它是一个字典(属性名与 SQL 语句的映射). 举例来说:

    Poll.objects.extra(
        select={
            'choice_count': 'SELECT COUNT(*) FROM choices WHERE poll_id = polls.id'
        }
    )

每个返回的 ``Poll`` 对象会有一个额外的属性: ``choice_count``, 一个关联`` Choice`` 对象的整数. 注意大多数数据库引擎需要用括号将子查询括起来. Django 的 ``select`` 子句则不需要这个括号.

where / tables如果你需要传递一个额外的 WHERE子句 -- 比方进行一个非显式的连接--你可以使用 where关键字参数. 如果你需要在查询中连接其它的表,你可以传递它们的名字给 tables参数.

where和 tables都接受一个字符串列表作为它们的值.所有的 where参数都被 "AND" 到其它的查询条件中.

举例来说:

    Poll.objects.filter(
        question__startswith='Who').extra(where=['id IN (3, 4, 5, 20)'])

...翻译成 SQL 语句就是::

    SELECT * FROM polls_polls WHERE question LIKE 'Who%' AND id IN (3, 4, 5, 20);

改变对象

一旦你使用任何上面介绍的方法从数据库中得到一个对象, 改变这个对象就是相当容易的一件事情了.直接操作这些对象的字段,然后调用 save()方法保存它们:

>>> p = Poll.objects.get(id__exact=15)
>>> p.slug = "new_slug"
>>> p.pub_date = datetime.datetime.now()
>>> p.save()

创建对象

通过创建一个新的实例并调用 save() 保存之,就可以创建一个新的数据记录(也就是 INSERT):

>>> p = Poll(slug="eggs",
...                question="How do you like your eggs?",
...                pub_date=datetime.datetime.now(),
...                expire_date=some_future_date)
>>> p.save()

一个主键值为 None的对象调用 save()方法表示这是一个新记录,应该被插入到数据表中.

通过便利方法(convenience function)可以很容易的创建关联对象 (比如 Choices):

>>> p.choice_set.create(choice="Over easy", votes=0)
>>> p.choice_set.create(choice="Scrambled", votes=0)
>>> p.choice_set.create(choice="Fertilized", votes=0)
>>> p.choice_set.create(choice="Poached", votes=0)
>>> p.choice_set.count()
4

这些 add_choice方法于下面的函数等价(却更简单):

>>> c = Choice(poll_id=p.id, choice="Over easy", votes=0)
>>> c.save()

注意当使用这种 add_foo()`方法时, 你不要给 id字段提供任何值, 也不要给保存关系的字段提供任何值.(此处是 poll_id ).

这类 add_FOO()方法总是返回刚刚创建的对象.

删除对象

如同你想象的一样,删除对象的方法是 delete(). 该方法立即删除该对象并返回 None.比如:

>>> c.delete()

通过使用同样的查询条件(参数), get_object 和其它查询方法也可以用来批量删除对象. 比如:

>>> Polls.objects.filter(pub_date__year=2005).delete()

此举将删除2005年的所有民意测验数据.  注意 delete()是唯一一个管理器对象不能直接访问的结果集方法.这提供了一种安全机制,可以避免发生意外事故: 否则 Poll.objects.delete(), 将删除 所有的 投票.

如果你 真的 想删除表中的所有数据,你只能这么做:

Polls.objects.all().delete()

此举将从数据库中删除所有的 Poll 实例.

比较对象

要比较两个 model 对象, 使用标准的 Python 比较运算符,即双等号: ==. (在幕后进行比较的是两个对象的 主键 的值).

仍然是上面的 Poll例子, 下面两个语句是等价的:

some_poll == other_poll
some_poll.id == other_poll.id

如果一个 model 的主键名字不是 ID, 没问题, 比较总是发生在主键之间,不管它叫什么名字. 举例来说, 如果一个 model 的主键字段叫 name, 则下面这两个语句是等价的:

some_obj == other_obj
some_obj.name == other_obj.name

其它实例方法

除了 save(), delete()和所有的 add_*及 get_*关联对象方法之外,一个 model 对象可能还拥有下面的部分或全部方法:

get_FOO_display()

如果一个字段有 choices选项集事, 这个对象将有一个 get_FOO_display()方法.这里 FOO是该字段的名字. 这个方法返回一个 "human-readable" 的字段值. 举例来说, 下面的model中:

GENDER_CHOICES = (
    ('M', 'Male'),
    ('F', 'Female'),
)
class Person:
    name = models.CharField(maxlength=20)
    gender = models.CharField(maxlength=1, choices=GENDER_CHOICES)

...每个 Person实例会拥有一个 get_gender_display()的方法. 示例:

>>> p = Person(name='John', gender='M')
>>> p.save()
>>> p.gender
'M'
>>> p.get_gender_display()
'Male'

get_next_by_FOO(**kwargs) 和 get_previous_by_FOO(**kwargs)

不存在 null=True的每个 DateField和 DateTimeField自动拥有 get_next_by_FOO()和 get_previous_by_FOO()方法, 此处的 FOO是字段的名字. 它们分别返回该字段的上一个对象和下一个对象. 如果上一对象或下一对象不存在,则抛出 *DoesNotExist异常.

这两个方法均接受可选关键字参数, 这些参数应该遵循上文中 "Field 查询" 中提到的格式.

注意如果遇到相同值的对象, 这些方法会使用 ID 字段进行检查. 这保证了没有一条记录会被跳过或重复记数.参阅 lookup API sample model_ ,那里有一个完整的例子.

get_FOO_filename()

对一个 FileField对象来说, 它自动拥有一个 get_FOO_filename()方法. 这里 FOO是字段名,它根据你的 MEDIA_ROOT设置返回一个完整的路径名称.

注意 ImageField技术上是 FileField的一个子类, 因此每个有 ImageField的 model 自动拥有此方法.

get_FOO_url()

含有 FileField字段的每个对象自动拥有一个 get_FOO_url()方法,这里的 FOO是字段的名字. 该方法根据你的 MEDIA_URL设置返回该文件的完整 URL ,如果 MEDIA_URL设置为空, 该方法返回一个空的字符串.

get_FOO_size()

含有 FileField字段的每个对象自动拥有一个 get_FOO_filename()方法,这里的 FOO是字段的名字. 该方法返回文件的长度(字节数).(在后台, Django 使用 os.path.getsize.)

save_FOO_file(filename, raw_contents)

含有 FileField字段的每个对象自动拥有一个 get_FOO_filename()方法,这里的 FOO是字段的名字. 该方法使用给定的文件名将文件保存到文件系统.. 如果同目录下已经有同名文件存在,Django 会在文件名后添加一个下划线(扩展名之前)直到文件名有效为止(也就是如果加了下划线还重名,就再加....直到没有重名为止).

get_FOO_height() 和 get_FOO_width()

含有 ImageField字段的每个对象自动拥有 get_FOO_height()和 get_FOO_width()方法, 这里的 FOO是字段的名字. 它们返回相应的图片高度和宽度(整数,以像素计).

转自： http://www.cnblogs.com/xiami303/archive/2012/07/12/2588265.html