矿泉水

Hetaoo团队编程规范

小水 — Sat, 19 Jun 2010 14:12:27 +0800

因为将会在大三做项目，所以就想向大家说明一下简单的编程规范，准备做一个系列的PPT展示

Feed enhanced by Better Feed from Ozh

写你的第一个Django程序 4th

小水 — Sat, 19 Jun 2010 11:33:49 +0800

这是第三部分的延续。我们将会继续投票程序，并且集中注意力到简单的表单生成和简化代码。

写一个简单的表单

让我们升级我们的投票详细模板（“polls/detail.html”），这样他将会含有HTML标签<form>：

<h1>{{ poll.question }}</h1>

{% if error_message %}<p><strong>{{ error_message }}</strong></p>{% endif %}

<form action="/polls/{{ poll.id }}/vote/" method="post">
{% csrf_token %}
{% for choice in poll.choice_set.all %}
    <input type="radio" name="choice" id="choice{{ forloop.counter }}" value="{{ choice.id }}" />
    <label for="choice{{ forloop.counter }}">{{ choice.choice }}</label><br />
{% endfor %}
<input type="submit" value="Vote" />
</form>

素描：

上边的模板为每一个投票选项添加一个可选按钮。每一个可选按钮的值关联到投票选项的ID。每一个选项按钮的名字是“choice”.也就是说，如果某个人选择了一个按钮，然后提交给表单，他将会POST数据：choice=3，这是HTML表单101。
我么么选择表单action给/polls/{{ poll.id }}/vote/，我们设置method="post"。使用method="post"很重要，因为这个提交表单的动作将会在服务器端提交数据。当你创建一个服务器端提示数据时，使用method="post"。这个准则不仅仅适用于Django。这是一个好的web开发习惯。
forloop.counter标明for标签在循环中被调用的次数。
子冲我们创建了一个POST表单（有填充数据功能），我们需要考虑卡站点请求。庆幸，我们不用过于着急，因为Django含有一个易用的保护系统。简单的说，所有的POST表单应当那个使用% csrf_token %}标签在每一个URLs中。

这个% csrf_token %}标签从请求对象中请求数据信息，在模板内容中这将不会是很简单触及的。为了修复这个，一个简单那的判断需要包含在detail视图中，如下：

from django.template import RequestContext
# ...
def detail(request, poll_id):
    p = get_object_or_404(Poll, pk=poll_id)
    return render_to_response('polls/detail.html', {'poll': p},
                               context_instance=RequestContext(request))

详细工作原理参见RequestContext

现在，让我们创建一个Django视图，它将会处理所有的提交数据并且做出反应。基础，在教程3中，我们创建了一个URLconf给投票程序包含如下行：

(r'^(?P<poll_id>\d+)/vote/$', 'vote'),

我们同样需要创建一个vote()函数的调用。让偶我们创建一个实时版本，添加如下于mysite/polls/views.py:

from django.shortcuts import get_object_or_404, render_to_response
from django.http import HttpResponseRedirect, HttpResponse
from django.core.urlresolvers import reverse
from django.template import RequestContext
from mysite.polls.models import Choice, Poll
# ...
def vote(request, poll_id):
    p = get_object_or_404(Poll, pk=poll_id)
    try:
        selected_choice = p.choice_set.get(pk=request.POST['choice'])
    except (KeyError, Choice.DoesNotExist):
        # Redisplay the poll voting form.
        return render_to_response('polls/detail.html', {
            'poll': p,
            'error_message': "You didn't select a choice.",
        }, context_instance=RequestContext(request))
    else:
        selected_choice.votes += 1
        selected_choice.save()
        # Always return an HttpResponseRedirect after successfully dealing
        # with POST data. This prevents data from being posted twice if a
        # user hits the Back button.
        return HttpResponseRedirect(reverse('mysite.polls.views.results', args=(p.id,)))

这些代码包含我们教程中还没有涉及到的事情：

request.POST是一个字典样的对象，它让你通过名字接触到提交数据。在这个例子中，request.POST['choice']返回选项的ID。request.POST通常是一个字符串。注意到，Django同样提供request.GET来触及GET数据以相同方式—但是我们明确使用request.POST在代码中，这保证数据只会被触发通过POST调用。
request.POST['choice']在没有选项在POST数据中时产生一个KeyError.如上代码检查KeyError然后重新展示含有错误信息的投票表单在选项没有时。
在选项增加以后，返回HttpResponseRedirect而不是平常的HttpResponse.HttpResponseRedirect含有一个参数：用户将被重定向的URL。就像上边Python代码指出的，你应当在成功处理数据以后返回一个HttpResponseRedirect对象；这不是只对Django这样，而是一个良好的web变成习惯。
我们使用reverse（）函数于HttpResponseRedirect构建。这个函数帮助避免在URL视图中硬编码。它给予视图名称，我们希望传递的，和这个URL模式向指向的视图。在这个例子中，使用我们在教程3中的URLconf，这个reverse（）函数返回如下字符串：

'/polls/3/results/'

这里3是p.id的值。这个重定向URL将会调用“results”视图在最后的展示页面。注意到你需要使用视图全程。（包括前缀）

就像在教程3中提及的那样，request是一个HttpRequest对象。更多参照：request and response documentation

有人投票以后，vote（）视图重定向页面到投票结果，让我们写此视图：

def results(request, poll_id):
    p = get_object_or_404(Poll, pk=poll_id)
    return render_to_response('polls/results.html', {'poll': p})

这就像教程3中的detail（）一样。唯一的不同是模板的名字。我们将会修复这个冗余。

现在创建一个results.html模板：

<h1>{{ poll.question }}</h1>

<ul>
{% for choice in poll.choice_set.all %}
    <li>{{ choice.choice }} -- {{ choice.votes }} vote{{ choice.votes|pluralize }}</li>
{% endfor %}
</ul>

<a href="/polls/{{ poll.id }}/">Vote again?</a>

现在，在你的浏览器中进入/poll/1/，然后投票。你将会在每一次投票时看到一个结果页面。如果你没有选择任何投票就提交，你将会一条错误信息。

使用一般视图：更少的视图将会更好

这个detail（）和results()很相似—就像上边提及的，他们是冗余。这个index()同样。

这些视图展现一个基础web设计中的通例：根从URL的得到的参数从数据库中找到数据，载入模板然后返回组成的模板。因为这是很平常的，Django提供一个快捷，称之为“generic views”系统。

一般视图抽象出你不行写Python代码的通用模式。

让我们转化应用通过一个通用视图系统，然后我们就可以删除一大堆代码。我们将花费几分钟时就爱你来转哈u，我们将：

转化URLconf
重命名几个模板
删除老的不需要的视图
修复几个视图URL

首先，打开polls/urls.py，它看起来如下：

from django.conf.urls.defaults import *

urlpatterns = patterns('mysite.polls.views',
    (r'^$', 'index'),
    (r'^(?P<poll_id>\d+)/$', 'detail'),
    (r'^(?P<poll_id>\d+)/results/$', 'results'),
    (r'^(?P<poll_id>\d+)/vote/$', 'vote'),
)

将其改变为：

from django.conf.urls.defaults import *
from mysite.polls.models import Poll

info_dict = {
    'queryset': Poll.objects.all(),
}

urlpatterns = patterns('',
    (r'^$', 'django.views.generic.list_detail.object_list', info_dict),
    (r'^(?P<object_id>\d+)/$', 'django.views.generic.list_detail.object_detail', info_dict),
    url(r'^(?P<object_id>\d+)/results/$', 'django.views.generic.list_detail.object_detail', dict(info_dict, template_name='polls/results.html'), 'poll_results'),
    (r'^(?P<poll_id>\d+)/vote/$', 'mysite.polls.views.vote'),
)

我们使用了两个通用视图：object_list() 和object_detail()。着来年各个视图抽象了“展示一个对象列表”和“展现一个特定对象的详细页面”。

每一个普通视图需要知道他所处理的数据。数据在字典中被提供。字典中的queryset指向被普通视图槽中的一个对象列表
这个object_detail()普通视图期望URL中被称为“object_id”的ID值，所以我们改变poll_id 到 object_id
我们需要增加一个名字，poll_results以使其返回视图，这样我们稍后将会有方式返回他的URL。我们同样适用django.conf.urls.defaults中的url()。这是一个好习惯当你提供一个模式名字如上时使用url().

默认，object_detail() 普通视图使用<app name>/<model name>_detail.html. 在我们的例子中，它使用"polls/poll_detail.html". 因此重命名你的polls/detail.html模板为polls/poll_detail.html, 然后改变vote()中的render_to_response() 。

