Django 快速实战入门(八):部署 Django

本节中,我们要彻底脱离测试服务器,以 gentoo+nginx+flup 为例,把我们的留言板部署到正式的服务器中。

在我们的 Web 服务器架构中,nginx 作为前端的 HTTP 服务器,而 flup 在后端以 fastcgi 的方式运行。在 nginx 中设置所有对动态内容的请求都交由后端的 flup 来处理。

安装配置 nginx

如果使用 gentoo 的 emerge 安装,则直接执行以下命令即可安装 nginx:

USE=fastcgi emerge nginx

如果要进行编译方式安装,在运行 ./configure 时请启动 fastcgi,可以参考以下选项:

gentoo ~ # /usr/sbin/nginx -V
nginx version: nginx/0.7.19
configure arguments: –prefix=/usr –conf-path=/etc/nginx/nginx.conf –http-log-path=/var/log/nginx/access_log –error-log-path=/var/log/nginx/error_log –pid-path=/var/run/nginx.pid –http-client-body-temp-path=/var/tmp/nginx/client –http-proxy-temp-path=/var/tmp/nginx/proxy –http-fastcgi-temp-path=/var/tmp/nginx/fastcgi –with-md5-asm –with-md5=/usr/include –with-sha1-asm –with-sha1=/usr/include –with-http_realip_module –with-http_ssl_module –with-http_perl_module

配置 /etc/nginx/nginx.conf:

user nginx nginx;
worker_processes 1;

error_log /var/log/nginx/error_log info;

events {
        worker_connections  8192;
        use epoll;
}

