Differences between revisions 1 and 9 (spanning 8 versions)
⇤ ← Revision 1 as of 2008-09-09 14:53:00 →
Size: 9635
Editor: HuangYi
Comment:
← Revision 9 as of 2008-09-18 23:46:06 → ⇥
Size: 10802
Editor: HuangYi
Comment:
Deletions are marked like this. Additions are marked like this.
Line 1: Line 1:
## Do not edit this header. It is not part of the wiki code and will not be
## posted back to the wiki when you save.
## Base: http://wiki.woodpecker.org.cn/moin/
## Page: ObpLovelyPython/PCS300
## Secs:
## END OF HEADER
Line 9: Line 3:
#format rst
Line 13: Line 6:
.. contents::
=========
django
=========

开门见山
========

Python 世界最火爆的 web 框架。MTV（Model Template View）模式。提倡将 project 分解成可重有的 app。
存在大量开源的 app 可以直接拿来用，以迅雷不及掩耳之势搭建复杂的 web 应用。

下载安装
=========

从官方网站（http://www.djangoproject.com/）下载最新版本，解压，执行 python setup.py install 。然后旅程开始。

快速起步
=========		 [[TableOfContents]]

= 开门见山 Django快速体验 =

== 开门见山 ==

Django 是 Python 世界目前最火爆的 web 框架。它提倡将 project 分解成可重有的 app。
并且 Django 社区有很好的编写可重用 app 的传统，存在大量开源的 app 可以直接拿来用，
帮助你以迅雷不及掩耳之势搭建功能强大的 web 应用。

== 下载安装 ==

从官方网站(http://www.djangoproject.com/download/) 下载最新版本，解压，执行执行命令 {{{python setup.py install}}} 进行安装。然后旅程开始。

== 快速起步 ==
Line 33: Line 23:
::

创建项目：
>django-admin.py startproject simple_wiki
进入项目的目录：
>cd simple_wiki
启动测试服务器：
\simple_wiki>manage.py runserver
Validating models...
0 errors found
...

现在打开个浏览器访问 http://localhost:8000/ ，就可以看到一个欢迎页面了：
{{{
  创建项目：
  >django-admin.py startproject simple_wiki
  进入项目的目录：
  >cd simple_wiki
  启动测试服务器：
  simple_wiki>manage.py runserver
  Validating models...
  0 errors found
  ...
}}}

这样就启动了 Django 自带的开发服务器，现在打开个浏览器访问 http://localhost:8000/ ，
就可以看到一个欢迎页面了：
Line 49: Line 41:
OK，我们先把这个命令行窗口留着别关，里面启动着 django 的开发web服务器呢。

下面我们得配置下数据库先，图方便，我们就直接使用python2.5自带的数据库引擎 sqlite 吧。编辑 settings.py ，设置以下两项： ::

DATABASE_ENGINE = 'sqlite3'
DATABASE_NAME = 'data.db'

如果你恰好和我一样，在中国大陆并且母语汉语，那就顺便再设置这样两项： ::

TIME_ZONE = 'Asia/Shanghai'
LANGUAGE_CODE = 'zh-CN'

再把自带的 admin app 启用了，找到 INSTALLED_APPS ，在里面加一行如下： ::

INSTALLED_APPS = (
    ...
 'django.contrib.admin',
)

我们再给自动的 admin 后台管理界面设置一个访问的入口，也就是 url。编辑 urls.py 文件，去掉第三、四行和倒数第二行的注释即可： ::

...
from django.contrib import admin
admin.autodiscover()
...
 (r'^admin/(.*)', admin.site.root),
)

然后，创建下数据库。打开一个新的命令行窗口并切换到 simple_wiki 目录，执行命令： ::

\simple_wiki>manage.py syncdb
Creating table auth_permission
...		 我们暂且把这个命令行窗口留着别关，不用管它，后面我们的Python代码修改后，
此服务器会自动重启以执行最新的代码，可以提高大家的开发效率。

下面我们得配置下数据库先，图方便，我们就直接使用python2.5自带的数据库引擎 sqlite 吧。编辑 settings.py ，设置以下两项：

{{{#!python
  DATABASE_ENGINE = 'sqlite3'
  DATABASE_NAME = 'data.db'
}}}