同样，the object_list()通用视图使用<app name>/<model name>_list.html. 因此重命名polls/index.html 为polls/poll_list.html.

因为我们的投票程序中URLconf不止一个entry使用object_detail()，我们人工区分一个模板名称：template_name='polls/results.html'，这样，所有视图将会使用同一个模板。注意到我们使用dict（）来返回一个字典。

在教程的前面，模板被含有poll 和latest_poll_list内容变量充斥的内容所提供。然后，普通视图提供一变量object和object_list作为变量。因此，我们需要改变模板来满足新的变量。在你的模板中，重新定义对latest_poll_list的引用到 object_list，定义poll的引用到 object。

你可以删除polls/views.py中的index(), detail() 和results()视图。我们不在需要他们---他们已经被通用视图取代。

vote（）仍然需要。然后，他需要改变来满足新的内容变量。在render_to_response()调用中，重命名poll为object。

最后一件事情是修复普通视图使用的URLconf。子这个投票视图中我们使用reverse（）函数来避免在URL中硬编码。现在我们转换到一个通用视图，我们需要改变reverse（）调用，使其指向我们新的通用视图。我们，不能只是使用视图函数---通用视图可以被多次使用----但是我们使用给定的名称：

return HttpResponseRedirect(reverse('poll_results', args=(p.id,)))

运行服务器，使用你给予通用视图的投票程序。

更多参照：generic views documentation

继续

教程到此结束。以后的安装教程涵盖：

高级表单生成
使用RSS框架
使用缓存框架
使用留言框架
高级管理：准许
高级管理：自定义JavaScript

此时，你也许想知道下一步怎么办：where to go from here

Feed enhanced by Better Feed from Ozh

写你的第一个Django程序 3rd

小水 — Sat, 19 Jun 2010 11:32:56 +0800

这是第二部分的延续。我们将会对于投票程序继续探讨并且集中注意力到如何创建一个公开的接口—“views”.

定义

一个视图是你的Django程序中的页面种类，它一般来说提供一个特定功能并且包含一个特定的模板。例如，在一个博客程序中，你也许会包含一些视图：

博客首页—展现最新的文章
文章“详细”页面—一个文章的永久页
基于年的汇总页—-展示某一年中所有月份的文章
基于月的汇总页—-展示某一个月的所有文章
基于天的汇总页—-展示某一天的搜有文章
留言—对于一个文章的留言句柄

在我们的投票程序中，我们已经有了如下的四个视图：

“archive”页—-展示最新的投票
“detail”页——投票的所有问题，没有结果，但是含有投票框
“results”页—-某一个投票问题的结果
vote—–对某一个投票问题投某一票的句柄

在Django中，每一个页面使用过一个简单的Python函数来展现的。

设计你的URLs

写视图的第一部是设计你的URL结构。你可以通过创造Python模块来实现，称之为URLconfs.它定义了Django如何关联一个特定的URL通过给定的Python代码。

当一个用户请求一个Django页面时，系统查找ROOT_URLCONF设置，它包含了一个Python语法块。Django加载这个模块，然后查找模块级别的变量urlpatterns,它包含一系列如下模式的元组：

(regular expression, Python callback function [, optional dictionary])

Django起始于第一个正则表达式，然后顺着查找，比较每一个请求URL于每一表达式，直到找到符合的为止。

当找到一个匹配以后，Django将会调用Python回调函数，使用一个HttpRequest对性作为第一个参数，任何的从正则中被抓取到的值将会作为关键字参数，并且，默认下，随意从字典中选择关键字参数。

对于更多的HttpRequest，参照Request and response objects.对于更多的URLconfs，参照URL dispatcher.

当你在教程1开始运行django-admin.py startproject mysite，它自动在mysite/urls.py中创建爱你默认的URLconfs。他同时自动设置你的ROOT_URLCONF (在 settings.py中)指向那个文件：

ROOT_URLCONF = 'mysite.urls'

例子时间。如下编辑mysite/urls.py：

from django.conf.urls.defaults import *

from django.contrib import admin
admin.autodiscover()

urlpatterns = patterns('',
    (r'^polls/$', 'mysite.polls.views.index'),
    (r'^polls/(?P<poll_id>\d+)/$', 'mysite.polls.views.detail'),
    (r'^polls/(?P<poll_id>\d+)/results/$', 'mysite.polls.views.results'),
    (r'^polls/(?P<poll_id>\d+)/vote/$', 'mysite.polls.views.vote'),
    (r'^admin/', include(admin.site.urls)),
)

总金额是奇偶欧冠值得的回顾。当有人在你的网站请求页面时，说"/polls/23/"

，Django载入这个Python模块，因为他被ROOT_URLCONF所指向。它找到名为urlpatterns德变量，。然后依次执行正则表达式。当发现一个匹配的正则时—–r’^polls/(?P<poll_id>\d+)/$—它载入函数detail（）从mysite/polls/views.py.。最后，它调用函数：

detail(request=<HttpRequest object>, poll_id='23')

这个poll_id='23'是从(?P<poll_id>\d+)来的，使用参数旁边的参数化来抓取符合的船体给视图函数的参数中数值；这个?P<poll_id>定义了一个名字，他竟会用作甄别匹配模式；\d+是正则表达式中匹配乙烯类数字的参数。

因为URL模式是正则，所以你可以做任何想做的事情。么有必要添加无用的东西，比如.php—–除非你有这种幽默，你可以这样做：

(r'^polls/latest\.php$', 'mysite.polls.views.index'),

但是，不要这样做，很傻。

注意到这些正则表达式没有搜索GET和POST参数，或是域名。例如，在请求http://www.example.com/myapp/中，URLconf将会查找myapp/。在请求http://www.example.com/myapp/?page=3，会查找myapp/.

如果你需要正则表达式的帮助，参照Wikipedia's entryand the Python documentation。同样，the O'Reilly book "Mastering Regular Expressions" by Jeffrey Friedl is fantastic.

最后，一个明显被观察到的情况：这些正则表达式在URLconfs第一次载入时被编译。他们很快。

写你的第一个视图

现在你还没有创建任何的视图---我们有了URLconfs.但是，让我们先保证Django正确运行了URLconfs.

运行Django服务器：

python manage.py runserver

现在进入"http://localhost:8000/polls/"。你应当看到一个漂亮的错误信息：

ViewDoesNotExist at /polls/

Tried index in module mysite.polls.views. Error was: 'module'
object has no attribute 'index'

错误发生原因是你没有在ysite/polls/views.py中写index()函数。

"尝试/polls/23/", "/polls/23/results/" and "/polls/23/vote/".错误信息将会告诉你Django已经尝试了那些视图。

是时间来写第一个试图了。打开mysite/polls/views.py文件，然后把如下代码放入：

from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world. You're at the poll index.")

这是最简单的视图。在你的浏览器中进入“/polls/”然后你将会看到你的文字。

现在让我们添加更多的试图。这些视图有一点不同，因为他们采用了不同的参数（在URLconfs中使用正则获取的）。

def detail(request, poll_id):
    return HttpResponse("You're looking at poll %s." % poll_id)

def results(request, poll_id):
    return HttpResponse("You're looking at the results of poll %s." % poll_id)

def vote(request, poll_id):
    return HttpResponse("You're voting on poll %s." % poll_id)

在你的浏览器中查看“poll/34/”.它将会运行detail（）方法并且展示你输入URL的ID。尝试"/polls/34/results/" 和 "/polls/34/vote/"—这些将会替换结果和投票页面。

写真正起作用的视图

每一个视图为两件事情之一：返回包含请求页面的HttpResponse对象，或是挂起一个404页面。剩下的在于你。

你的视图能够从数据库中读取数据，或不能，他将会用一个模板就像Django的—或是一个第三方的Python模板系统–或不用。他将会生成一个PDF文档，生成XML，生成zip文件，或是任何你想要的事情，使用任何你想要的Python库。

任何Django想要的是HttpResponse。或是一个异常。

因为很方便，就让我们使用Django自己的数据库API,我们已经在教程1中介绍了。这里有一个短代码包含于index()视图中，将会展示最新的5个投票问题，根据时间使用逗号隔开：

from mysite.polls.models import Poll
from django.http import HttpResponse

def index(request):
    latest_poll_list = Poll.objects.all().order_by('-pub_date')[:5]
    output = ', '.join([p.question for p in latest_poll_list])
    return HttpResponse(output)

但是，这里还有一个问题：这些页面时在视图中进行硬编码的。如果你想改变视图样子，你必须更改Python代码。让我们使用Django的模板系统来分离设计:

from django.template import Context, loader

from mysite.polls.models import Poll

from django.http import HttpResponse

