django高级应用

Django高级应用
出自GongGeng
跳转到： 导航, 搜索
目录

    * 1 URLconf的一些技巧
          o 1.1 视图函数的导入
          o 1.2 使用多个urls前缀
          o 1.3 在debug模式下指定特定的url
          o 1.4 使用命名参数
          o 1.5 向视图函数传递额外参数
                + 1.5.1 URLconf值
                + 1.5.2 生成通用视图
          o 1.6 使用默认参数
          o 1.7 url匹配中的特例
    * 2 包含其他url
          o 2.1 包含其他url
          o 2.2 在包含的url中获取参数和传递额外参数
                + 2.2.1 捕获参数
                + 2.2.2 传递额外参数
    * 3 模板的高级应用
          o 3.1 RequestContext类和Context处理器
          o 3.2 自动进行HTML脱字操作
                + 3.2.1 如何关闭该操作
                + 3.2.2 针对一块数据
          o 3.3 模板加载
          o 3.4 扩展模板系统
                + 3.4.1 定制模板过滤器
                + 3.4.2 定制模板标签
                + 3.4.3 编译函数的编写
                + 3.4.4 创建Node子类
                + 3.4.5 注册标签
    * 4 模型的高级应用
          o 4.1 回顾
          o 4.2 访问外键
          o 4.3 访问多对多关系
          o 4.4 改变数据库模式
                + 4.4.1 添加字段
                + 4.4.2 删除字段
                + 4.4.3 删除多对多字段
                + 4.4.4 删除模型
          o 4.5 管理器
                + 4.5.1 添加额外的管理器
                + 4.5.2 修改查询结果集
          o 4.6 模型方法
          o 4.7 执行原始SQL语句
    * 5 通用视图
          o 5.1 使用通用视图
          o 5.2 通用视图中的对象

URLconf的一些技巧
视图函数的导入

此前的试图函数在urls.py文件的导入如下：

from django.conf.urls.defaults import *
from mysite.views import hello, current_datetime, hours_ahead

urlpatterns = patterns('',
    (r'^hello/$', hello),
    (r'^time/$', current_datetime),
    (r'^time/plus/(\d{1,2})/$', hours_ahead),
)

我们可以采用如下方法来简化导入操作：

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^hello/$', views.hello),
    (r'^time/$', views.current_datetime),
    (r'^time/plus/(d{1,2})/$', views.hours_ahead),
)

还可以进一步简化：

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^hello/$', 'mysite.views.hello'),
    (r'^time/$', 'mysite.views.current_datetime'),
    (r'^time/plus/(d{1,2})/$', 'mysite.views.hours_ahead'),
)

注意不要忘记引号。

此外，我们还可以通过添加前缀的方法：

from django.conf.urls.defaults import *

urlpatterns = patterns('mysite.views',
    (r'^hello/$', 'hello'),
    (r'^time/$', 'current_datetime'),
    (r'^time/plus/(d{1,2})/$', 'hours_ahead'),
)

使用多个urls前缀

原来的代码：

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^hello/$', 'mysite.views.hello'),
    (r'^time/$', 'mysite.views.current_datetime'),
    (r'^time/plus/(\d{1,2})/$', 'mysite.views.hours_ahead'),
    (r'^tag/(\w+)/$', 'weblog.views.tag'),
)

修改后的代码：

from django.conf.urls.defaults import *

urlpatterns = patterns('mysite.views',
    (r'^hello/$', 'hello'),
    (r'^time/$', 'current_datetime'),
    (r'^time/plus/(\d{1,2})/$', 'hours_ahead'),
)

urlpatterns += patterns('weblog.views',
    (r'^tag/(\w+)/$', 'tag'),
)

在debug模式下指定特定的url

方法如下：

from django.conf import settings
from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^$', views.homepage),
    (r'^(\d{4})/([a-z]{3})/$', views.archive_month),
)

if settings.DEBUG:
    urlpatterns += patterns('',
        (r'^debuginfo/$', views.debug),
    )

使用命名参数

修改urlpatterns中的正着表达式，以进行命名参数调用。见下面的示例：未使用：

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^articles/(\d{4})/$', views.year_archive),
    (r'^articles/(\d{4})/(\d{2})/$', views.month_archive),
)

使用后：

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^articles/(?P<year>\d{4})/$', views.year_archive),
    (r'^articles/(?P<year>\d{4})/(?P<month>\d{2})/$', views.month_archive),
)