如果你恰好和我一样，在中国大陆并且母语汉语，那就顺便再设置这样两项：

{{{#!python
  TIME_ZONE = 'Asia/Shanghai'
  LANGUAGE_CODE = 'zh-CN'
}}}

再把自带的 admin app 启用了，找到 INSTALLED_APPS ，在里面加一行如下：

{{{#!python
  INSTALLED_APPS = (
      ...
   'django.contrib.admin',
  )
}}}

我们再给自动的 admin 后台管理界面设置一个访问的入口，也就是 url。编辑 urls.py 文件，去掉第三、四行和倒数第二行的注释即可：

{{{#!python
  ...
  from django.contrib import admin
  admin.autodiscover()
  ...
   (r'^admin/(.*)', admin.site.root),
  )
}}}

然后，创建下数据库。打开一个新的命令行窗口并切换到 simple_wiki 目录，执行命令：

{{{
  simple_wiki>manage.py syncdb
  Creating table auth_permission
  ...
}}}
Line 87: Line 90:
建立Model
============

配置完成后，我们就写个超级简单的 wiki 试试吧。由于对于 django 来说，一个 project 就是一堆 app 的组合，在我们编写功能前，需要先建一个 app ： ::

\simple_wiki>manage.py startapp wiki

然后我们在配置里面启用这个 app ，修改 settings.py 在 INSTALLED_APPS 里面增加一行： ::

 'simple_wiki.wiki',

然后修改 wiki\models.py ，填充如下代码（model api：TODO url）： ::

# coding: utf-8
from django.db import models

# 代表 wiki 页面的 Model
class WikiPage(models.Model):
    title = models.CharField(u'页面标题', maxlength=255)
    content = models.TextField(u'页面内容')
    class Meta:
        # 在显示在管理后台中名字
        verbose_name = verbose_name_plural = u'Wiki页面'

from django.contrib import admin
# 注册到管理后台
admin.site.register(WikiPage)		 == 建立Model ==

配置完成后，我们就写个超级简单的 wiki 试试吧。由于对于 django 来说，一个 project 就是一堆 app 的组合，在我们编写功能前，需要先建一个 app ：

{{{
  simple_wiki>manage.py startapp wiki
}}}

然后我们在配置里面启用这个 app ，修改 settings.py 在 INSTALLED_APPS 里面增加一行：

{{{#!python
   'simple_wiki.wiki',
}}}

然后修改 {{{wiki/models.py}}} ，填充如下代码：

{{{#!python
  # coding: utf-8
  from django.db import models

  # 代表 wiki 页面的 Model
  class WikiPage(models.Model):
   title = models.CharField(u'页面标题', max_length=255)
      email = models.EmailField(u'创建者Email', max_length=255)
      content = models.TextField(u'页面内容')
      class Meta:
          # 显示在管理后台中名字
          verbose_name = verbose_name_plural = u'Wiki页面'

  # 定义 WikiPage 的后台管理界面
  class WikiPageAdmin(admin.ModelAdmin):
      # 定义列表页显示的字段
      list_display = ('title', 'email')
      # 显示搜索框，并定义搜索的字段
      search_fields = ['title', 'email', 'content']
      # 设置每页显示数量
      list_per_page = 50

  from django.contrib import admin
  # 注册到管理后台
  admin.site.register(WikiPage, WikiPageAdmin)
}}}
Line 116: Line 135:

然后创建相应的数据表。执行命令： ::