def index(request):

    latest_poll_list = Poll.objects.all().order_by(‘-pub_date’)[:5]

    t = loader.get_template(‘polls/index.html’)

    c = Context({

        ‘latest_poll_list’: latest_poll_list,

    })

    return HttpResponse(t.render(c))

这段代码载入被称为“polls/index.html”的模板，然后传递给内容。这些内容是一个字典，它映射模板变量名称到Python对象。

重新载入这个页面，现在你看到一条信息：

TemplateDoesNotExist at /polls/

polls/index.html

额，这里还没有模板。首先，创建一个路径，在你的硬盘上，Django可以进入（Django和你的服务器运行的一样。）不要把他们放在你的文档根目录下。你不应该让这些东西公开，

这是为了安全原因。然后，编辑TEMPLATE_DIRS在你的setting.py文件中，使得它通知Django在哪里可以发现这个模板—就像你在教程2中自定义管理界面那样。

当你完成了这些，在你的模板路径中出创建一个目录polls。在这个中创建一个index.html文件。注意到我们的loader.get_template(‘polls/index.html’)映射到系统中的“[template_directory]/polls/index.html”.

把如下代码放入模板：

{% if latest_poll_list %}

    <ul>

    {% for poll in latest_poll_list %}

        <li><a href="/polls/{{ poll.id }}/">{{ poll.question }}</a></li>

    {% endfor %}

    </ul>

{% else %}

    <p>No polls are available.</p>

{% endif %}

载入你的页面，然后你将会看到一个包含“What’s up”的列表。这个链接指向投票的具体信息页面。

快捷：render_to_response()

这是一个常用的方法来再载入模板，填充内容然后返回含有给予模板对象的HttpResponse对象。Django提供一个快捷方式。这是全部index()看起来的样子，重写以后：

from django.shortcuts import render_to_response

from mysite.polls.models import Poll

def index(request):

latest_poll_list = Poll.objects.all().order_by(‘-pub_date’)[:5]

return render_to_response(‘polls/index.html’, {‘latest_poll_list’: latest_poll_list})

注意到一旦我们已经完成了这些视图，我们就不再需要导入loader,Content和HttpResponse。

render_to_respones()函数将提取第一个参数名称的模板和第二个参数为名称的字典。然后返回给定结果的模板中的HttpResponse对象。

挂起404

现在，让偶我们解决详细视图—一个展示给定投票问题的页面。这里是视图：

from django.http import Http404

# …

def detail(request, poll_id):

    try:

        p = Poll.objects.get(pk=poll_id)

    except Poll.DoesNotExist:

        raise Http404

    return render_to_response(‘polls/detail.html’, {‘poll’: p})

一个新的原则：如果请求投票ID不存在的话就会挂起一个404错误页面。

我们稍后将会讨论在polls/detail.html中存放的内容，但是，如果你想尽快看下以上的工作情况的话，就填入：

{{ poll }}

将会工作。

快捷：get_object_or_404()

这是一个常用方法使用get()和挂起Http404当一个对象不存在。Django提供一个快捷。这是detail()视图，重写以后：

rom django.shortcuts import render_to_response, get_object_or_404

# …

def detail(request, poll_id):

p = get_object_or_404(Poll, pk=poll_id)

return render_to_response(‘polls/detail.html’, {‘poll’: p})

这个get_object_or_404()函数将会使用Django模板作为第一个参数，关键字参数作为数字标示，他们将会被传递给get()函数。如果对象不存在将会挂起一个404错误。

同样有一个get_list_or_404()函数，他和get_object_or_404（）工作原理很像—-除了是使用filter()函数替代了get()函数，如果列表为空同样挂起404错误。

写一个404（未发现）页面

当你在几个视图内挂起一个Http404，Django将会载入一个特殊的页面视图来控制404错误。他将会通过查找变量handler404来找到他，这是一个Python语法—和URLconfs使用的一样。一个404视图并没有什么特殊：他只是一个普通的视图。

你不用为了写一个404视图而烦恼。默认情况下，URLconfs包含如下：

from django.conf.urls.defaults import *

小心在现有的模块中设置handler404.就像你在django/conf/urls/defaults.py看到的，handler404默认指向django.views.defaults.page_not_found()。

更多关于404视图：

如果DEBUG 设置为true,呢么你的404页面将永远不会被使用（404.html也将不会被传递）因为回执将会被替代。
这个404视图在Django没有找到一个符合URLconf的正则时同样被调用。
如果你不自定义404视图—只是使用默认，就像推荐的那样—-你仍然有一个义务：在根目录下创建一个404.html。这个404视图将会对所有的404错误产生时使用。
如果DEBUG设置为false,并且你没有创建一个404..html页面，一个Http500错误将会被挂起。所以记住创建404.html。

写500（服务器错误）视图

同样，URLconfs也可以定义一个handler500，它在服务器错误时指向一个视图。当你在服务器运行时错误产生时触发服务器错误。

使用模板系统

回到我们投票程序的poll()视图。给内容变量poll,这是“polls/detail.html”模板的内容：

<h1>{{ poll.question }}</h1>
<ul>
{% for choice in poll.choice_set.all %}
    <li>{{ choice.choice }}</li>
{% endfor %}
</ul>

模板系统将会使用点查询语法来找到变量属性。在{{poll.questuion}}中，首先，Django在对象poll中使用字典查找。查找失败，尝试属性查找—成功。如果属性查找失败，它将会尝试调用question（）方法在poll对象中。

在{% for %}循环中方法调用被触发：poll.choice_set.all被解释为Python代码poll.choice_set.all()，它返回一个Choice对象，并且使用于{% for %}标签。

更多参考：template guide

简化URLconfs

花费时间来围绕视图和模板系统。当你变价URLconf时，你也许注意到其中有很多冗余：

urlpatterns = patterns('',
    (r'^polls/$', 'mysite.polls.views.index'),
    (r'^polls/(?P<poll_id>\d+)/$', 'mysite.polls.views.detail'),
    (r'^polls/(?P<poll_id>\d+)/results/$', 'mysite.polls.views.results'),
    (r'^polls/(?P<poll_id>\d+)/vote/$', 'mysite.polls.views.vote'),
)

也就是说，mysite.polls.views在每一个回调中。

因为这是一个通例，URLconf框架提供一个同样前缀的快捷。你可以提取出相同的前缀，然后把他恩价位patterns()的第一个参数，如下：

urlpatterns = patterns('mysite.polls.views',
    (r'^polls/$', 'index'),
    (r'^polls/(?P<poll_id>\d+)/$', 'detail'),
    (r'^polls/(?P<poll_id>\d+)/results/$', 'results'),
    (r'^polls/(?P<poll_id>\d+)/vote/$', 'vote'),
)

这和以前在功能上一致。这是简化些。

解耦URLconfs

当我们看到它时，我们应当花费点时间来解耦我们的投票程序从Django程序设置中。Django程序意味着可插入—也就是说，每一个特定的应用应当在最小的更改下可以转移到另一个Django程序。

我们的投票应用现在解耦很好，感谢python manage.py startapp创建的严格的目录结构，但是有一部分和Django设置耦合：URLconf.

我们已经编辑了mysite/urls.py中的URLs，但是这个URL设计于此特定的程序，而不是Django安装程序—让我们将它转移到应用内部的路径。

复制文件mysite/urls.py到mysite/polls/urls.py.然后改变mysite/urls.py，删除投票特定的URLs，然后插入一个include()函数：