上面的两部分代码，在调用视图函数时，分别进行如下调用：

month_archive(request, '2006', '03')

month_archive(request, year='2006', month='03')

使用和不使用命名参数时的顺序如下：

    * 如果包含命名参数，则忽略所有未命名参数
    * 如果没有，则使用顺序参数调用
    * 以上两种方式中，都可以传递额外选项。

向视图函数传递额外参数

先看一个例子：

# urls.py

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^foo/$', views.foo_view),
    (r'^bar/$', views.bar_view),
)

# views.py

from django.shortcuts import render_to_response
from mysite.models import MyModel

def foo_view(request):
    m_list = MyModel.objects.filter(is_new=True)
    return render_to_response('template1.html', {'m_list': m_list})

def bar_view(request):
    m_list = MyModel.objects.filter(is_new=True)
    return render_to_response('template2.html', {'m_list': m_list})

URLconf值

通过传递额外参数在处理大量url的同时来处理个别的url请求，请看下面的例子。

我们有如下url请求：

/mydata/jan/01/
/mydata/jan/02/
/mydata/jan/03/
# ...
/mydata/dec/30/
/mydata/dec/31/

对其进行处理的方法是：

urlpatterns = patterns('',
    (r'^mydata/(?P<month>\w{3})/(?P<day>\d\d)/$', views.my_view),
)

视图函数的原型如下：

def my_view(request, month, day):
    # ....

如果我们现在要匹配这样一个url：/mydata/birthday/，而它实际上调用的url等同于/mydata/jan/06/，则我们可以进行如下处理：

urlpatterns = patterns('',
    (r'^mydata/birthday/$', views.my_view, {'month': 'jan', 'day': '06'}),
    (r'^mydata/(?P<month>\w{3})/(?P<day>\d\d)/$', views.my_view),
)

生成通用视图

看如下代码：

def say_hello(person_name):
    print 'Hello, %s' % person_name

def say_goodbye(person_name):
    print 'Goodbye, %s' % person_name

我们可以将其重构为如下代码：

def greet(person_name, greeting):
    print '%s, %s' % (greeting, person_name)

来看一个实际一些的例子：

# urls.py

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^events/$', views.event_list),
    (r'^blog/entries/$', views.entry_list),
)

# views.py

from django.shortcuts import render_to_response
from mysite.models import Event, BlogEntry

def event_list(request):
    obj_list = Event.objects.all()
    return render_to_response('mysite/event_list.html', {'event_list': obj_list})

def entry_list(request):
    obj_list = BlogEntry.objects.all()
    return render_to_response('mysite/blogentry_list.html', {'entry_list': obj_list})

重构后的结果：

# urls.py

from django.conf.urls.defaults import *
from mysite import models, views

urlpatterns = patterns('',
    (r'^events/$', views.object_list, {'model': models.Event}),
    (r'^blog/entries/$', views.object_list, {'model': models.BlogEntry}),
)

# views.py

from django.shortcuts import render_to_response

def object_list(request, model):
    obj_list = model.objects.all()
    template_name = 'mysite/%s_list.html' % model.__name__.lower()
    return render_to_response(template_name, {'object_list': obj_list})

使用默认参数

我们可以通过在视图函数中针对参数添加默认参数来简化处理流程，看如下例子：

# urls.py

from django.conf.urls.defaults import *
from mysite import views

urlpatterns = patterns('',
    (r'^blog/$', views.page),
    (r'^blog/page(?P<num>\d+)/$', views.page),
)

# views.py

def page(request, num='1'):
    # Output the appropriate page of blog entries, according to num.
    # ...

url匹配中的特例

在通过正则表达式处理大量url请求时，可能需要对某个特定的url请求调用不同的视图处理函数。解决的方法是将需要匹配的url特例放在通用的正则表达式前，如下例：

urlpatterns = patterns('',
    # ...
    ('^auth/user/add/$', views.user_add_stage),
    ('^([^/]+)/([^/]+)/add/$', views.add_stage),
    # ...
)

包含其他url
包含其他url

包含其他url的方法如下：

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^weblog/', include('mysite.blog.urls')),
    (r'^photos/', include('mysite.photos.urls')),
    (r'^about/$', 'mysite.views.about'),
)