http {
        include         /etc/nginx/mime.types;
        default_type    application/octet-stream;
        charset         utf-8;

        log_format main
                ‘$remote_addr – $remote_user [$time_local] ‘
                ‘”$request” $status $bytes_sent ‘
                ‘”$http_referer” “$http_user_agent” ‘
                ‘”$http_x_forwarded_for” “$gzip_ratio”‘;

        client_header_timeout   10m;
        client_body_timeout     10m;
        send_timeout            10m;

        connection_pool_size            256;
        client_header_buffer_size       1k;
        large_client_header_buffers     4 2k;
        request_pool_size               4k;

        gzip on;
        gzip_min_length 1100;
        gzip_buffers    4 8k;
        gzip_types      text/plain;

        output_buffers  1 32k;
        postpone_output 1460;

        sendfile        on;
        tcp_nopush      on;
        tcp_nodelay     on;

        keepalive_timeout       75 20;

        ignore_invalid_headers  on;

        index index.html;

        include sites/*.enable;
}

新建 /etc/nginx/sites/myblog.enable:

server {
        listen          80;
        server_name     192.168.1.6;
        charset         utf-8;

        access_log      /var/log/nginx/myblog.access.log main;
        error_log       /var/log/nginx/myblog.error.log info;

        location /media {
                root    /home/www/myblog/media;
        }

        location / {
                include flup_params;
        }
}

管理后台中有部分静态资源,将它们复制到 /home/www/myblog/media 目录下:

cp -r /usr/lib/python2.4/site-packages/django/contrib/admin/media /home/www/myblog/media

/etc/nginx/flup_params 内容为:

fastcgi_param  QUERY_STRING       $query_string;
fastcgi_param  REQUEST_METHOD     $request_method;
fastcgi_param  CONTENT_TYPE       $content_type;
fastcgi_param  CONTENT_LENGTH     $content_length;
fastcgi_param  PATH_INFO          $fastcgi_script_name;

fastcgi_param  GATEWAY_INTERFACE  CGI/1.1;
fastcgi_param  SERVER_SOFTWARE    nginx/$nginx_version;

fastcgi_param  REMOTE_ADDR        $remote_addr;
fastcgi_param  REMOTE_PORT        $remote_port;
fastcgi_param  SERVER_ADDR        $server_addr;
fastcgi_param  SERVER_PORT        $server_port;
fastcgi_param  SERVER_NAME        $server_name;

# PHP only, required if PHP was built with –enable-force-cgi-redirect
fastcgi_param  REDIRECT_STATUS    200;

fastcgi_pass   127.0.0.1:2380;

这里设置 fastcgi 的 ip:port 为 127.0.0.1:2380。

配置完毕后重新启动 nginx:

/etc/init.d/nginx restart

安装 flup 并启动 fastcgi

如果使用 gentoo 的 emerge 方式安装,输入以下命令即可:

emerge -pv flup

如果使用 Python eggs 方式安装,则需要到 flup 官网 http://trac.saddi.com/flup 上下载压缩包,再进行安装:

gentoo ~ # wget http://www.saddi.com/software/flup/dist/flup-1.0.1.tar.gz
gentoo ~ # tar zxf flup-1.0.1.tar.gz
gentoo ~ # cd flup-1.0.1
gentoo flup-1.0.1 # python setup.py install

启动 fastcgi:

python manage.py runfcgi host=127.0.0.1 port=2380

打开 http://192.168.1.6/message/http://192.168.1.6/admin/, 看看是否与测试服务器时一致呢?

结束

本文到此已结束,希望通过本文你已经大致了解 Django 的 MVT 架构,并能利用 Django 进行应用开发。

最后附上文中代码的压缩包:myblog.zip

— EOF —

Django 快速实战入门(七):admin 应用

管理后台对于每个网站来说都是必须,在管理后台中,我们可以添加、编辑和删除网站内容。

Django 中引入了 admin 应用,可以帮助我们快速地建立管理后台。

下面,我们就要利用 Django 附带的 admin 应用来为我们的留言板创建一个管理后台。

激活 admin 应用

修改 settings.py,在 INSTALLED_APPS 列表中加入 ‘django.contrib.admin’:

INSTALLED_APPS = (
    ‘django.contrib.auth’,
    ‘django.contrib.contenttypes’,
    ‘django.contrib.sessions’,
    ‘django.contrib.sites’,
    ‘django.contrib.admin’,
    ‘myblog.messages’,
)

在第五节创建留言板的数据模型过程中,为了在安装模型过程中不至于产生许多不需要的表,我们在 settings.py 中禁用了许多应用。在这里,因为 admin 应用依赖于 ‘django.contrib.auth’、’django.contrib.contenttypes’ 和 ‘django.contrib.sessions’,因此我们需要同时重新激活它们。另外,如果需要对多个站点进行管理,还需要激活 ‘django.contrib.sites’。

激活后,我们需要再执行一次同步数据库的操作,来将这些应用中需要用到的表安装到 MySQL:

gentoo myblog # python manage.py syncdb
Creating table auth_permission
Creating table auth_group
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table django_admin_log

You just installed Django’s auth system, which means you don’t have any superusers defined.
Would you like to create one now? (yes/no): yes
Username (Leave blank to use ‘root’):
E-mail address: hily@test.com
Password:
Password (again):
Superuser created successfully.
Installing index for auth.Permission model
Installing index for auth.Message model
Installing index for admin.LogEntry model

如上所示,安装过程中会提示您创建用于管理后台的超级管理员的用户名和密码,按照提示输入即可。

安装完成后,MySQL 中的数据表如下:

mysql> show tables;
+—————————-+
| Tables_in_mydb             |
+—————————-+
| auth_group                 |
| auth_group_permissions     |
| auth_message               |
| auth_permission            |
| auth_user                  |
| auth_user_groups           |
| auth_user_user_permissions |
| django_admin_log           |
| django_content_type        |
| django_session             |
| django_site                |
| messages_message           |
+—————————-+
12 rows in set (0.01 sec)

配置管理后台入口

修改项目目录下的 urls.py,将以下行前面的注释去掉即可:

from django.contrib import admin
admin.autodiscover()

(r’^admin/(.*)’, admin.site.root),

访问 http://192.168.1.6:8080/admin/,就可以看到后台管理的登录界面了:

使用刚刚设置的超级管理员用户名和密码就可以登录到管理后台了:

将留言板加入后台管理

到此为止,我们还看不到留言板的管理界面,在这一步我们来实现把留言板加入到管理界面中。

Django 提供了一种简易的方法来将需要进行管理的数据模型添加到管理列表中:

admin.site.register(ModelName)

ModelName 就是需要添加到后台管理菜单中的数据模型类名。

在留言板应用目录 messages/ 下新建一个 admin.py(也可以用其它名称),存储后台的管理菜单配置信息:

from django.contrib import admin
from myblog.messages.models import Message

admin.site.register(Message)

重新启动测试服务器,进入后台,这时候在菜单列表中就出现了 Messages:

点击 Messages 后就可以看到留言的列表了。在这里我们重新修改一下 models.py 中 Message 的 __str__,以便留言列表看起来更简洁:

from django.db import models

class Message(models.Model):
    name = models.CharField(max_length=30)
    email = models.EmailField()
    homepage = models.URLField()
    title = models.CharField(max_length=200)
    content = models.CharField(max_length=500)
    time = models.DateTimeField(auto_now_add=True)
    ip = models.CharField(max_length=20)

def __str__(self):
        return ‘%s: %s’ % (self.name, self.title)

留言列表效果截图:

编码问题

在点击第一条记录“江:留言测试”时,Django 返回错误提示,类似如下:

TemplateSyntaxError at /admin/messages/message/5/

Caught an exception while rendering: 'ascii' codec can't encode character u'\u6c5f' in position 0: ordinal not in range(128)

Original Traceback (most recent call last):
  File "/usr/lib/python2.4/site-packages/django/template/debug.py", line 71, in render_node
    result = node.render(context)
  File "/usr/lib/python2.4/site-packages/django/template/debug.py", line 87, in render
    output = force_unicode(self.filter_expression.resolve(context))
  File "/usr/lib/python2.4/site-packages/django/template/__init__.py", line 559, in resolve
    new_obj = func(obj, *arg_vals)
  File "/usr/lib/python2.4/site-packages/django/template/defaultfilters.py", line 37, in _dec
    args[0] = force_unicode(args[0])
  File "/usr/lib/python2.4/site-packages/django/utils/encoding.py", line 52, in force_unicode
    s = unicode(str(s), encoding, errors)
UnicodeEncodeError: 'ascii' codec can't encode character u'\u6c5f' in position 0: ordinal not in range(128)

这是编码类型有问题造成的,在多语言编码环境中,__str__ 经常会发生问题,因为它只支持 ascii 编码。所以我们修改 messages/models.py 中 Message 的 __str__,将其改为 __unicode__,问题就可以解决了:

from django.db import models

class Message(models.Model):
    name = models.CharField(max_length=30)
    email = models.EmailField()
    homepage = models.URLField()
    title = models.CharField(max_length=200)
    content = models.CharField(max_length=500)
    time = models.DateTimeField(auto_now_add=True)
    ip = models.CharField(max_length=20)

def __unicode__(self):
        return ‘%s: %s’ % (self.name, self.title)

编辑留言页面截图:

定制管理界面

也许你对现在看到的管理界面还不满意,那么你可以通过模板继承的方式从默认模板中继承,并对相应部分进行修改。

Django 管理界面的默认模板位于类似以下路径中,每个管理界面都有一个模板与它相对应:

gentoo myblog # ls -F /usr/lib/python2.4/site-packages/django/contrib/admin/templates/admin/
404.html          change_list_results.html  login.html
500.html          date_hierarchy.html       object_history.html
app_index.html    delete_confirmation.html  pagination.html
auth/             edit_inline/              prepopulated_fields_js.html
base.html         filter.html               search_form.html
base_site.html    includes/                 submit_line.html
change_form.html  index.html                template_validator.html
change_list.html  invalid_setup.html

作为示例,我们接下来就来修改一下留言列表顶部的“Django 管理”,将它替换为“留言管理”。

Django 的 admin 应用查找模板的顺序如下:

  • admin/<应用名称>/<对象名称>/<模板名称>.html
  • admin/<应用名称>/<模板名称>.html
  • admin/<模板名称>.html

留言列表的默认模板为 change_list.html,我们实现一个新的模板来继承并覆盖它。创建 messages/templates/admin/messages/message/change_list.html,内容如下(注意文件编码一定要保存为 UTF8):

{% extends “admin/change_list.html” %}

{% block branding %}
<h1 id=”site-name”>留言管理</h1>
{% endblock %}

这样就修改成功了,看看效果:

下一节 >>>

Django 快速实战入门(八):部署 Django

以 gentoo+nginx+flup 为例,部署我们的留言板到生产服务器中。

— EOF —

Django 快速实战入门(六):表单模型

在与用户的交互过程中,表单发挥了十分重要的作用,多数 Web 应用都带有许多的表单处理。与数据模型类似,如果使用传统的开发方法,那么表单页面的编写和提交结果的验证和处理将成为开发者一大头疼事。

因此,Django 中将表单抽象为模型,集表单生成、内容验证为一体。通过视图控制将表单模型、数据模型结合在一起,就可以很容易地实现表单结构的设计、对用户提交数据的验证和数据的保存入库等操作。

下面我们继续上一节中的示例,为留言板创建一个表单页面。

创建表单模型

要利用 Django 的表单模型来创建一个表单页面,就需要先建立一个表单模型。我们在应用目录 messages/ 目录下新建一个表单模型文件 forms.py,专门用于存放各种表单模型:

from django import forms

class MessageForm(forms.Form):
    name = forms.CharField(required=True)
    email = forms.EmailField(required=True)
    homepage = forms.URLField(required=False)
    title = forms.CharField(required=True)
    content = forms.CharField(required=True)

forms.CharField、forms.EmailField 同上一节我们使用的字段类型一样,是 Django 内置的表单类型,更多的类型和参数说明请参考官方手册

required=True 表示这个字段是必须填写的,否则表单验证时将会提示错误。

创建留言页的视图控制

在视图控制函数中生成一个表单对象,最后交由模板系统格式化显示,同时显示留言记录。

修改后的 messages/views.py 内容如下:

from django.http import HttpResponseRedirect
from django.shortcuts import render_to_response·
from forms import MessageForm
from models import Message

def message(request):
    if request.method == ‘POST’:
        form = MessageForm(request.POST)
        if form.is_valid():
            name = form.cleaned_data[‘name’]
            email = form.cleaned_data[’email’]
            homepage = form.cleaned_data[‘homepage’]
            title = form.cleaned_data[‘title’]
            content = form.cleaned_data[‘content’]
            ip = request.META[‘REMOTE_ADDR’]
            m = Message(name=name,
                        email=email,
                        homepage=homepage,
                        title=title,
                        content=content,
                        ip=ip)
            m.save()
            return HttpResponseRedirect(‘/message/’)
    else:
        form = MessageForm()
    messages = Message.objects.all().order_by(‘-time’)
    return render_to_response(‘message.html’,
                {‘form’: form, ‘messages’: messages})

当用户提交留言后,request.method 值为 POST,这时候我们使用 MessageForm(request.POST) 来处理表单内容。

如果验证通过,则 form.is_valid() 为 True,这时我们就把提交的内容添加到数据库中,这些提交的内容经过验证后都保存在 form.cleaned_data 字典中。

最后返回一个 HttpResponseRedirect 对象,作用是重定向到 /message/ 页,防止用户刷新导致重复提交数据。

实现页面模板

模板 templates/message.html:

<html>
<head>
<title> Leave your message here </title>
</head>

<body>
<h1>Messages</h1>

<table>
  {% for message in messages %}
  <tr>
    <td>
    {% if message.homepage %}
      <a href="{{ message.homepage }}">{{ message.name }}</a>
    {% else %}
      {{ message.name }}
    {% endif %}
    ({{ message.email }})
    leave a message at {{ message.time }}
    from {{ message.ip }}:
    </td>
  </tr>
  <tr>
    <td>{{ message.content }}</td>
  </tr>
{% endfor %}
</table>

<h2>Leave your message</h2>
<form action="." method="POST">
  <table>
    {{ form.as_table }}
  </table>
  <p><input type="submit" value="Submit"></p>
</form>

</body>
</html>

其中 as_table 是 form 的一个属性,form.as_table 表示使用表格形式输出时要输出的 HTML 代码。

为保持应用的封装,我们可以在每个应用目录下创建一个模板目录 templates,然后把这个目录添加到项目配置文件 settings.py 中的模板搜索路径中:

TEMPLATE_DIRS = (
    os.path.join(os.path.dirname(__file__), ‘templates’).replace(‘\\’, ‘/’),
    os.path.join(os.path.dirname(__file__), ‘messages/templates’).replace(‘\\’,
‘/’),
)

配置访问接口

实现好视图控制后,我们需要修改 urls.py 配置留言板访问接口,可以简单地在 patterns.py 中增加一行:

(r’^message/$’, ‘myblog.messages.views.message’),

如果希望应用的可移植性更好一些,我们可以为每个应用单独维护一个 urls.py,然后在项目的 urls.py 中引入。

新建 messages/urls.py,内容如下:

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

urlpatterns = patterns(”,
    (r’^$’, message),
)

然后在项目的 urls.py 中包含它:

urlpatterns = patterns(”,
    (r’^$’, index),
    (r’^message/’, include(‘myblog.messages.urls’)),
)

这样,在访问 http://192.168.1.6:8080/message/ 时,项目中的 urls.py 会匹配 message/,并把匹配完的剩余部分传递给应用中的 urls.py,这里的剩余部分就是空字符串,因此在 messages/urls.py 中的 r’^$’ 将会匹配它。

最终效果

访问 http://192.168.1.6:8080/message/,增加几笔留言,你可能会发现时间与当前时间不匹配。这时你需要根据你所在的时区修改一下 settings.py 中的时区:

TIME_ZONE = ‘Asia/Shanghai’

如果输入有误,则会在输入错误的表单域上方显示错误提示,如:

如果你希望按你的语言来显示提示信息,则修改 settings.py 中的相应设置,如:

LANGUAGE_CODE = ‘zh-CN’

则以上的“This field is required”会变为“这个字段是必填项”。

最终效果如下:

下一节 >>>

Django 快速实战入门(七):admin 应用

Django 自带了不少实用的应用,下一节中我们将介绍如果使用 admin 应用实现留言板的后台管理。

— EOF —

Django 快速实战入门(五):数据模型

ORM 与 CRUD

在当今绝大多数的 Web 应用中,数据库已经成为不可或缺的一个重要组成部分。对于许多应用来说,使用传统的开发方法,仍然要编写不少 SQL 语句,让许多开发者感到枯燥乏味。

由此,在许多面向对象的开发模型中,引入了对象关系映射(ORM )机制,对关系数据库进行抽象与建模。引入了 ORM 之后,对数据库的操作不再是直接通过 SQL 语句,而是直接操作于数据对象。

Django 作为一个优秀的 Web 开发框架,它也实现了 ORM,支持 CRUD。在许多应用中,SQL 语句大多数都是比较简单的,因此 CRUD 基本上能满足大多数场合的应用,大大提升了开发效率。

下面我们就要使用 Django 的 ORM 机制,建立一个简单的留言板,来领略一下无 SQL 的应用开发。

配置数据库

在这部分,我们将使用 MySQL 作为留言数据的存储引擎,如果你还没安装 MySQL 和 MySQLdb,请回到第二节进行安装。

要在 Django 项目中使用数据库,我们需要修改一下项目目录下的 settings.py,这里以 MySQL 为例,修改以下数据库相关的选项:

DATABASE_ENGINE = ‘mysql’           # ‘postgresql_psycopg2’, ‘postgresql’, ‘mysql’, ‘sqlite3’ or ‘oracle’.
DATABASE_NAME = ‘mydb’             # Or path to database file if using sqlite3.
DATABASE_USER = ‘root’             # Not used with sqlite3.
DATABASE_PASSWORD = ‘hily’         # Not used with sqlite3.
DATABASE_HOST = ”             # Set to empty string for localhost. Not used with sqlite3.
DATABASE_PORT = ”             # Set to empty string for default. Not used with sqlite3.

(注意,在大多数情况下,直接把 root 作为 Web 应用的数据库用户是不安全的,这里是为了简便才这样做的。)

新建 Django 应用

在 Django 中,项目为应用提供了运行环境,一个项目中可以包含多个应用,同一个项目下的应用共享着项目的配置信息,如数据库配置、模板路径、时区等信息。一个应用以一个包的形式存在,便于重用和移植。

第一节的 Django 架构图中我们可以看到,数据模型(Model)是存在于应用(Application)之中的,因此要使用数据模型,需要首先建立一个 Django 应用。使用以下命令:

python manage.py startapp messages

执行成功后,会在项目目录下新建一个名为 comments 的目录,这就是 comments 应用包的路径,startapp 会对它进行初始化。初始化后包含三个文件:

gentoo myblog # ls messages/
__init__.py  models.py  views.py

对这三个文件作一下简要说明:

  • __init__.py:同项目目录下的 __init__.py,表示这是一个包。
  • models.py:模型定义。一会儿我们就需要在这里面定义数据模型。
  • views.py:该应用的视图控制实现代码。

新建的应用在 Django 项目中默认是不启用的,因此我们需要修改 settings.py 来启用我们的留言板应用,同时先禁用其它暂时不用的应用:

INSTALLED_APPS = (
#    ‘django.contrib.auth’,
#    ‘django.contrib.contenttypes’,
#    ‘django.contrib.sessions’,
#    ‘django.contrib.sites’,
    ‘myblog.messages’,
)

在 INSTALLED_APPS 尾部加上 ‘myblog.messages’ 即可。

新建应用后,models.py 和 views.py 都是空的,下一步我们就要对它们进行填充实现。

建立留言板模型

我们要实现的留言板由以下部分组成:

  • 留言者
  • 邮箱
  • 主页
  • 留言标题
  • 留言内容
  • 留言时间
  • 留言者 IP

根据以上描述,在 models.py 中定义它:

from django.db import models

class Message(models.Model):
    name = models.CharField(max_length=30)
    email = models.EmailField()
    homepage = models.URLField()
    title = models.CharField(max_length=200)
    content = models.CharField(max_length=500)
    time = models.DateTimeField(auto_now_add=True)
    ip = models.CharField(max_length=20)

Comment 类继承自 Django 的 models.Model 类,models.CharField、models.DateTimeField 等都是 Django 数据模型中支持的类型,更多可用类型请参考官方手册

安装模型

到这里为止,我们还没有对数据库做任何结构定义操作,在开发应用时习惯先建立数据库和表结构的朋友可能会有点儿迷惑,这些数据表什么时候会被创建?在这一步里,我们就要做这个事情,通过安装模型把模型定义同步到数据库。

首先使用以下命令验证一下模型的有效性:

python manage.py validate

如果提示“0 errors found”,则表示模型被正确定义,否则请返回修改。

在开始安装模型前,你可能需要查看一个安装模型时执行的 SQL 语句,你可以使用以下命令查看:

python manage.py sqlall messages

执行后结果类似:

gentoo myblog # python manage.py sqlall messages
BEGIN;
CREATE TABLE `messages_message` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `name` varchar(30) NOT NULL,
    `email` varchar(75) NOT NULL,
    `homepage` varchar(200) NOT NULL,
    `title` varchar(200) NOT NULL,
    `content` varchar(500) NOT NULL,
    `time` datetime NOT NULL,
    `ip` varchar(20) NOT NULL
)
;
COMMIT;

确认无误后使用以下命令将模型同步到数据库:

python manage.py syncdb

这将会在数据库中建立一个 messages_message 表。

使用数据模型

这一节中,我们暂不打算为留言板创建视图控制,这部分我们将在下一节中实现。但是我们希望先通过一些简单的方法来快速测试一下这个数据模型。

下面我们就通过使用 Python 命令行来测试这个数据模型,如果直接通过输入 python 来启动 shell,那么在导入一些 Django 相关的库时会发生错误,因为缺少相关环境变量的设置。

所以,我们需要使用以下命令启动 Python 命令行:

python manage.py shell

导入数据模型并显示所有留言:

>>> from messages.models import Message
>>> Message.objects.all()
[]

因为当前数据表中并没有存在任何留言记录,所以 Message.objects.all() 显示为空。

新增留言:

>>> m = Message(name=’Hily’,
…        email=’hily@test.com’,
…        homepage=’http://hily.me/’,
…        title=’My first message’,
…        content=’This is my first message.’,
…        ip=’192.168.1.5′)
>>> m.save()
>>> Message.objects.all()                       
[<Message: Message object>]

要使 Message.objects.all() 输出可阅读的信息,我们需要修改 Message 类,增加 __str__ 方法:

from django.db import models

class Message(models.Model):
    name = models.CharField(max_length=30)
    email = models.EmailField()
    homepage = models.URLField()
    title = models.CharField(max_length=200)
    content = models.CharField(max_length=500)
    time = models.DateTimeField(auto_now_add=True)
    ip = models.CharField(max_length=20)

    def __str__(self):
        return ‘Name: %s Email: %s Homepage: %s\n’ \
               ‘Time: %s IP: %s\n’ \
               ‘Title: %s\nContent: %s\n’ \
               % (self.name, self.email, self.homepage,
                  self.time, self.ip,
                  self.title, self.content);

重新启动 shell,查看所有留言记录:

>>> from messages.models import Message
>>> Message.objects.all()
[<Message: Name: Hily Email: hily@test.com Homepage: http://hily.me/
Time: 2008-11-21 09:00:17 IP: 192.168.1.5
Title: My first message
Content: This is my first message.
>]

更新记录:

>>> m = Message.objects.get(name=’Hily’)
>>> m.content = ‘Is this my first message?’
>>> m.save()
>>> Message.objects.all()                 
[<Message: Name: Hily Email: hily@test.com Homepage: http://hily.me/
Time: 2008-11-21 09:00:17 IP: 192.168.1.5
Title: My first message
Content: Is this my first message?
>]

删除记录:

>>> m = Message.objects.get(name=’Hily’)
>>> m.delete()
>>> Message.objects.all()              
[]

Django 的 CRUD 为大家演示到此,更多更丰富的模型操作语句,请参考官方手册

下一节 >>>

Django 快速实战入门(六):表单模型

本节中只是建立了一个留言板模型,还没有给它添加视图控制。在下一节,我们将介绍如何使用 Django 的表单模型来快速制作一个留言页面。

— EOF —