# ...
urlpatterns = patterns('',
    (r'^polls/', include('mysite.polls.urls')),
    # ...

include()，简单的指向另一个URLconf.注意到这个正则表达式没有包含$(末尾相符字符），但是含有一个反斜杠。当Django使用include()，它将会分割在URL中任何符合的部分，并把剩余的部分传递给被包含的URLconf。

这是系统中“polls/34/”的情况：

Django发现他符合：’^polls/’
然后，Django去除法和的文本("polls/")然后传递剩下的文本"34/"，传递给’mysite.polls.urls’做以后的调用。

既然我们已经解耦了它，我们还需要通过删除行受得“polls/”来解耦‘mysite.polls.urls’的URLconf.并且删除管理站点的注册：

urlpatterns = patterns('mysite.polls.views',
    (r'^$', 'index'),
    (r'^(?P<poll_id>\d+)/$', 'detail'),
    (r'^(?P<poll_id>\d+)/results/$', 'results'),
    (r'^(?P<poll_id>\d+)/vote/$', 'vote'),
)

include()和URLconf解耦背后的思想是是URL更容易插入和执行。既然polls是自己的URLconf,它可以在“/polls/”下被替代，或是在"/fun_polls/", 或是 "/content/polls/"，抑或是任何其他程序起作用的URL路径。

所有投票程序关心他的相对URL，而不是绝对URL。

当你对自己的视图满意时，阅读第四部分虚席表单进程和产生视图。

Feed enhanced by Better Feed from Ozh

写你的第一个Django程序 2nd

小水 — Sat, 19 Jun 2010 10:48:33 +0800

这是接着第一部分的教程。我们将会继续完成投票程序并且把注意力放到Django的自动管理生成站点上。

激活管理站点

Django的管理站点默认不是激活的—这是一个可选项。为了激活你的管理站，作如下的三件事：

添加"django.contrib.admin"到你的 INSTALLED_APPS 设置中
运行python manage.py syncdb
编辑 mysite/urls.py文件并且去除 admin前面的注释— 共有三行需要去除注释。这是一个URLconf，我们将会在以后的教程中深入讨论，现在你所要知道的是他是一个URL路径的映射，最后你的urls.py文件应该看起来是这个样子的：

from django.conf.urls.defaults import *

# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()

urlpatterns = patterns(”,
    # Example:
    # (r’^mysite/’, include(‘mysite.foo.urls’)),

    # Uncomment the admin/doc line below and add ‘django.contrib.admindocs’
    # to INSTALLED_APPS to enable admin documentation:
    # (r’^admin/doc/’, include(‘django.contrib.admindocs.urls’)),

    # Uncomment the next line to enable the admin:
    (r’^admin/’, include(‘admin.site.urls’)),
)

启动开发服务器

让我们启动开发服务器探寻管理站点。回忆教程1中所教授的启动服务器的方法：

python manage.py runserver

现在，打开一个浏览器并且进入“/admin/ "在你的主机上—-例如，http://127.0.0.1:8000/admin/。你应该会看到如下的登陆界面：

进入管理站点

现在，尝试登陆。（在教程1中你创建了一个超级管理员，记得吗？如果你忘记了就需要在创建一个。）你将会看到如下的管理界面：

你应当看到一些可编辑的选项，包括组、用户和站点。这些是Django的默认属性。

让投票程序在管理站点可用

但是我们的投票程序呢？他没有在管理站点显示。

只需要做一件事情：我们需要告诉管理站，Poll对象有一个管理接口。为了这样做，我们创建一个admin.py文件在polls文件夹中，然后编辑这个文件：

from mysite.polls.models import Poll
from django.contrib import admin

admin.site.register(Poll)

你需要重新启动开发服务器来看到变化。一般来说，服务器将会重新载入当有文件改变时，但是这个变化却不会触发自动重启逻辑。

探索管理站点的功能

既然我们注册了poll，Django知道它将会被展示到起始页面：

点击：{Poll。现在你在“change list”页面中了。这个页面展示所有的数据库投票并且你可以有选择的更改。这里有一个“What’s up？”投票：

点击“What’s up?”投票并编辑：

需要注意的事情：

这个页面自动从Poll模块生成
不同的模块属性（DateTimeField,CharField）对应不同的HTMl代码。每一种属性知道如何在Django站点表现自己。
每一个DateTimeField有JavaScript快捷方式。这个页面的底部给你一些列的选项：
Save—保存更改并将返回到change-list页面
Save and continue editing—-保存更改然后重新加载
Save and add another—-保存更改并添加一个新的空的对象
Delete—-删除一个信息

改变发布时间通过点击“Today”或是“Now”.然后点击“Save and continue editing”。然后点击右上方的“History”，你将会看到通过Django管理站点进行的所有更改操作—包含时间和用户：

自定义管理框

花几分钟惊叹于节省的代码。通过使用admin.site.register(Poll)注册投票模块，Django能够构造表格的表现形式。经常，你想自己定义管理页面的外观和工作模式。你可以通过告知Django你想定义的选项。

让我们看看通过再次定义块来编辑表格是如何工作的。使用如下来替换admin.site.register(Poll):

class PollAdmin(admin.ModelAdmin):
    fields = ['pub_date', 'question']

admin.site.register(Poll, PollAdmin)

你可以使用如下模式—创建一个管理员对象，然后将它传递给admin.site.register()作为第二个参数—任何你在任何时间来通知管理项。

上边这个将“Publish date”放在“Question”前面：

对于只有两块的表格来说，这些不令人印象深刻。但是如果对于几十块的管理界面。选择一个模块将是一个重要的可用性模块。

当提及几十块的表格时，你也许希望将这个分割成块：

class PollAdmin(admin.ModelAdmin):
    fieldsets = [
        (None,               {'fields': ['question']}),
        ('Date information', {'fields': ['pub_date']}),
    ]

admin.site.register(Poll, PollAdmin)

在块组中各元组的第一元素是这个快组的名字。这是他们的样子：

你可以将HTML的类性质给予每个块。Django提供一个“collapse”类，它能够通过默认方式展现块。当你的长表单中包含不经常用的模块时，浙江会非常有用：

添加关联对象

好了，我们已经有了管理界面。但是，一个投票（Poll）含有多个选项(Choices)，但是管理页面并不显示这些选项。

起码来说现在还没有。

有两种方式来解决这个问题。一个是就像我们对于Poll做得那样来注册Choice模块。这很简单：

from mysite.polls.models import Choice

admin.site.register(Choice)

现在“Choices”已经在Django的管理页面中可用了。这个“Add choice”表单看起来就像这样：

在这个表中，“Poll”是包含数据库中每一个投票的下拉列表。Django知道每一个外键应当使用一个选择框来呈现。在我们的例子中，现在只有一个投票存在。

同样注意到“Add Another”连接到“Poll”。每一个含有外键的对象将会得到另一个。当你添加“Add Another”，你将会得到一个含有“Add poll”表单的弹出窗口。如果你在这个窗口中添加一个投票并点击“Save”，Django将会将这个投票保存到数据库中并且动态将其作为“Add choice”中的选择值添加进来。

但是，这的确不是一个方便的方法来添加选项对象到系统中。如果你能够在创建一个投票对象的同时添加一系列选项将会更好。让我们实现它。

为选项模块移除这个register（）调用。然后，编辑这个Poll的注册模块:

class ChoiceInline(admin.StackedInline):
    model = Choice
    extra = 3

class PollAdmin(admin.ModelAdmin):
    fieldsets = [
        (None,               {'fields': ['question']}),
        ('Date information', {'fields': ['pub_date'], 'classes': ['collapse']}),
    ]
    inlines = [ChoiceInline]

admin.site.register(Poll, PollAdmin)

这个告诉Django：“选项对象将会在管理界面被添加。默认提供三个选项”。

载入这个“Add poll”，看看发生了什么：

着看起来：将会有三个选项的关联—-通过“extra”来确定—–当你每次返回到“change”页面的时候，你将会得到额外的三个对象。

尽管是一个小问题。但是将会占据很多屏幕空间来展示选项的关联对象。因此。Django提供一个行内关联属性来解决这一问题；你只需要改变对ChoiceInline的声明如下：

class ChoiceInline(admin.TabularInline):
    #...

使用这个TabularInline(替换StackedInline),关联属性将会被放置到一个表格内：

自定义管理员更改列表

现在的投票页面看起来已经不错了，现在让我们对”change list“页面做点更改—这个页面用来展示系统中的所有投票。

这是现在的外观：

默认，Django展示每个对象的str()属性。但是在有些情况下展现单独的域将会更加有用。为了达到这个目的，使用list_display的管理员选项，这将会展示一个元组的名称作为列名，在对象的更改页面：

class PollAdmin(admin.ModelAdmin):
    # ...
    list_display = ('question', 'pub_date')

做更多好的改动，让我们包含教程1中was_published_today这个默认方法：

class PollAdmin(admin.ModelAdmin):
    # ...
    list_display = ('question', 'pub_date', 'was_published_today')

现在这个投票更改页面将会看起来想这个样子：

你可以通过点击列名来根据值自动排序—-除了was_published_today这个列，因为逻辑的自动排序不被支持。同时，注意到was_published_today列名默认是他的方法名（使用空格代替了下划线）。但是，你可以通过给这个方法一个short_description属性来更改列名：

def was_published_today(self):
    return self.pub_date.date() == datetime.date.today()
was_published_today.short_description = 'Published today?'

让我们添加另一个提升方法：筛选.添加如下行到PollAdmin:

list_filter = ['pub_date']

这将会添加一个“Filter”的侧边栏，它允许人们通过pub_date属性来筛选列表：

分类的方式将会取决于你所筛选的属性。因为pub_date是一个DateTimeField属性，Django知道给予DateTimeFields默认的筛选值："Any date," "Today," "Past 7 days," "This month," "This year."

他的可造型强。让我们添加一些搜索属性：

search_fields = ['question']

这将会在每一个更改页面的头部添加一个搜索框。当任何人输入搜索与属性以后，Django将会搜索question域。你可以使用多个属性域—背后它使用了一个LIKE查询，使其具有说服力，并使你的数据库愉悦。？？

左右，因为投票含有时间，如果能够根据时间排序，将会非常便捷。我们可以添加如下行“

date_hierarchy = 'pub_date'

这将会在页面顶部添加一个根据时间的阶级式的导航。在最高层，它显示所有的年。然后，是月份，最后是天。

现在是个好时机来注意改变列表给你分页的能力。默认是每一个页面展示50项。改变列表导航、搜索框、筛选、时间列和列名排序都如你所愿的在一起实现了。

自定义管理站的外观和感觉

很明显，在每一个管理页面含有“Django administration”是很荒谬的。这个只是文字。

然而使用Django系统模板将会很容易改变。Django管理站是Django支持的，因此它的接口使用Django自己的模板系统。

打开你的设置文件（记住，mysite/settings.py）,然后查找TEMPLATE_DIRS设置项。他是载入Django模板时将会检查的系统路径列表。他是一个搜索路径。

默认为空。所以，让我们添加一行，告诉Django我们的模板在哪里：

TEMPLATE_DIRS = (
    "/home/my_username/mytemplates", # Change this to your own directory.
)

现在复制源代码(django/contrib/admin/templates)中的管理员模板路径中的模板admin/base_site.html至一个你在TEMPLATE_DIRS中所使用的二级目录下。

例如，如果你的TEMPLAte_DIRS中半酣“/home/my_username/mytemplates”,就像上边，然后复制django/contrib/admin/templates/admin/base_site.html到/home/my_username/mytemplates/admin/base_site.html。不要妄加admin这个二级目录。

然后，编辑这个文件，然后使用你的站点名称来替换Django的文字。

这个模板文件包含许多文本比如{% block branding %} and{{ title }}.``{% and {{ tags是Django模板的一部分。当Django生成admin/base_site.htm时，这个模板语言将会解释并最后生成HTML页面。不要着急你还不会任何模板语言—我们将会在教程3中探讨。

注意到任何Django的管理模板可以被重写。为了重写一个模板，对base_site.html做重复的事情--复制它从默认路径到你的自定义路径，然后修改。

精明的读者将会问：但是TEMPLATE_DIRS默认为空，那么Django如何找到默认的管理模板？答案是，默认情况下，Django自动找每一个程序包的templates/子目录来调用。更多，阅读：template loader documentation。

自定义管理站点首页

同样，你也许项自定义Django管理首页的外观和感觉。

默认情况下，它按照字母顺序展示通过管理项注册的所有模块。你也许想对外观做点出奇的更改。总之，首页也许是管理站的最重要的页面，并且也是最容易修改的。

自定义的模板是admin/index.html。（使用之前对于admin/base_site.html所做的修改---复制至你的自定义模板目录。）编辑这个文件，你将会看到它使用了一个变量：app_list.它包含所有安装的Django应用。你可以通过硬编码连接到特定的对象页面来替换它以达到你所认为的最好效果。再次，不要对于还不知道模板语言而着急---我们将会在第三部分中详细介绍。

当你对于这一块熟悉以后，开始我们的第三部分教程。

Feed enhanced by Better Feed from Ozh

写你的第一个Django程序 1st

小水 — Thu, 17 Jun 2010 21:54:25 +0800

让我们通过例子来学习。

通过这个教程，我们将会全程经历创建基本的投票程序的创建过程。

它将包含两个部分：

一个公开的站点，让人们来查看投票并且参与投票
一个管理员站点，使你可以添加、删除、修改投票

我们假设你已经安装好了Django。你可以通过Python的命令行来判断是否将Django安装完成，输入import Django。如果命令行成功运行，Django即为正确安装。

创建一个项目

这是你第一次使用Django，你必须注意一些初始化操作。也就是说，你必须自动创建一些代码来建立一个Django项目–一个Django项目的一系列设置，包括数据库设置、Django特殊设置和应用程序设置。

在命令行，cd进入一个目录，在这里你可以存储你的代码，然后运行指令django-admin.py startproject mysite。这将会创建一个mysite目录在当前目录下。

如果你是通过python setup.py安装Django，那么django-admin.py应当在你的系统路径中。如果没有存在，你可以在site-packges/django/bin中发现它，这就是你的site-packages在Python中的目录。考虑到对性django-admin.py的链接从你的路径的某些地方，例如/usr/local/bin。

让我们看看startproject创建了什么文件：

mysite/
    __init__.py
    manage.py
    settings.py
    urls.py

这些文件是：

__init__.py:一个空的文件告诉Python这个路径应当被当做一个Python包。
manage.py:一个命令行，允许你通过各种方式和Django项目交互。你可以阅读更多通过django-admin.py and manage.py。
settings.py:设置/配置Django项目。Django settings将会告诉它是如何工作的。
urls.py:这个URL为项目声明。一个关于你Django驱动的内容表。你可以阅读更多通过URL dispatcher.

开发服务器

让我们运行它。进入，mysite目录，运行命令行：python manage.py runserver。你将会看到如下的输出：

Validating models...
0 errors found.

Django version 1.0, using settings 'mysite.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

你已经启动了Django开发服务器，一个使用Python写的轻量的web服务器。我们已经将其包含在Django中，这样你就能够立即开发项目而不用考虑配置服务器–比如Apache—在你发布产品之前。

现在是一个好的时机注意：不要再任何产品中包含此服务器的引用。它只是用来进行开发。

现在服务器已经运行，通过http://127.0.0.1:8000/访问你的站点。你将会看到一个蓝色、愉快色调的“Welcome to Django”页面。它成功运行了。

改变端口

默认情况下，runserver将项目的初始端口设置为8000。

如果你想改变这个端口，输入命令行参数。例如，你可以设置为8080端口：

python manage.py runserver 8080

如果你想改变ip地址，输入如下指令。这样将会侦听所有公用IP:

python manage.py runserver 0.0.0.0:8000

更多：runserver

建立数据库

现在，编辑settings.py。这是一个普通的Python模块，通过它反映Django的模块层。改变如下的DATABASES 'default'使其符合你的连接设置。

ENGINE—'django.db.backends.postgresql_psycopg2','django.db.backends.mysql' o或是'django.db.backends.sqlite3'.其他参见also available.
NAME — 你的数据库名.如果你在使用sqllite，它将是你的电脑上的一个文件，这样的话，name将是他的全路径，包括温江名。如果这个文件不存在，将会被自动建立在你同步数据库时。
USER — 你的数据库用户名 (not used for SQLite).
PASSWORD — 你的数据库密码(not used for SQLite).
HOST — 数据库所在地址. 当你的项目和数据库在同一台计算机时可以留空 (not used for SQLite).

如果你对于数据库时新手，我们强力建议你使用SQLite.它被包含在Python 2.5及其后版本中，所以你不用安装其他任何东西。

当你编辑settings.py是，注意INSTALLED_APPS于文件的底部。这个变量包含Django中所有激活的模块。程勋可以被不同的项目中被使用，你可以打包并且把他们适用于任何项目。

默认情况下，INSTALL_APPS包含如下的程序，他们默认在Django中。

django.contrib.auth — 认证系统。
django.contrib.contenttypes — 内容类型框架.
django.contrib.sessions — session框架.
django.contrib.sites — 在一个Django中管理不同站点框架.

这些程序默认情况下被包含。

这些程序至少使用一个数据库表，所以我们创建数据库表在我们使用它们之前。为了做到如此，使用如下的命令：

python manage.py syncdb

这个syncdb命令查找所有的INSTSLL_APPS设置并且通过数据库表设置文件settings.py来创建数据库表。在每个数据库表被创建时你将会看到一条信息，然后你将被询问是否创建一个超级管理员为认证系统。确认并且创建。

如果你感兴趣，你可以运行命令行为你的数据库，然后输入\dt (PostgreSQL), SHOW TABLES; (MySQL), or.schema (SQLite)来展示Django创建的所有表。

创建模块

现在你的环境—-一个项目已经被创建，你下一步将开始工作。

在Django中程序将包含一个Python模块，在你的Python路径中，从过一个确定的方式。Django创建默认方式产生一个程序的访问方式。这样你将集中注意于写代码而不是创建路径。

在这个教程中，我们将创建poll程序在mysite中。结果，程序将解耦—也就是说poll程序中的代码指向mysite.app。接着，我们将讨论解耦。

为了创建你的程序，确保进入mysite路径并且输入如下指令：

python manage.py startapp polls

这将会创建poll路径，包含如下文文件：

polls/
    __init__.py
    models.py
    tests.py
    views.py

这个路径将持有poll程序。

在数据库的web应用中第一步是定义你的模块—你的数据库框架包含额外的元信息。

在我们的poll应用中，我们创建了两个模块：polls和choices。一个poll包含一个问题（question）和发布时间（publication date）。一个选择（choice）包含两个属性：选择文本和投票数。每一个选项(choice)关联一个投票（poll）。

这些内容通过简单的Python类来展现。如下编辑polls/models.py：

from django.db import models

class Poll(models.Model):
    question = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')

class Choice(models.Model):
    poll = models.ForeignKey(Poll)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()

这些代码很直接。每一个模块通过一个django.db.models.Model的子类来展现。每一个模块包含一定数量的类变量，每一个展示数据库域在模块中。

每一个域通过一个Field类实例来代表—例如，CharField代表字符串，DateTimeField代表时间。这些告诉Django数据的类型。

每一个Field的实例是这个属性的名字，使用机器亲近的模式。你急那个使用这些值在你的Python代码中，并且你的数据库将会使用这些作为他的列明。

你可一个使用可选的第一位置参数给一个Field来满足一个人类可读的名字。这将会用作Django的交互部分，这将会使用文档表示。如果第一个域没有标明，Django将会使用机器可读名字。在例子中，我们只为Poll.pub_date顶一个可读属性。对于所有的属性，必须定义相应的可读属性。

一些域类包含必须属性.CharField，例如，要求你给出一个max_length。这不仅用于数据库，还用于变量。

最后，注意到关系被定义，使用ForeignKey。它告诉Django，每一个选择（choice）对应一个投票（poll）。Django支持所有的常见数据库关系：一对多，一对一，多对一。

激活模块

这个小的模块赋予Django许多信息。使用它，你可以：

创建一个数据表
创建一个连接数据库的API

但是，首先你要判断polls是否已经正确安装。

再次编辑settings.py，改变INSTALLED_APPS使其包含‘mysite.polls’。如下：

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'mysite.polls'
)

现在Django知道mysite已经能够包含了polls应用。让我们执行另一个命令：

python manage.py sql polls

你应当扛到下面类似的指令：

BEGIN;
CREATE TABLE "polls_poll" (
    "id" serial NOT NULL PRIMARY KEY,
    "question" varchar(200) NOT NULL,
    "pub_date" timestamp with time zone NOT NULL
);
CREATE TABLE "polls_choice" (
    "id" serial NOT NULL PRIMARY KEY,
    "poll_id" integer NOT NULL REFERENCES "polls_poll" ("id"),
    "choice" varchar(200) NOT NULL,
    "votes" integer NOT NULL
);
COMMIT;

注意如下：

实际的输出决定于你的数据库
表名称结合应用名称（polls）和模块名称小写字母自动产生（—-polls和choice）
主键自动添加
通过转换，Django追加“_id”到每一个外键。你也可以重写它
外键关系被REFERENCE来解释
It’s tailored to the database you’re using, so database-specific field types such as auto_increment (MySQL), serial(PostgreSQL), or integer primary key (SQLite) are handled for you automatically. Same goes for quoting of field names — e.g., using double quotes or single quotes. The author of this tutorial runs PostgreSQL, so the example output is in PostgreSQL syntax.
sql命令不一定在你的数据库中运行–它只是在屏幕上显示Django需要的，如果你想，可以复制粘贴进入你的数据库命令行。然后，就像我们看到的，Django提供一种更简单的方式

如果你有兴趣，可以执行如下命令：

python manage.py validate — Checks for any errors in the construction of your models.
python manage.py sqlcustom polls — Outputs any custom SQL statements (such as table modifications or constraints) that are defined for the application
python manage.py sqlclear polls — Outputs the necessaryDROP TABLE statements for this app, according to which tables already exist in your database (if any)
python manage.py sqlindexes polls — Outputs the CREATE INDEXstatements for this app.
python manage.py sqlall polls — A combination of all the SQL from the sql, sqlcustom, and sqlindexes commands. 查看这些命令的输出能够让你更加理解发生了什么。

现在执行syncdb来创建模块表在你的数据库中。

python manage.py syncdb

这个syncdb执行sql命令从sqlall在你的数据库中为你的所有INSTALL_APPS中存在的应用。浙江会创建所有的表，初始化数据，为你所有的应用添加索引。

使用API

现在让我们进入交互行然后使用Django给你的免费API。进入命令行后输入：

python manage.py shell

我们使用这个而不是简单的输入“python”,因为manage.py设置了整个项目环境为你。“设置项目环境”包含下面两个事情：

Putting mysite on sys.path. For flexibility, several pieces of Django refer to projects in Python dotted-path notation (e.g.'mysite.polls.models'). In order for this to work, the mysitepackage has to be on sys.path.We’ve already seen one example of this: the INSTALLED_APPSsetting is a list of packages in dotted-path notation.
Setting the DJANGO_SETTINGS_MODULE environment variable, which gives Django the path to your settings.py file.一旦你进入交互行，探索数据库API吧：

>>> from mysite.polls.models import Poll, Choice # Import the model classes we just wrote.

# No polls are in the system yet.
>>> Poll.objects.all()
[]

# Create a new Poll.
>>> import datetime
>>> p = Poll(question="What's up?", pub_date=datetime.datetime.now())

# Save the object into the database. You have to call save() explicitly.
>>> p.save()

# Now it has an ID. Note that this might say "1L" instead of "1", depending
# on which database you're using. That's no biggie; it just means your
# database backend prefers to return integers as Python long integer
# objects.
>>> p.id
1

# Access database columns via Python attributes.
>>> p.question
"What's up?"
>>> p.pub_date
datetime.datetime(2007, 7, 15, 12, 00, 53)

# Change values by changing the attributes, then calling save().
>>> p.pub_date = datetime.datetime(2007, 4, 1, 0, 0)
>>> p.save()

# objects.all() displays all the polls in the database.
>>> Poll.objects.all()
[<Poll: Poll object>]

<Poll: Poll object>

class Poll(models.Model):
    # ...
    def __unicode__(self):
        return self.question

class Choice(models.Model):
    # ...
    def __unicode__(self):
        return self.choice

添加__unicode__()给你的模块是很重要的，不仅是因为你的不仅为自己的清醒时，迅速处理的互动性，而且还因为对象的表示是管理员用于整个Django的自动生成。

请注意这些都是Python的用法。让我们添加一个自定义模块：

import datetime
# ...
class Poll(models.Model):
    # ...
    def was_published_today(self):
        return self.pub_date.date() == datetime.date.today()

注意到添加的import datetime引用了Python的标准模块datetime。保存并重新输入命令：

>>> from mysite.polls.models import Poll, Choice

# Make sure our __unicode__() addition worked.
>>> Poll.objects.all()
[<Poll: What's up?>]

# Django provides a rich database lookup API that's entirely driven by
# keyword arguments.
>>> Poll.objects.filter(id=1)
[<Poll: What's up?>]
>>> Poll.objects.filter(question__startswith='What')
[<Poll: What's up?>]

# Get the poll whose year is 2007.
>>> Poll.objects.get(pub_date__year=2007)
<Poll: What's up?>

>>> Poll.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Poll matching query does not exist.

# Lookup by a primary key is the most common case, so Django provides a
# shortcut for primary-key exact lookups.
# The following is identical to Poll.objects.get(id=1).
>>> Poll.objects.get(pk=1)
<Poll: What's up?>

# Make sure our custom method worked.
>>> p = Poll.objects.get(pk=1)
>>> p.was_published_today()
False

# Give the Poll a couple of Choices. The create call constructs a new
# choice object, does the INSERT statement, adds the choice to the set
# of available choices and returns the new Choice object. Django creates
# a set to hold the "other side" of a ForeignKey relation
# (e.g. a poll's choices) which can be accessed via the API.
>>> p = Poll.objects.get(pk=1)

# Display any choices from the related object set -- none so far.
>>> p.choice_set.all()
[]

# Create three choices.
>>> p.choice_set.create(choice='Not much', votes=0)
<Choice: Not much>
>>> p.choice_set.create(choice='The sky', votes=0)
<Choice: The sky>
>>> c = p.choice_set.create(choice='Just hacking again', votes=0)

# Choice objects have API access to their related Poll objects.
>>> c.poll
<Poll: What's up?>

# And vice versa: Poll objects get access to Choice objects.
>>> p.choice_set.all()
[<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]
>>> p.choice_set.count()
3

# The API automatically follows relationships as far as you need.
# Use double underscores to separate relationships.
# This works as many levels deep as you want; there's no limit.
# Find all Choices for any poll whose pub_date is in 2007.
>>> Choice.objects.filter(poll__pub_date__year=2007)
[<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]

# Let's delete one of the choices. Use delete() for that.
>>> c = p.choice_set.filter(choice__startswith='Just hacking')
>>> c.delete()

For more information on model relations, see Accessing related objects. For full details on the database API, see ourDatabase API reference.

When you’re comfortable with the API, read part 2 of this tutorial to get Django’s automatic admin working.

Feed enhanced by Better Feed from Ozh

1st.Django at a glance

小水 — Wed, 16 Jun 2010 23:33:44 +0800

由于Django是快速的开发环境，它被设计于使web开发任务更加快速、简单。这里是对如何使用Django开发数据驱动程序的一些介绍。

本文的目的是给你足够的技术来理解Django如何工作，虽然不是要写成一个指南或是教程–但是实际上已经具备了二者的功能。当你准备一个工程之时，你可以开始阅读这个教程或是其他的相关文章。

设计你的模块

尽管你可以不使用数据库来构建你的Django，他是一个对象关系型的mapper，你使用Python来描绘数据库构架。

数据模块驱动提供多种模块的展现方式–迄今为止，他已经解决了两年的数据库表问题。这是一个例子：

class Reporter(models.Model):
    full_name = models.CharField(max_length=70)

    def __unicode__(self):
        return self.full_name

class Article(models.Model):
    pub_date = models.DateTimeField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter)

    def __unicode__(self):
        return self.headline

安装

接下来，使用Django的命令行模式来自动创建数据库表：

manage.py syncdb

syncdb命令将会查看所有的可用模块，并且在你的数据库中创建没有的表。

享受免费的API

利用这个，你可以得到一个免费的、丰富的Python API来操作你的数据。这些api创建于高层的、五代码的层需求之上：

>>> from mysite.models import Reporter, Article

# No reporters are in the system yet.
>>> Reporter.objects.all()
[]

# Create a new Reporter.
>>> r = Reporter(full_name='John Smith')

# Save the object into the database. You have to call save() explicitly.
>>> r.save()

# Now it has an ID.
>>> r.id
1

# Now the new reporter is in the database.
>>> Reporter.objects.all()
[<Reporter: John Smith>]

# Fields are represented as attributes on the Python object.
>>> r.full_name
'John Smith'

# Django provides a rich database lookup API.
>>> Reporter.objects.get(id=1)
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__startswith='John')
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__contains='mith')
<Reporter: John Smith>
>>> Reporter.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Reporter matching query does not exist.

# Create an article.
>>> from datetime import datetime
>>> a = Article(pub_date=datetime.now(), headline='Django is cool',
...     content='Yeah.', reporter=r)
>>> a.save()

# Now the article is in the database.
>>> Article.objects.all()
[<Article: Django is cool>]

# Article objects get API access to related Reporter objects.
>>> r = a.reporter
>>> r.full_name
'John Smith'

# And vice versa: Reporter objects get API access to Article objects.
>>> r.article_set.all()
[<Article: Django is cool>]

# The API follows relationships as far as you need, performing efficient
# JOINs for you behind the scenes.
# This finds all articles by a reporter whose name starts with "John".
>>> Article.objects.filter(reporter__full_name__startswith="John")
[<Article: Django is cool>]

# Change an object by altering its attributes and calling save().
>>> r.full_name = 'Billy Goat'
>>> r.save()

# Delete an object with delete().
>>> r.delete()

动态管理接口：不仅是脚手架—他是一整座房屋

一旦你的模块已经被定义，Django可以自动创建专业的、高效率的管理接口—-一个网站，可以田间、修稿、删除认证用户。在管理站很容易来注册你的模块：

# In models.py...

from django.db import models

class Article(models.Model):
    pub_date = models.DateTimeField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter)

# In admin.py in the same directory...

import models
from django.contrib import admin

admin.site.register(models.Article)

这逻辑在于你的站点时被员工或是客户来编辑，或是你自己—-你不想来亲自创建底层的接口来管理内容。

在Django应用程序中的一个典型的工作流式创建模块，在管理站点注册并且迅速执行，这样你的员工（或是客户）能够发布数据。接着，将数据发布给用户。

设计你的URLs

一个清晰、高雅的URL表对于高质量的web应用来说是至关重要的。Django促进了高雅的URL设计，并且不会吧无用的东西放入到URL中，例如.php或是.asp。

为了给程序设计urls.你可以给使用一个Python模块，称之为：URLconf。一个你的程序的内容表，包含简单的映射介于URL和Python回调函数之间。URLconf同样解耦从Python代码。

下面是一个URLconf看起来的样子对于Report/Article：

from django.conf.urls.defaults import *

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

这个地图URL，像简单的正则表达式，指向Python回调函数（“views”）。正则表达式，获取URL的值。当一个用户请求一个页面时，Django通过执行每一个模式顺序执行，然后再第一个符合的地方停止（如果没有符合的就会出现特殊的404页面）。这个执行很快，因为正则表达式在页面加载时执行。

一旦一个正则符合，Django导入并且调用这个页面，这是一个简单的Python函数。每一个页面获得一个请求对象—它包含请求元数据—数据被正则获取。

举例子，如果一个用户获取URL“/article/2005/05/39323”,Django就爱你干活调用函数mysite.views.article_detail(request,’2005’,’05’,’39323’)。

写你的页面

每一个页面负责连个事情：返回一个httpresponse对象，其中包含请求页的内容，或是刮起一个错误例如HTTP·404。其他的在于你。

一般来说，一个视图通过参数返回数据，载入模板并且将模板和数据结合。这是一个页面的代码：

def year_archive(request, year):
    a_list = Article.objects.filter(pub_date__year=year)
    return render_to_response('news/year_archive.html', {'year': year, 'article_list': a_list})

设计你的模板

上面的代码载入news/year_archive.html模板。

Django有一个模板搜索路径，它允许你将模板的冗余最小化。在你的Django设置中，你可以定义一个路径列表来检查模板。如果一个模板在第一个路径中不存在，它将会检查第二个，依次进行。

让我们看看news/article_detail.html模板被发现的过程：

{% extends "base.html" %}

{% block title %}Articles for {{ year }}{% endblock %}

{% block content %}
<h1>Articles for {{ year }}</h1>

{% for article in article_list %}
    <p>{{ article.headline }}</p>
    <p>By {{ article.reporter.full_name }}</p>
    <p>Published {{ article.pub_date|date:"F j, Y" }}</p>
{% endfor %}
{% endblock %}

变量被双引号号包围。{{ article.headline }}意味着“输出文章的标题属性”。但是点不只是用来表示属性“他同样可以用作字典查找、索引查找和函数调用。

注意到{{ article.pub_date|date:"F j, Y" }}使用Unix-style”pipe“(这个”|“)。这被叫做一个模板文件夹，并且它过滤输出变量属性值。这种情况下，时间被Python的时间模板过滤（奖项是PHP 的时就爱你函数）。

你可以连接很多过滤。你可以写出自己的过滤。你可以写自己的模板标签，将会在后台执行Python代码。

最后，Django使用模板继承：这就是{% extends "base.html" %}所实现的。它表示”首先载入”base“模板，它定义了一个块，并且使用下面的块填充。简单来说，它使你动态减少了模板中的冗余：每一个模板只需要定义它唯一的东西。

下面是一个“base.html”模板内容：

<html>
<head>
    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <img src="sitelogo.gif" alt="Logo" />
    {% block content %}{% endblock %}
</body>
</html>

最简单的，它定义了外表和感受为你的站点（使用站点的logo），并且提供”洞“给你的子模板来填充。这将会是站点更改更加简单因为你将只需要改变一个文件—base.html。

注意到你不必非要使用Django的模板如果你偏好另外的话。虽然Django得模板系统更好的和Django的模块结合，没有人和东西强迫你使用它。因此，你不必同样必须使用Django的数据库API。你可以使用其他系统的数据库抽象层，你可以读取XML文件，你可以读取硬盘或是其他的你所需要的。Django的其他块—模块、视图、模板—将会接下来解耦。

这只是表面

我们已经系统的看过了Django的功能。更多的阅读：

A caching framework that integrates with memcached or other backends.
A syndication framework that makes creating RSS and Atom feeds as easy as writing a small Python class.
More sexy automatically-generated admin features — this overview barely scratched the surface.

Feed enhanced by Better Feed from Ozh

Django for me

小水 — Wed, 16 Jun 2010 23:32:44 +0800

这一次的英语6级很有很有危险，所以找个方式为下一次六级做准备，想了半天，准备翻译Django的官方文档，借机提高自己的英文能力和学习Django。

呵呵，以前不知道这个构架，因为有段时间迷Python所以会经常看到这个web构建的介绍。很想学习，但是，总是给自己找各种接口没有看，现在是“机会来了”。

其实，学习Django，你要有基本的Python基础，但是，对我来说，依旧是一项新的挑战。

不管怎样，以后都会是一个“走动”的时代，任何东西不再局限于他的圈子，世界变小了，圈子变大了，也许Google让我们知道我们想知道的事，Facebook让我们认识我们想认识的人，但是，没有web构架，一些不会存在~所以，学一门构建技术很重要~既然有人使用Python给我们创造了这么好一个构建，那就学习吧，当然，随着学习的深入，一定会看到很多不足，所以，高手是会自己写构架的，但现在我还是菜鸟，很多东西还很深奥，我依旧是雾里看花~

学习是一个人得以进步的方式，理想是一个人前行的动力，所以，不要满足于现在，学习更多的东西~

Django算是我的web学习入门学习~好好学

Feed enhanced by Better Feed from Ozh

第六感

小水 — Tue, 15 Jun 2010 14:40:17 +0800

智慧会创造什么？财富？生产力？

NO，心灵的撼动~

Feed enhanced by Better Feed from Ozh

矿泉水的历程

小水 — Mon, 14 Jun 2010 01:28:51 +0800

矿泉水喝了很久了

真的没有很久坚持做一件事情了，维持这个博客让我起码觉得没有荒废很多。

同时，这个博客也见证了我的成长，学习、工作、爱情

“只有走过才能成长，只有经历过才会明白”—写博客的原因之一

回顾整个博客的历程：

2009-06-17:购买了域名magicshui.cn

之前的一段时间尝试过很多的免费的博客服务，但是都不尽人意，当然了，那时候还是对于blogger很懵懂，不知道这是干嘛的，所以没有珍惜blogger.com能够访问的日子，后悔了~不过，还是以很低的价钱购买了magicshui.cn，然后开始筹划自己的独立博客，这样很装13

2009-06-19:购买了空间和数据库

看到这个标题，你就知道我实在国内买的空间和数据库，因为只有国内的黑心厂商才会这样来拆分赚钱，Fuck，当时竟然还觉得挺便宜的，好傻呀！

然后就开始了自己的折腾生涯，像很多人开始一样，我也没有听说过WordPress，用的是z-blog，但是，追求小众的想法让我对WordPress产生了好感，由于当时还没有什么数据，就删了重新建立了基于WordPress的站点。

开始不知道要为自己的博客起一个怎样的名字，于是就问了波波童鞋，呵呵，因为他很搞（起码我是这样认为的，我们都是闷骚的淫）~于是，矿泉水诞生了！

后来因为博客服务商不怎么地，就搜索更好的婆家，其后认识了simple（北大的高材生），呵呵，后来还会在说到他的~然后，就经常在simple的博客上踩踩，互访~是我的第一个友链，其实当时对于友情链接没有任何理会

2009-08-19:购买了现在的空间

在经历了不断地博客宕机和数据库的全部数据丢失以后，我真的对国内的这个所谓的服务商无奈了，于是，在Google之后发现了胡戈戈，呵呵，其实衡天小张也挺不错的，但是，本着不想备案的原则就买了外国的主机，事实证明我终于做了一个明智的选择。

其后发现，自己一个人单枪匹马是不能创出名堂来，我们需要依附于一个组织，然后机缘巧合之中加入了WPG独立博客联盟，呵呵，这是一个很放松的地方，同时，也很年轻，估计我也算是早一批加入的人，但是也同样是早一批潜水的人，自我批评一下，就像我前边说到的，我在这里碰到了simple，呵呵，他比我再点进入组织~

不管怎样，WPG当时、现在都是一个很小众很牛气的组织，因此能够挂出来一个组织的图标同样装13，哈哈~但是，由于那段时间的确很忙）——学生会的p事，就和组织脱节了，以至于连潜水也没有进行，再次自我批评~现在组织已经不断的发展壮大了，的确很牛哈~当然其中贡献最大的是Joya姐姐，大家可以去踩她的博客，不过还是那句话：非诚勿扰

对于访问别人的博客，自己的观点也有了变化，开始只要你来我的博客，我就去你的留言，然后交换链接，但是，这的确没有任何意义，因为我们讲的是友情不只是链接，所以后来就把这些都淡化了不当成一种负担，这样才能快乐写博~

2009-9-19：恋爱了

这个和博客无关，但是那一天恋爱了，表白成功，顺利摆脱了单身，然后就时不时肉麻一下路过的童鞋，在这里对于被肉麻到的童鞋表示歉意~可以这样说，矿泉水见证了我的爱情历程，分分合合我想没有什么比他更清楚了~

2009-12-3：生日

这一天一直在研究Django的设置和GAE，所以就没打算怎么过生日，但是办公室的朋友们给了我一个以外的惊喜，当我被骗到了小花园时发现地上摆满了蜡烛，中间是18的字样，生日快乐从大家的口中说出，顿时那叫一个感动呀~但是没哭，不知道为什么~那天真的很高兴，很多东西意想不到，谢谢大家，谢谢所有的朋友们~爱你们

2009-12-25：圣诞节彩蛋

到了圣诞节了，这段时间一直不断地对主题小打小闹，同时在节日来临之际就像弄点不一样的东西，于是查了半天代码，在博客中加入了圣诞节彩蛋（小雪童鞋第一个发现彩蛋，鼓掌）

2010-1-1：更换主题

博客使用了很多主题，其中使用最长的是大家熟悉的wsly的那款简单的主题，因为他很简单，后来在林木木的博客上同样看到了这款主题的改进版以及林木木的演绎版本，看着自己的主题小打小闹有点惭愧~

2010-3-1：更换域名

后来大家知道，网络审查的确开始严格起来，GFW的威力是不容小视的，虽然博客空间在国外，但是域名确实国内的cn域名，为了避免麻烦在过年之际就购买了godaddy的域名（奔着它的名声）shui.us,然后绑定成功，但是一直没有写一篇特别正式的文章来说这个事情，因为忘了，导致有些童鞋那两天rss订阅失败，真的很抱歉~后来，胡戈戈童鞋告诉：可以绑定三个域名，好吧，继续绑定着magicshui.cn，但是好不容易攒起来的pr也降为了0，而shui.us也要从头再来~

2010~~

后来就发现了原来网络不只是博客等等，微博客也是很迅猛的，于是千方百计翻过了墙然后重新进入twitter来探索天地，在上边认识了一些朋友，呵呵，链接上的小雪童鞋也是在这个上边认识的~

其后，在不断地折腾中，少了很多文章呈现，因为觉得很多都不是很清晰发布的意义，于是就在草稿中放着放着没了~呵呵，但是，对于很多事情却多了自己的一份理解~男人成熟的标志是话少了，大家叫这个为：稳重。

其实，折腾的道路还很漫长，我想用博客来记录自己的成长~

Feed enhanced by Better Feed from Ozh

还会再见

小水 — Sun, 06 Jun 2010 13:25:07 +0800

又到了毕业的季节，所有的教室都被占用进行论文答辩，给了我一个不去上自习的理由~寝室外的路上挂起了一个横幅：毕业生物资交流会：其实就是大四的学长学姐们买旧书~尤其是在星期六星期天，这个景象更加热闹~

想想，自己来到大学已经两年了~而这些人是自己送走的第一届认识的人~

刚来大学的时候，纯呀~呵呵

大一的时候，认识的最高年级的是大三的，因为在学生会混迹，于是就会在主席的带领下进行工作~我们的主管主席，特别可爱善良的硕姐，今年也要毕业了，呵呵，硕姐去英国留学，赞一个~祝硕姐一切顺利~~其实，和哥哥姐姐们的交流不多，但是，从他们身上学到了一些东西，呵呵，尤其后来自己也大二了，留部了以后，就越发觉得他们的确很厉害，因为这些工作远没有我们想的那么简单~哎，让自己大一只顾着闷骚了（嘉铭的话），和哥哥姐姐们交流太少~遗憾了~

在路上走着，就开始想着自己的毕业时光~

不知道会是怎样的心情~

但是我觉得不会像张震岳唱的那样，以后再也不见，大学里，有我敬爱的老师、学长，还有一帮可爱的学弟学妹，我会送走学长们，也同样会在学弟学妹的挥手告别中走出校门，但是，以后我们还会再见~

想想，其实大学生活过的很快，不知不觉就已经过去了两年时光~还有两年，对自己说

这个学期还好，没有什么大的波澜，一切很平淡~

又是盛夏季节L:哥哥姐姐们~我们还会再见的~加油呀

Feed enhanced by Better Feed from Ozh