\simple_wiki>manage.py syncdb
Creating table wiki_wikipage		 (Model定义的详细内容见： http://docs.djangoproject.com/en/dev/topics/db/models/ )

然后创建相应的数据表。执行命令：

{{{#!python
  simple_wiki>manage.py syncdb
  Creating table wiki_wikipage
}}}
Line 123: Line 145:
（定制admin：URL） (关于定制admin的详细内容：http://docs.djangoproject.com/en/dev/ref/contrib/admin/#ref-contrib-admin )
Line 129: Line 151:
展示页面
=========

现在我们再写点代码把数据库里的 wiki 页面展示出来。修改 wiki\views.py ，填充以下内容 ： ::

# coding: utf-8
from django.shortcuts import render_to_response, get_object_or_404
from simple_wiki.wiki.models import WikiPage

def view_page(request, title='FrontPage'):
    # 根据 title 查询页面数据，如果不存在自动显示 404 错误页面。
    page = get_object_or_404(WikiPage, title=title)
    # 渲染模板。
    return render_to_response('page_view.html', {'page':page})

现在，MTV 的 M（Model）和V（View）都有了，下面我们就增加个 T（Template），在 wiki 目录下面创建目录 templates ，在里面创建模板文件 page_view.html ，内容如下： ::

<html>
  <head>
    <title>{{ page.title }}</title>
  </head>
  <body>
    {{ page.content }}
  </body>
</html>

模板文件中使用 {{ }} 表示把中间的对象的值填充在相应的位置。模板中还有许多其他的语法，比如分支、循环、继承等，详见文档（）。

最后我们再给页面展示设置一个 url，修改 urls.py ，增加一条 url 映射规则如下： ::

urlpatterns = patterns('',
    ...
 (r'^simple_wiki/(\w+?)/?$', 'simple_wiki.wiki.views.view_page'),
    ...
 == 展示页面 ==

现在我们再写点代码把数据库里的 wiki 页面展示出来。修改 {{{wiki/views.py}}} ，填充以下内容 ：

{{{#!python
  # coding: utf-8
  from django.shortcuts import render_to_response, get_object_or_404
  from simple_wiki.wiki.models import WikiPage

  def view_page(request, title='FrontPage'):
   # 根据 title 查询页面数据，如果不存在自动显示 404 错误页面。
      page = get_object_or_404(WikiPage, title=title)
      # 渲染模板。
      return render_to_response('page_view.html', {'page':page})
}}}

现在，MTV 的 M（Model）和V（View）都有了，下面我们再来增加个 T（Template），在 wiki 目录下面创建目录 templates ，在里面创建模板文件 page_view.html ，内容如下：

{{{
  <html>
    <head>
      <title>{{ page.title }}</title>
    </head>
   <body>
      {{ page.content }}
   </body>
  </html>
}}}

模板文件中使用 {{ }} 表示把中间的对象的值填充在相应的位置。模板中还有许多其他的语法，比如分支、循环、继承等。(关于django模板语法的详细内容见 http://docs.djangoproject.com/en/dev/topics/templates/#topics-templates )

最后我们再给页面展示设置一个 url，修改 urls.py ，增加一条 url 映射规则如下：

{{{#!python
  urlpatterns = patterns('',
      ...
   (r'^simple_wiki/(\w+?)/?$', 'simple_wiki.wiki.views.view_page'),
      ...
}}}
Line 167: Line 193:
处理表单
=========

现在如果我们访问一个不存在的 wiki 页面，比如 http://localhost:8000/simple_wiki/Python ，会得到一个 404 页面。这显然还不够好，应该提示用户去创建相应的页面。修改 wiki/views.py 页面如下： ::

# coding: utf-8
from django.shortcuts import render_to_response, get_object_or_404
from django import forms
from simple_wiki.wiki.models import WikiPage

# 让 django 从 WikiPage 这个 model 自动产生的 form，然后把 title 的 widget 改成隐藏表单。
class WikiPageForm(forms.ModelForm):
    title = forms.CharField(widget=forms.HiddenInput())
    class Meta:
        model = WikiPage

def view_page(request, title='FrontPage'):
    try:
        page = WikiPage.objects.get(title=title) # 查询一个页面对象
    except WikiPage.DoesNotExist:
        # 如果数据不存在，显示内容提示用户创建相应页面
        return render_to_response('page_empty.html', {title:title})
    else:
        # 页面存在，则显示这个页面。
        return render_to_response('page_view.html', {'page':page})

在 wiki\templates 目录下再添加一个模板 page_empty.html，内容如下： ::

<html>
  <head>
    <title>页面{{ title }}不存在</title>
  </head>
  <body>
    <h1>页面{{ title }}不存在，<a href="{{ title }}/edit">创建该页面</a></h1>
  </body>
</html>		 == 处理表单 ==

现在如果我们访问一个不存在的 wiki 页面，比如 http://localhost:8000/simple_wiki/Python ，会得到一个 404 页面。这显然还不够好，应该提示用户去创建相应的页面。修改 wiki/views.py 页面如下：

{{{#!python
  # coding: utf-8
  from django.shortcuts import render_to_response, get_object_or_404
  from django import forms
  from simple_wiki.wiki.models import WikiPage

  # 让 django 从 WikiPage 这个 model 自动产生的 form，同时覆盖 title 字段的 widget，把它改成隐藏表单。
  class WikiPageForm(forms.ModelForm):
   title = forms.CharField(widget=forms.HiddenInput())
      class Meta:
          model = WikiPage

  def view_page(request, title='FrontPage'):
      try:
   page = WikiPage.objects.get(title=title) # 查询一个页面对象
      except WikiPage.DoesNotExist:
   # 如果数据不存在，显示内容提示用户创建相应页面
          return render_to_response('page_empty.html', {title:title})
      else:
   # 页面存在，则显示这个页面。
          return render_to_response('page_view.html', {'page':page})
}}}

在 {{{wiki/templates}}} 目录下再添加一个模板 page_empty.html，内容如下：

{{{
  <html>
    <head>
   <title>页面{{ title }}不存在</title>
    </head>
   <body>
   <h1>页面{{ title }}不存在，<a href="{{ title }}/edit">创建该页面</a></h1>
    </body>
  </html>
}}}
Line 206: Line 235:
不过现在链接后面还没有真正创建页面的功能。下面我们继续编写代码，由于创建页面和编辑页面之间很相似，两个功能可以一起完成。在 wiki/views.py 文件顶部增加一行导入： ::

# HttpResponseRedirect 继承自 HttpResponse，代表页面跳转的 response
from django.http import HttpResponseRedirect

再添加一个 view 函数 edit_page 如下：

def edit_page(request, title):
    if request.method == 'GET':
        # 如果是 GET 请求，输出编辑框
 try:
            # 根据 tite 查询 wiki页面
            page = WikiPage.get(title=title)
        except WikiPage.DoesNotExists:
            # 如果不存在该页面，则显示一个创建表单
            form = WikiPageForm()
        else:
            # 否则，显示一个编辑表单
            form = WikiPageForm(instance=page)
        return render_to_response('page_edit.html', {'form':form})
    else:
        # 如果是表单提交，则保存相应的wiki页面数据
        form = WikiPageForm(request.POST)
        if form.errors:
            # 用过表单验证失败，需要提示用户修改输入内容
            return render_to_response('page_edit.html', {'form':form})
        page = form.save()
        # 成功，跳转到展示页面的地址
        return HttpResponseRedirect('/simple_wiki/'+page.title)

在 wiki\templates 目录下增加显示页面编辑表单的模板 page_edit.html ，内容如下： ::

<html>
  <head>
    <title>创建页面{{ title }}</title>
  </head>
  <body>
    <form method="post" action="">
      {{ form }}
      <br/>
      <input type="submit" value="提交"/>
    </form>
  </body>
</html>

最后在 urls.py 中配置页面编辑的 url： ::

   (r'^simple_wiki/(\w+?)/edit/?$', 'simple_wiki.wiki.views.edit_page'),

现在访问一个不存在 wiki 页面，比如： http://localhost:8000/simple_wiki/Python ，点击创建页面链接，填写表单，点击提交，然后跳转到展示的页面。

到这里，这个 wiki 就算是顺利完工了！

但是在这最后的最后，我还是忍不住要再向您展示一次 django 的非凡魅力。假如，您在这个时候突然发现需要做一点小改动，比如说，每个 wiki 页面还应该记录下它的创建者的邮箱，以便后期管理。		 不过现在链接后面还没有真正创建页面的功能。下面我们继续编写代码，由于创建页面和编辑页面之间很相似，两个功能可以一起完成。在 wiki/views.py 文件顶部增加一行导入：

{{{#!python
  # HttpResponseRedirect 继承自 HttpResponse，代表页面跳转的 response
  from django.http import HttpResponseRedirect
}}}

再添加一个 view 函数 edit_page 如下：   {{{#!python
  def edit_page(request, title):
   if request.method == 'GET':
          # 如果是 GET 请求，则显示表单
   try:
              # 根据 tite 查询 wiki页面
              page = WikiPage.get(title=title)
   except WikiPage.DoesNotExists:
   # 如果不存在该页面，则显示一个创建表单
              form = WikiPageForm()
          else:
   # 否则，显示一个编辑表单
              form = WikiPageForm(instance=page)
   return render_to_response('page_edit.html', {'form':form})
      else:
   # 如果是POST请求，则提交表单，并保存用户输入的wiki页面数据
   form = WikiPageForm(request.POST)
          if form.errors:
              # 表单验证失败，需要提示用户错误信息，并让用户重新输入内容
              return render_to_response('page_edit.html', {'form':form})
          page = form.save()
          # 数据保存成功，跳转到展示页面的地址
          return HttpResponseRedirect('/simple_wiki/'+page.title)
}}}

在 {{{wiki/templates}}} 目录下增加显示页面编辑表单的模板 page_edit.html ，内容如下：

{{{
  <html>
    <head>
   <title>创建页面{{ title }}</title>
    </head>
   <body>
   <form method="post" action="">
        {{ form }}
   <br/>
   <input type="submit" value="提交"/>
      </form>
   </body>
  </html>
}}}

最后在 urls.py 中配置页面编辑的 url：

{{{#!python
 (r'^simple_wiki/(\w+?)/edit/?$', 'simple_wiki.wiki.views.edit_page'),
}}}

现在访问一个不存在 wiki 页面，比如： http://localhost:8000/simple_wiki/Python ，点击创建页面链接，填写表单，点击提交，然后跳转到展示的页面。(更多表单处理的介绍：http://docs.djangoproject.com/en/dev/topics/forms/#topics-forms-index )

到这里，这个 wiki 就算是顺利完工了！相信大家对使用 django 进行web开发也有了基本的认识了吧。

status

草稿

HuangYi; 80%

TableOfContents

开门见山 Django快速体验

开门见山

Django 是 Python 世界目前最火爆的 web 框架。它提倡将 project 分解成可重有的 app。 并且 Django 社区有很好的编写可重用 app 的传统，存在大量开源的 app 可以直接拿来用， 帮助你以迅雷不及掩耳之势搭建功能强大的 web 应用。

下载安装

从官方网站(http://www.djangoproject.com/download/) 下载最新版本，解压，执行执行命令 python setup.py install 进行安装。然后旅程开始。

快速起步

安装完django后，就该创建项目了。打开一个命令行窗口，找个目录，然后跟我输命令吧。 

  创建项目：
  >django-admin.py startproject simple_wiki
  进入项目的目录：
  >cd simple_wiki
  启动测试服务器：
  simple_wiki>manage.py runserver
  Validating models...
  0 errors found
  ...

这样就启动了 Django 自带的开发服务器，现在打开个浏览器访问 http://localhost:8000/ ， 就可以看到一个欢迎页面了：

<截图>

我们暂且把这个命令行窗口留着别关，不用管它，后面我们的Python代码修改后， 此服务器会自动重启以执行最新的代码，可以提高大家的开发效率。

下面我们得配置下数据库先，图方便，我们就直接使用python2.5自带的数据库引擎 sqlite 吧。编辑 settings.py ，设置以下两项： 

   1   DATABASE_ENGINE = 'sqlite3'
   2   DATABASE_NAME = 'data.db'

如果你恰好和我一样，在中国大陆并且母语汉语，那就顺便再设置这样两项： 

   1   TIME_ZONE = 'Asia/Shanghai'
   2   LANGUAGE_CODE = 'zh-CN'

再把自带的 admin app 启用了，找到 INSTALLED_APPS ，在里面加一行如下： 

   1   INSTALLED_APPS = (
   2       ...
   3       'django.contrib.admin',
   4   )

我们再给自动的 admin 后台管理界面设置一个访问的入口，也就是 url。编辑 urls.py 文件，去掉第三、四行和倒数第二行的注释即可： 

   1   ...
   2   from django.contrib import admin
   3   admin.autodiscover()
   4   ...
   5       (r'^admin/(.*)', admin.site.root),
   6   )

然后，创建下数据库。打开一个新的命令行窗口并切换到 simple_wiki 目录，执行命令： 

  simple_wiki>manage.py syncdb
  Creating table auth_permission
  ...

注意：中间需要你输入一个超级用户名、EMail和密码，请记住用户名和密码，等下登陆管理后台有用的。如果忘了可以 data.db 删掉，重新生成下数据库。

现在打开浏览器，访问 http://localhost:8000/admin/ ，就可以欣赏 django 自带的 admin 后台管理模块了，后面你会看到，你还可以很轻松地往里面添加你自己 app 的后台管理。

建立Model

配置完成后，我们就写个超级简单的 wiki 试试吧。由于对于 django 来说，一个 project 就是一堆 app 的组合，在我们编写功能前，需要先建一个 app ： 

  simple_wiki>manage.py startapp wiki

然后我们在配置里面启用这个 app ，修改 settings.py 在 INSTALLED_APPS 里面增加一行： 

   1       'simple_wiki.wiki',

然后修改 wiki/models.py ，填充如下代码： 

   1   # coding: utf-8
   2   from django.db import models
   3 
   4   # 代表 wiki 页面的 Model
   5   class WikiPage(models.Model):
   6       title = models.CharField(u'页面标题', max_length=255)
   7       email = models.EmailField(u'创建者Email', max_length=255)
   8       content = models.TextField(u'页面内容')
   9       class Meta:
  10           # 显示在管理后台中名字
  11           verbose_name = verbose_name_plural = u'Wiki页面'
  12 
  13   # 定义 WikiPage 的后台管理界面
  14   class WikiPageAdmin(admin.ModelAdmin):
  15       # 定义列表页显示的字段
  16       list_display = ('title', 'email')
  17       # 显示搜索框，并定义搜索的字段
  18       search_fields = ['title', 'email', 'content']
  19       # 设置每页显示数量
  20       list_per_page = 50
  21 
  22   from django.contrib import admin
  23   # 注册到管理后台
  24   admin.site.register(WikiPage, WikiPageAdmin)

记得要保存成 utf-8 编码的文件，本教程中所有文件一律保存成 utf-8 编码的。 (Model定义的详细内容见： http://docs.djangoproject.com/en/dev/topics/db/models/ )

然后创建相应的数据表。执行命令： 

   1   simple_wiki>manage.py syncdb
   2   Creating table wiki_wikipage

现在再去看下 http://localhost:8000/admin/ ，是不是发现里面有了Wiki页面的管理后台了？哈哈，爽吧。 (关于定制admin的详细内容：http://docs.djangoproject.com/en/dev/ref/contrib/admin/#ref-contrib-admin )

现在不妨利用这个管理后台在里面添加一个标题为 FrontPage 的页面。

《截图》

展示页面

现在我们再写点代码把数据库里的 wiki 页面展示出来。修改 wiki/views.py ，填充以下内容 ： 

   1   # coding: utf-8
   2   from django.shortcuts import render_to_response, get_object_or_404
   3   from simple_wiki.wiki.models import WikiPage
   4 
   5   def view_page(request, title='FrontPage'):
   6       # 根据 title 查询页面数据，如果不存在自动显示 404 错误页面。
   7       page = get_object_or_404(WikiPage, title=title)
   8       # 渲染模板。
   9       return render_to_response('page_view.html', {'page':page})

现在，MTV 的 M（Model）和V（View）都有了，下面我们再来增加个 T（Template），在 wiki 目录下面创建目录 templates ，在里面创建模板文件 page_view.html ，内容如下： 

  <html>
    <head>
      <title>{{ page.title }}</title>
    </head>
    <body>
      {{ page.content }}
    </body>
  </html>

模板文件中使用 表示把中间的对象的值填充在相应的位置。模板中还有许多其他的语法，比如分支、循环、继承等。(关于django模板语法的详细内容见 http://docs.djangoproject.com/en/dev/topics/templates/#topics-templates )

最后我们再给页面展示设置一个 url，修改 urls.py ，增加一条 url 映射规则如下： 

   1   urlpatterns = patterns('',
   2       ...
   3       (r'^simple_wiki/(\w+?)/?$', 'simple_wiki.wiki.views.view_page'),
   4       ...

然后访问 http://localhost:8000/simple_wiki/FrontPage ，就可以看到刚才在后台里面添加的那个页面了。

处理表单

现在如果我们访问一个不存在的 wiki 页面，比如 http://localhost:8000/simple_wiki/Python ，会得到一个 404 页面。这显然还不够好，应该提示用户去创建相应的页面。修改 wiki/views.py 页面如下： 

   1   # coding: utf-8
   2   from django.shortcuts import render_to_response, get_object_or_404
   3   from django import forms
   4   from simple_wiki.wiki.models import WikiPage
   5 
   6   # 让 django 从 WikiPage 这个 model 自动产生的 form，同时覆盖 title 字段的 widget，把它改成隐藏表单。
   7   class WikiPageForm(forms.ModelForm):
   8       title = forms.CharField(widget=forms.HiddenInput())
   9       class Meta:
  10           model = WikiPage
  11 
  12   def view_page(request, title='FrontPage'):
  13       try:
  14           page = WikiPage.objects.get(title=title) # 查询一个页面对象
  15       except WikiPage.DoesNotExist:
  16           # 如果数据不存在，显示内容提示用户创建相应页面
  17           return render_to_response('page_empty.html', {title:title})
  18       else:
  19           # 页面存在，则显示这个页面。
  20           return render_to_response('page_view.html', {'page':page})

在 wiki/templates 目录下再添加一个模板 page_empty.html，内容如下： 

  <html>
    <head>
      <title>页面{{ title }}不存在</title>
    </head>
    <body>
      <h1>页面{{ title }}不存在，<a href="{{ title }}/edit">创建该页面</a></h1>
    </body>
  </html>

然后访问 http://localhost:8000/simple_wiki/Python ，是不是发现有了一个提醒用户创建页面的链接。

不过现在链接后面还没有真正创建页面的功能。下面我们继续编写代码，由于创建页面和编辑页面之间很相似，两个功能可以一起完成。在 wiki/views.py 文件顶部增加一行导入： 

   1   # HttpResponseRedirect 继承自 HttpResponse，代表页面跳转的 response
   2   from django.http import HttpResponseRedirect

再添加一个 view 函数 edit_page 如下： 

   1   def edit_page(request, title):
   2       if request.method == 'GET':
   3           # 如果是 GET 请求，则显示表单
   4           try:
   5               # 根据 tite 查询 wiki页面
   6               page = WikiPage.get(title=title)
   7           except WikiPage.DoesNotExists:
   8               # 如果不存在该页面，则显示一个创建表单
   9               form = WikiPageForm()
  10           else:
  11               # 否则，显示一个编辑表单
  12               form = WikiPageForm(instance=page)
  13           return render_to_response('page_edit.html', {'form':form})
  14       else:
  15           # 如果是POST请求，则提交表单，并保存用户输入的wiki页面数据
  16           form = WikiPageForm(request.POST)
  17           if form.errors:
  18               # 表单验证失败，需要提示用户错误信息，并让用户重新输入内容
  19               return render_to_response('page_edit.html', {'form':form})
  20           page = form.save()
  21           # 数据保存成功，跳转到展示页面的地址
  22           return HttpResponseRedirect('/simple_wiki/'+page.title)

在 wiki/templates 目录下增加显示页面编辑表单的模板 page_edit.html ，内容如下： 

  <html>
    <head>
      <title>创建页面{{ title }}</title>
    </head>
    <body>
      <form method="post" action="">
        {{ form }}
        <br/>
        <input type="submit" value="提交"/>
      </form>
    </body>
  </html>

最后在 urls.py 中配置页面编辑的 url： 

   1   (r'^simple_wiki/(\w+?)/edit/?$', 'simple_wiki.wiki.views.edit_page'),

现在访问一个不存在 wiki 页面，比如： http://localhost:8000/simple_wiki/Python ，点击创建页面链接，填写表单，点击提交，然后跳转到展示的页面。(更多表单处理的介绍：http://docs.djangoproject.com/en/dev/topics/forms/#topics-forms-index )

到这里，这个 wiki 就算是顺利完工了！相信大家对使用 django 进行web开发也有了基本的认识了吧。

ObpLovelyPython/AbtDjango (last edited 2009-12-25 07:16:30 by localhost)