注意，包含的url行的正则表达式不要写'$'。
在包含的url中获取参数和传递额外参数
捕获参数

# root urls.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^(?P<username>\w+)/blog/', include('foo.urls.blog')),
)

# foo/urls/blog.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^$', 'foo.views.blog_index'),
    (r'^archive/$', 'foo.views.blog_archive'),
)

传递额外参数

# urls.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^blog/', include('inner'), {'blogid': 3}),
)

# inner.py

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^archive/$', 'mysite.views.archive'),
    (r'^about/$', 'mysite.views.about'),
    (r'^rss/$', 'mysite.views.rss'),
)

模板的高级应用
RequestContext类和Context处理器

下面通过一个例子来看一下RequestContext的使用。

from django.template import loader, Context

def view_1(request):
    # ...
    t = loader.get_template('template1.html')
    c = Context({
        'app': 'My app',
        'user': request.user,
        'ip_address': request.META['REMOTE_ADDR'],
        'message': 'I am view 1.'
    })
    return t.render(c)

def view_2(request):
    # ...
    t = loader.get_template('template2.html')
    c = Context({
        'app': 'My app',
        'user': request.user,
        'ip_address': request.META['REMOTE_ADDR'],
        'message': 'I am the second view.'
    })
    return t.render(c)

通过使用RequestContext，就可以简化上面的代码：

from django.template import loader, RequestContext

def custom_proc(request):
    "A context processor that provides 'app', 'user' and 'ip_address'."
    return {
        'app': 'My app',
        'user': request.user,
        'ip_address': request.META['REMOTE_ADDR']
    }

def view_1(request):
    # ...
    t = loader.get_template('template1.html')
    c = RequestContext(request, {'message': 'I am view 1.'},
            processors=[custom_proc])
    return t.render(c)

def view_2(request):
    # ...
    t = loader.get_template('template2.html')
    c = RequestContext(request, {'message': 'I am the second view.'},
            processors=[custom_proc])
    return t.render(c)

上述代码中，我们首先定义了一个custom_proc函数作为上下文处理器，该函数会返回一个字典数据结构。然后用RequestContext替换Context。

为了使用此前介绍的render_to_response()函数，我们可以使用context_instance参数：

from django.shortcuts import render_to_response
from django.template import RequestContext

def custom_proc(request):
    "A context processor that provides 'app', 'user' and 'ip_address'."
    return {
        'app': 'My app',
        'user': request.user,
        'ip_address': request.META['REMOTE_ADDR']
    }

def view_1(request):
    # ...
    return render_to_response('template1.html',
        {'message': 'I am view 1.'},
        context_instance=RequestContext(request, processors=[custom_proc]))

def view_2(request):
    # ...
    return render_to_response('template2.html',
        {'message': 'I am the second view.'},
        context_instance=RequestContext(request, processors=[custom_proc]))

上面的例子中，通过使用context_instance参数，可以继续使用此前的render_to_response()函数。

若经常使用某个处理器，可以在settings.py文件中设置TEMPLATE_CONTEXT_PROCESSORS变量。
自动进行HTML脱字操作

针对html页面，当我们在显示某个变量的时候，有可能会遇到如下情况：

Hello, {{ name }}.

如果name变量中用户输入的内容如下：

<script>alert('hello')</script>

在运行时，该变量就会被替换为如下内容：

Hello, <script>alert('hello')</script>

这样就会造成很多不安全的隐患。为此，django会对输出的内容进行脱字操作。
如何关闭该操作

针对某个输出变量，可以使用safe过滤器：

This will be escaped: {{ data }}
This will not be escaped: {{ data|safe }}

针对一块数据

{% autoescape off %}
    Hello {{ name }}
{% endautoescape %}

还可以嵌套使用：

Auto-escaping is on by default. Hello {{ name }}

{% autoescape off %}
    This will not be auto-escaped: {{ data }}.

    Nor this: {{ other_data }}
    {% autoescape on %}
        Auto-escaping applies again: {{ name }}
    {% endautoescape %}
{% endautoescape %}

注意，上面标记的使用会被模板继承。如下面的例子：

# base.html

{% autoescape off %}
<h1>{% block title %}{% endblock %}</h1>
{% block content %}
{% endblock %}
{% endautoescape %}

# child.html

{% extends "base.html" %}
{% block title %}This & that{% endblock %}
{% block content %}{{ greeting }}{% endblock %}

输出的结果：

<h1>This & that</h1>
<b>Hello!</b>

模板加载

    * django.template.loaders.filesystem.load_template_source：默认开启，从文件系统中获取模板
    * django.template.loaders.app_directories.load_template_source：默认开启，从安装的应用中获取模板
    * django.template.loaders.eggs.load_template_source：默认关闭，从python eggs中获取模板

通过设置settings.py文件中的TEMPLATE_LOADERS变量来开启上面的模板加载模块。
扩展模板系统

通过扩展模板系统，可以实现一些开发者自己需要的功能。

创建自己模板库的步骤：

   1. 确定模板库的位置
   2. 在与models.py views.py文件同级目录中创建templatetags目录。在该目录中包含__init__.py文件和模板定义文件。

在定义好定制模板库后，通过{% load XXXXX %}就可以使用定制的模板了。
定制模板过滤器

过滤器函数可以有一个或两个参数，第一个参数为输入，第二个参数为选项。下面来看一些例子：

def cut(value, arg):
    "Removes all values of arg from the given string"
    return value.replace(arg, '')

{{ somevariable|cut:" " }}

def lower(value): # Only one argument.
    "Converts a string into all lowercase"
    return value.lower()

注册定制过滤器的代码如下：

from django import template

register = template.Library()
register.filter('cut', cut)
register.filter('lower', lower)

定制模板标签

在django中，模板系统的工作分为两部分：编译和渲染。

在编译的过程中，django会分析模板标签，并将其生成相应的django.template.Node对象，该对象中包含有render()函数。可参考下面的例子：

Hello, {{ person.name }}.

{% ifequal name.birthday today %}
    Happy birthday!
{% else %}
    Be sure to come back on your birthday
    for a splendid surprise message.
{% endifequal %}

上面的模板在分析后，会生成如下Node列表：

    * Text node: "Hello, "
    * Variable node: person.name
    * Text node: ".\n\n"
    * IfEqual node: name.birthday and today

在编译完成后，会依次调用每个Node的render()函数进行渲染。
编译函数的编写

下面通过一个{% current_time %}标记来演示定制标签的方法。我们要实现的标签的使用方法如下：

<p>The time is {% current_time "%Y-%m-%d %I:%M %p" %}.</p>

首先是编译函数：

from django import template

register = template.Library()

def do_current_time(parser, token):
    try:
        # split_contents() knows not to split quoted strings.
        tag_name, format_string = token.split_contents()
    except ValueError:
        msg = '%r tag requires a single argument' % token.split_contents()[0]
        raise template.TemplateSyntaxError(msg)
    return CurrentTimeNode(format_string[1:-1])

需要注意的是，在编译函数中不能抛出异常。返回的一定是一个Node的子类。
创建Node子类

下面来创建CurrentTimeNode类：

import datetime

class CurrentTimeNode(template.Node):
    def __init__(self, format_string):
        self.format_string = str(format_string)

    def render(self, context):
        now = datetime.datetime.now()
        return now.strftime(self.format_string)

注册标签

注册标签的方法如下：

register.tag('current_time', do_current_time)

其他的高级定制方法请参考Django Book第9章的相关内容。
模型的高级应用
回顾

回顾此前层创建的模型对象：

from django.db import models

class Publisher(models.Model):
    name = models.CharField(max_length=30)
    address = models.CharField(max_length=50)
    city = models.CharField(max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()

    def __unicode__(self):
        return self.name

class Author(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=40)
    email = models.EmailField()

    def __unicode__(self):
        return u'%s %s' % (self.first_name, self.last_name)

class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()

    def __unicode__(self):
        return self.title

访问外键

访问外键的方法如下：

>>> b = Book.objects.get(id=50)
>>> b.publisher
<Publisher: Apress Publishing>
>>> b.publisher.website
u'http://www.apress.com/'

>>> p = Publisher.objects.get(name='Apress Publishing')
>>> p.book_set.all()
[<Book: The Django Book>, <Book: Dive Into Python>, ...]

>>> p = Publisher.objects.get(name='Apress Publishing')
>>> p.book_set.filter(name__icontains='django')
[<Book: The Django Book>, <Book: Pro Django>]

这里的book_set是一个QuerySet。book_set是django自动生成的。
访问多对多关系

访问多对多关系的方法如下：

>>> b = Book.objects.get(id=50)
>>> b.authors.all()
[<Author: Adrian Holovaty>, <Author: Jacob Kaplan-Moss>]
>>> b.authors.filter(first_name='Adrian')
[<Author: Adrian Holovaty>]
>>> b.authors.filter(first_name='Adam')
[]

>>> a = Author.objects.get(first_name='Adrian', last_name='Holovaty')
>>> a.book_set.all()
[<Book: The Django Book>, <Book: Adrian's Other Book>]

改变数据库模式
添加字段

向已有的模型中添加字段的步骤如下。首先需要在开发/测试服务器中进行测试：

   1. 向模型类中添加字段
   2. 运行命令manage.py sqlall [yourapp]，查看新创建字段的类型
   3. 通过ALTER TABLE语句改变数据库中的模式
   4. 运行manage.py shell测试修改

在生产服务器中：

   1. 打开数据库交互shell
   2. 执行ALTER TABLE语句
   3. 重启服务器

举例：

    * 修改模型类：

class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()
    num_pages = models.IntegerField(blank=True, null=True)

    def __unicode__(self):
        return self.title

    * 执行manage.py sqlall books命令：

CREATE TABLE "books_book" (
    "id" serial NOT NULL PRIMARY KEY,
    "title" varchar(100) NOT NULL,
    "publisher_id" integer NOT NULL REFERENCES "books_publisher" ("id"),
    "publication_date" date NOT NULL,
    "num_pages" integer NULL
);

"num_pages" integer NULL

    * 执行ALTER TABLE语句：

ALTER TABLE books_book ADD COLUMN num_pages integer;

    * 在shell中测试修改：

>>> from mysite.books.models import Book
>>> Book.objects.all()[:5]

删除字段

   1. 删除模型中的字段，并重启服务器
   2. 执行ALTER TABLE books_book DROP COLUMN num_pages;语句修改数据库模式

删除多对多字段

   1. 删除模型中的多对多字段，并重启服务器
   2. 执行DROP TABLE books_book_authors;删除多对多关系对应的表

删除模型

   1. 删除models.py文件中的模型，并重启服务器
   2. 执行DROP TABLE books_book;删除数据库中的相应表格

注意：需要删除所有依赖的表
管理器

此前在访问模型对象时使用的objects对象是系统自动生成的管理器。
添加额外的管理器

例子：

# models.py

from django.db import models

# ... Author and Publisher models here ...

class BookManager(models.Manager):
    def title_count(self, keyword):
        return self.filter(title__icontains=keyword).count()

class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()
    num_pages = models.IntegerField(blank=True, null=True)
    objects = BookManager()

    def __unicode__(self):
        return self.title

上面的代码创建了BookManager类，该类是models.Manager的子类。并在Book类中将其赋值给objects。下面来看一下使用方法：

>>> Book.objects.title_count('django')
4
>>> Book.objects.title_count('python')
18

修改查询结果集

默认情况下访问objects.all()函数的结果集是通过Manager.get_query_set()函数返回的。我们可以修改默认返回的查询结果集：

from django.db import models

# First, define the Manager subclass.
class DahlBookManager(models.Manager):
    def get_query_set(self):
        return super(DahlBookManager, self).get_query_set().filter(author='Roald Dahl')

# Then hook it into the Book model explicitly.
class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)
    # ...

    objects = models.Manager() # The default manager.
    dahl_objects = DahlBookManager() # The Dahl-specific manager.

使用方法和objects一样：

Book.dahl_objects.all()
Book.dahl_objects.filter(title='Matilda')
Book.dahl_objects.count()

另外一个例子：
<source lang="python">
class MaleManager(models.Manager):
    def get_query_set(self):
        return super(MaleManager, self).get_query_set().filter(sex='M')

class FemaleManager(models.Manager):
    def get_query_set(self):
        return super(FemaleManager, self).get_query_set().filter(sex='F')

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    sex = models.CharField(max_length=1, choices=(('M', 'Male'), ('F', 'Female')))
    people = models.Manager()
    men = MaleManager()
    women = FemaleManager()
</source

需要注意的是在系统中管理器的位置很重要，第一个管理器会作为默认管理器。
模型方法

我们可以根据业务逻辑的需要来定制模型中的一些方法，见下面的代码：

from django.contrib.localflavor.us.models import USStateField
from django.db import models

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    birth_date = models.DateField()
    address = models.CharField(max_length=100)
    city = models.CharField(max_length=50)
    state = USStateField() # Yes, this is U.S.-centric...

    def baby_boomer_status(self):
        "Returns the person's baby-boomer status."
        import datetime
        if datetime.date(1945, 8, 1) <= self.birth_date <= datetime.date(1964, 12, 31):
            return "Baby boomer"
        if self.birth_date < datetime.date(1945, 8, 1):
            return "Pre-boomer"
        return "Post-boomer"

    def is_midwestern(self):
        "Returns True if this person is from the Midwest."
        return self.state in ('IL', 'WI', 'MI', 'IN', 'OH', 'IA', 'MO')

    def _get_full_name(self):
        "Returns the person's full name."
        return u'%s %s' % (self.first_name, self.last_name)
    full_name = property(_get_full_name)

使用方法：

>>> p = Person.objects.get(first_name='Barack', last_name='Obama')
>>> p.birth_date
datetime.date(1961, 8, 4)
>>> p.baby_boomer_status()
'Baby boomer'
>>> p.is_midwestern()
True
>>> p.full_name  # Note this isn't a method -- it's treated as an attribute
u'Barack Obama'

执行原始SQL语句

执行原始SQL语句需要使用Python的DB-API：

>>> from django.db import connection
>>> cursor = connection.cursor()
>>> cursor.execute("""
...    SELECT DISTINCT first_name
...    FROM people_person
...    WHERE last_name = %s""", ['Lennon'])
>>> row = cursor.fetchone()
>>> print row
['John']

from django.db import connection, models

class PersonManager(models.Manager):
    def first_names(self, last_name):
        cursor = connection.cursor()
        cursor.execute("""
            SELECT DISTINCT first_name
            FROM people_person
            WHERE last_name = %s""", [last_name])
        return [row[0] for row in cursor.fetchone()]

class Person(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    objects = PersonManager()

>>> Person.objects.first_names('Lennon')
['John', 'Cynthia']

通用视图

下面列举了使用通用视图的方法，如果有需要，请参考Django Book第8、11章的相关内容，此处仅作简单介绍。
使用通用视图

先来看一个简单的使用通用视图的方法：

from django.conf.urls.defaults import *
from django.views.generic.simple import direct_to_template

urlpatterns = patterns('',
    (r'^about/$', direct_to_template, {
        'template': 'about.html'
    })
)

direct_to_template()函数的另外一种用法：

from django.conf.urls.defaults import *
from django.views.generic.simple import direct_to_template
from mysite.books.views import about_pages

urlpatterns = patterns('',
    (r'^about/$', direct_to_template, {
        'template': 'about.html'
    }),
    (r'^about/(\w+)/$', about_pages),
)


from django.http import Http404
from django.template import TemplateDoesNotExist
from django.views.generic.simple import direct_to_template

def about_pages(request, page):
    try:
        return direct_to_template(request, template="about/%s.html" % page)
    except TemplateDoesNotExist:
        raise Http404()

通用视图中的对象

先来看一个例子：

class Publisher(models.Model):
    name = models.CharField(max_length=30)
    address = models.CharField(max_length=50)
    city = models.CharField(max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()

    def __unicode__(self):
        return self.name

    class Meta:
        ordering = ['name']

from django.conf.urls.defaults import *
from django.views.generic import list_detail
from mysite.books.models import Publisher

publisher_info = {
    'queryset': Publisher.objects.all(),
}

urlpatterns = patterns('',
    (r'^publishers/$', list_detail.object_list, publisher_info)
)

上面的代码可以直接将Publisher模型中的数据作为参数传递给object list视图。

可以通过如下方法来指定要加载的模板：

from django.conf.urls.defaults import *
from django.views.generic import list_detail
from mysite.books.models import Publisher

publisher_info = {
    'queryset': Publisher.objects.all(),
    'template_name': 'publisher_list_page.html',
}

urlpatterns = patterns('',
    (r'^publishers/$', list_detail.object_list, publisher_info)
)

{% extends "base.html" %}

{% block content %}
    <h2>Publishers</h2>
    <ul>
        {% for publisher in object_list %}
            <li>{{ publisher.name }}</li>
        {% endfor %}
    </ul>
{% endblock %}

除此以外，其他一些定制的方法请参考Django Book第11章。