Django Models学习笔记-模型

原文发表于:2010年1月13日

1. 模型

模型是对数据的描述,包括数据的基本字段和行为。一般一个模型对应一个数据表。

模型是Python类,是django.models.Model的子类。

一个模型的属性描述一个数据表的字段。

Django提供自动生成的数据库访问API(参考“进行查询(URL)”)。

参考阅读:模型例子的官方软件源(URL)(这些例子位于Django源代码发行版的test/modeltests目录)

(笔记:好的例子和恰当的解释是最好的学习材料)

Django Models学习笔记-目录

原文发表于:2010年1月13日

目录

1. 模型
1.1. 快速例子
1.2. 使用模型
1.3. 字段
1.3.1. 字段类型
1.3.2. 字段选项
1.3.3. 自动主键字段
1.3.4. 冗长字段名
1.3.5. 关系
1.3.5.1. 多对一关系
1.3.5.2. 多对多关系
1.3.5.3. 多对多关系的额外字段(Django 1.0新增)
1.3.5.4. 一对一关系
1.3.6. 跨文件模型
1.3.7. 字段名限制
1.3.8. 定制字段类型(Django 1.0引入)
1.4. 元选项
1.5. 模型方法
1.5.1. 重载预定义的模型方法
1.5.2. 执行定制的SQL
1.6. 模型继承(Django 1.0引入)
1.6.1. 抽象基类
1.6.1.1. 元继承
1.6.1.2. 小心使用related_name
1.6.2. 多表继承
1.6.2.1. 元和多表继承
1.6.2.2. 继承和保留关系
1.6.2.3. 指定父链接字段
1.6.3. 代理模型
1.6.3.1. 查询集仍然返回需要的模型
1.6.3.2. 基类限制
1.6.3.3. 代理模型管理器
1.6.3.4. 代理继承和未管理模型的差别
1.6.4. 多重继承
1.6.5. 字段名hiding是不允许的
1.7. 常用术语中英文对照

Django Step by Step 2010版(基于Django 1.1.1) 第六讲

原文发表于:2010年1月9日

1. 引言

这一讲我们要实现一个简单的Wiki,包括如下功能:

1) 可以修改当前页面。在页面下方提供一个编辑按钮,单击它可以编辑当前页面。

2) 识别页面切换点,页面切换点是两个首字母大写的单词连在一起,点击它们将进入已有的页面或者创建新页面。

我们要创建一个Django的app来实现这个Wiki。app是一个完整的功能集合,它拥有自己的模型(Model)、View和模板 (Template),还可以拥有自己的urls.py(URL映射)。app是一个独立的目录,它可以独立安装,也就是说你可以把它安装到其它 Django服务器中去。app结构是Django的核心特性之一,Django提供了很多针对app结构的自动功能。

2. 创建wiki app

在newtest目录下执行下列命令:

$ ./manage.py startapp wiki

这个命令会在newtest目录下创建wiki目录,并在wiki目录下创建4个文件:

__init__.py
表示wiki目录是一个包。

models.py
用来存放模型(Model)代码(描述数据库结构和数据接口)。

views.py
用来存放View代码(处理URL请求的View方法)。

tests.py
演示两种风格的测试代码,用于Django app的调试。

3. 修改wiki/models.py

Django中的模型(Model)实际是通过ORM(Object Relation Mapping,对象关系映射)来屏蔽数据库的底层细节,以对象的形式来处理数据。模型中的每个model都对应数据库中的一张表,model的每个属性 对应表中的一个字段。这样不但数据的访问非常方便,而且当你需要使用不同的数据库时也不必修改这些代码(例如从sqlite3迁移到 PostgreSQL)。

修改后的wiki/models.py内容如下:

from django.db import models

#Create your models here.
class Wiki(models.Model):
pagename = models.CharField(max_length=20, unique=True)
content = models.TextField()

在这里,Wiki是model的名字,它是models.Model的子类,它的两个属性分别是models.CharField和 models.TextField的实例。pagename用来保存页面的名字,最大长度为20个字符,并且不能重复(因为它要作为页面的切换点)。 content用来保存页面的内容。

关于模型(Model)的深入阅读:http://www.djangoproject.com/documentation/model_api/

关于数据库API的深入阅读:http://www.djangoproject.com/documentation/db_api/

4. 安装wiki app

每个app创建后都需要手动安装,包括修改settings.py和初始化数据库两步。

4.1. 修改settings.py

在settings.py找到INSTALLED_APPS,修改为:

INSTALLED_APPS = (
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.sites’,
‘newtest.wiki’,
)

这一步是注册wiki app。

4.2. 初始化数据库

$ ./manage.py syncdb

这一步是根据wiki/models.py在数据库中创建相应的表。

5. 创建wiki的首页

我们使用命令行来创建一个名为FrontPage的首页。

$ ./manage.py shell

用这个命令会进入Python解释器,然后执行:

>>> from newtest.wiki.models import Wiki
>>> page = Wiki(pagename=’FrontPage’, content=’Welcome to Easy Wiki’)
>>> page.save()
>>> Wiki.objects.all()
[]
>>> p = Wiki.objects.all()[0]
>>> p.pagename
u’FrontPage’
>>> p.content
u’Welcome to EasyWiki’

在Django中操作数据库有两种方式:一种是集合操作方式,一种是对象操作方式。我们在这里使用的是集合操作方式,也就是使用model.objects来处理数据,all()会返回全部数据,filter()会返回符合条件记录。

6. 修改wiki/views.py

修改wiki/views.py,内容如下:

[quote]# Create your own views here.
#-*- coding: utf-8 -*-
from newtest.wiki.models import Wiki
from django.template import loader, Context
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render_to_response

def index(request, pagename=”):
”’显示一般页面,对页面内容做链接处理”’
if pagename:
#如果提供了页面的名字,则查找页面是否已经存在
pages = Wiki.objects.filter(pagename=pagename)
if pages:
#如果页面已存在,则调用模板来显示
return process(‘wiki/page.html’, pages[0])
else:
#如果页面不存在,则进入编辑页面
return render_to_response(‘wiki/edit.html’, {‘pagename’:pagename})
else:
#如果没有提供页面的名字,则显示首页
page = Wiki.objects.get(pagename=’FrontPage’)
return process(‘wiki/page.html’, page)

def edit(request, pagename):
”’显示编辑页面”’
page = Wiki.objects.get(pagename=pagename)
return render_to_response(‘wiki/edit.html’, {‘pagename’:pagename, ‘content’:page.content})

def save(request, pagename):
”’保存页面内容并转到更新后的页面,如果页面已存在则更新它的内容,如果页面不存在则新建这个页面”’
content = request.POST[‘content’]
pages = Wiki.objects.filter(pagename=pagename)
if pages:
pages[0].content = content
pages[0].save()
else:
page = Wiki(pagename=pagename, content=content)
page.save()
return HttpResponseRedirect(‘/wiki/%s’ % pagename)

import re
r = re.compile(r’\b(([A-Z]+[a-z]+){2,})\b’)
def process(template, page):
”’处理页面链接,并将换行符转换为
”’
t = loader.get_template(template)
content = r.sub(r’\1‘, page.content)
content = re.sub(r'[\n\r]+’, ‘
‘, content)
c = Context({‘pagename’:page.pagename, ‘content’:content})
return HttpResponse(t.render(c))

Wiki.objects对象有filter()和get()方法,前者返回一个结果集合(如果找不到会返回空集),后者返回指定的对象(如果找不到会抛出异常)。

换行符的转换也可以在模板中用filter来完成。

调用模板时使用wiki/edit.html而不是edit.html,表示我们将在templates目录中创建wiki子目录。为不同的app创建不同的子目录,这样方便区分、易于维护。

你应该记得wiki/models.py中pagename是唯一的,因此filter()的返回值一定是1个或0个元素,只要pages不是空集,我们就可以用pages[0]来访问我们想要的对象。

提示:在Django中,修改对象之后需要调用它的save()方法才会把它保存到数据库中去。

7. 创建templates/wiki/page.html文件

先创建templates/wiki目录:

$ mkdir ./templates/wiki

创建templates/wiki/page.html文件,内容如下:

{{ pagename }}

{{ content|safe }}



显示一般页面,包括页面标题和内容,在分割线下方显示编辑按钮。

提示:这里对content变量使用了safe标签(Tag),这样可以避免模板渲染时的自动转义。如果不加这个标签,那么在生成页面切换点时就会出现错误,得到<而不是<,无法生成超链接。 8. 创建templates/wiki/edit.html文件 创建templates/wiki.html文件,内容如下:

编辑:{{ pagename }}



显示编辑页面,包括页面的标题和已有内容,在文本区域下方显示保存按钮。

9. 修改urls.py

找到urlpatterns,修改为:

urlpatterns = patterns(”,
(r’^wiki/$’, ‘newtest.wiki.views.index’),
(r’^wiki/(?P\w+)/$’, ‘newtest.wiki.views.index’),
(r’^wiki/(?P\w+)/edit/$’, ‘newtest.wiki.views.edit’),
(r’^wiki/(?P\w+)/save/$’, ‘newtest.wiki.views.save’),
)

这里的URL是这样设计的:

wiki/pagename是显示一个页面,wiki/pagename/edit是编辑这个页面,wiki/pagename/save是保存这个页面。

10. 在Web浏览器中测试

先启动Django内置的Web服务器,然后在你的浏览器中输入http://127.0.0.1:8000/wiki/,你将进入Wiki的首页:

http://www.woodpecker.org.cn/obp/django/django-stepbystep/newtest/doc/tut06_01.jpg

点击编辑,你将进入FrontPage的编辑页面:

http://www.woodpecker.org.cn/obp/django/django-stepbystep/newtest/doc/tut06_02.jpg

我们加上一行“TestPage”,然后保存。TestPage是两个首字母大写的单词连在一起,它会被识别为页面切换点。现在的首页是这样的:

http://www.woodpecker.org.cn/obp/django/django-stepbystep/newtest/doc/tut06_03.jpg

我们点击“TestPage”将进入“TestPage”的编辑页面:

http://www.woodpecker.org.cn/obp/django/django-stepbystep/newtest/doc/tut06_04.jpg

我们把内容写为:

这是新的页面
返回首页 FrontPage

并保存。这时TestPage的页面如下:

http://www.woodpecker.org.cn/obp/django/django-stepbystep/newtest/doc/tut06_05.jpg

在这里点击“FrontPage”又将回到Wiki的首页。

11. 小结

在这一讲中,我们亲手创建了一个Wiki,其中使用了三个URL映射、三个View方法和两个三个模板文件。这个例子中我们完整地展示了Django中Model Template View的使用。

Django Step by Step 2010版(基于Django 1.1.1) 第五讲

原文发表于:2010年1月9日

1. 引言

这一讲我们要学习session,并开始接触模型(Model)。

session也就是会话,是为了在Web页面间交换数据而产生的,它保存在浏览器的cookie中。

在Django中使用session非常简单,只需要访问request对象的session属性,你可以把它当作一个字典来使用。

我们马上开始试验。给用户提供一个登录页面,上面有一个文本框用来输入用户名,还有一个提交按钮用来提交数据。当用户输入用户名,点击提交按钮后,就显示 用户已经登录,并且打印出用户输入的用户名,同时提供一个注销按钮。如果用户点击了注销按钮,就回到未登录的页面。未登录状态和登录状态是被记忆的,也就 是当你登录成功,并且没有注销时,你再次访问仍然显示的是登录成功的页面。当你没有登录或者注销后,你再次访问的就是未登录成功的页面。

2. 创建login.py文件

在newtest/目录下创建login.py文件,内容如下:

from django.http import HttpResponseRedirect
from django.shortcuts import render_to_response

def login(request):
username = request.POST.get(‘username’, None)
if username:
request.session[‘username’] = username
username = request.session.get(‘username’, None)
if username:
return render_to_response(‘login.html’, {‘username’:username})
else:
return render_to_response(‘login.html’)

def logout(request):
try:
del request.session[‘username’]
except KeyError:
pass
return HttpResponseRedirect(‘/login’)

这里定义了两个View方法,login()和logout()。login()提供登录页面,处理用户提交的数据,判断用户是否登录。logout() 从session中删除用户名,将页面重新定向到登录页面。Django的模板支持条件判断,因此这里可以通过传入不同的字典来控制模板的生成。

login()的具体工作流程是这样的:

1) 从POST中取出username,POST中的数据是由HTML页面的表单(form)提供的。如果成功取得了username,就把它加入到 session中去(实际上就是操作session这个字典,如果username这个键不存在,就新建这个键值对,如果username这个键已存在, 就覆盖这个键值对)。

2) 从session中取出username。如果成功取得了username,就返回已登录的页面,如果没有取得username,就返回未登录的页面。这里调用不同页面就是通过往模板传入不同的字典来实现的。

logout()的工作流程更简单:尝试删除session,然后重定向到未登录页面。

3. 创建login.html文件

创建newtest/templates/login.html文件,内容如下:

{% if not username %}

用户名:

{% else %}
{{ username }},您已经登录了!


{% endif %}

Django模板中的if的用法和Python中相似,可以使用not, and, or。在这里,如果username不存在,则显示一个表单,显示用户名输入文本框和登录按钮。如果username存在,则显示用户名和注销按钮。

4. 修改urls.py

找到urlpatterns,修改为:

urlpatterns = patterns(”,
(r’login/$’, ‘newtest.login.login’),
(r’logout/$’, ‘newtest.login.logout’),
)

5. 修改settings.py

Django的session需要使用数据库,Python 2.6中内置了sqlite3数据库,因此我们在这里直接使用sqlite3。sqlite3直接使用本地文件存储数据库,因此不存在服务器、端口、用户 名、密码、权限的配置问题,马上就可以开始使用,简单方便。

对newste/settings.py进行如下修改:

[quote]DATABASE_ENGINE = ‘sqlite3’
DATABASE_NAME = ‘./data.db’
DATABASE_USER = ”
DATABASE_PASSWORD = ”
DATABASE_HOST = ”
DATABASE_PORT = ”

6. 初始化数据库

需要手动执行syncdb命令来完成数据库的初始化操作,包括创建数据库、数据表。命令如下:

$ ./manage.py syncdb

当出现是否要创建超级用户的提示时:

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,然后创建一个用户名和密码都是test的超级用户。这个超级用户在以后会用到。

7. 在Web浏览器中测试

先启动Django内置的Web服务器,然后在你的浏览器中输入http://127.0.0.1:8000/login/。接下来测试一下登录和注销。

8. 小结

这一讲中,我们学习了Django中session的使用,尝试了模板(template)渲染(render)的另一种方式,并且初步接触了模型(model)。这些内容在网站开发中将会经常用到。

Django Step by Step 2010版(基于Django 1.1.1) 第四讲

原文发表于:2010年1月8日

1. 引言

回顾之前的内容,我们可以看到Django的大致开发流程:

添加View方法 -> 添加模板 -> 修改urls.py

再加上数据库相关的模型(Model)部分,这个流程在逻辑上就完整了。不过在我们开始学习模型之前,我们再巩固一下之前学到的知识。

在这一讲,我们要改进上一讲的通讯录,提供CSV格式的通讯录下载。

2. 修改list.html

在templates/list.html文件的末尾加上一行:

csv格式下载

这些代码会在通讯录表格下显示一个指向CSV格式通讯录文件的超链接。

3. 创建csv_test.py文件

在newtest目录下创建csv_test.py文件,内容如下:

#-*- coding: utf-8 -*-
from django.http import HttpResponse
from django.template import loader, Context

address = [
(‘张三’, ‘地址一’),
(‘李四’, ‘地址二’)
]

def output(request, filename):
response = HttpResonse(mimetype=’text/csv’)
response[‘Content-Disposition’] = ‘attachment; filename =%s.csv’ % filename
t = loader.get_template(‘csv.html’)
c = Context({‘data’:address})
response.write(t.render(c))
return response

提示:不要使用csv.py作为文件名,它会和系统的csv模块重名。

这里没有使用render_to_response,因为我们需要修改response对象的值,而render_to_response封装了response使我们无法修改它。

实际的工作流程是:创建response对象(HttpResonse类的一个实例),修改response的属性,加载模板(先生成template对象,再生成Context对象)、渲染模板(t.render(c)),返回准备好的response对象。

注意,这里的address不是字典的列表,而是元组的列表,实际上只要是序列,Django模板都能处理。

关于request和response的深入阅读:http://www.djangoproject.com/documentation/request_response/

4. 创建csv.html文件

在newtest/templates/目录下创建csv.html文件,内容如下:

{% for row in data %}
“{{ row.0|addslashes }}”, “{{ row.1|addslashes }}”
{% endfor %}

记住data是一个列表,而这个列表的元素是元组,因此row.0和row.1就是取元组的第一个和第二个元素。|是过滤符号,表示将前面处理的结果作为 输入传入后面的处理,addslashes是Django模板内置的过滤标签(Tag),它的作用是给特殊字符加上反斜线。

Django中可以自定义标签,具体可以阅读:http://www.djangoproject.com/documentation/templates_python/

5. 修改urls.py

找到urlpatterns,修改为:

urlpatterns = pattern(”,
(r’list/$’, ‘newtest.list.index’),
(r’csv/(?P\w+)/$’, ‘newtest.csv_test.output’),
)

增加了这个URL映射后,如果你访问/csv/address/,将调用csv.output(filename=’address’)。

6. 在Web浏览器中测试

先启动Django内置的Web服务器,然后在你的浏览器中输入http://127.0.0.1:8000/list/,看到最后的超链接了吗,点一下看看是不是会提示你下载和保存address.csv这个文件。

7. 小结

Django的模板系统、View方法、URL映射是非常强大和易于使用的,在这一讲里我们再次看到了这一点。

接下来我们就要学习模块(Template),开始和数据库打交道了。

Django Step by Step 2010版(基于Django 1.1.1) 第三讲

原文发表于:2010年1月8日

1. 引言

上一讲中,我们直接用add.index()返回HTML代码,这种混合方式(指Template和View混合在一起)不适合于大型开发。这一讲我们要 学习Template(模板)的使用。Django自带模板系统,当然你也可以使用自己的模板系统:在return前使用自己喜欢的模板系统进行处理,然 后返回。不过Django自带的模板系统有很多特点,我们接下来就使用它。

我们使用的例子是:用一个表格来显示通讯录数据。

在这里我们仍然先不使用数据库,而是把数据保存在View中。

2. 创建list.py文件

list.py的内容如下:

#-*- coding: utf-8 -*-
from django.shortcuts import render_to_response

address = [
{‘name’:’张三’, ‘address’:’地址一’},
{‘name’:’李四’, ‘address’:’地址二’}
]

def index(request):
return render_to_response(‘list.html’, {‘address’:address})

提示: 如果源代码中出现了中文字符,文件的开头就要加上“#-*- coding: utf-8 -*-”这一行,表示使用UTF-8编码。

这里使用了render_to_response这个方法,它调用了list.html这个模板,用字典填充模板(也就是把模板中的变量替换成相应的内 容,这又称为渲染),然后返回生成的文本。这种方式和格式化字符串(例如:print ‘Hello %s!’ % ‘World’)非常相似。

3. 创建templates目录

在newtest目录下创建templates目录,用来存放模板文件。

$ mkdir templates

4. 修改settings.py

找到TEMPLATE_DIRS,进行如下修改:

TEMPLATE_DIRS = (
‘./templates’,
)

如果有多个模板目录,可以都加入TEMPLATE_DIRS这个元组(tuple),Django会按顺序搜索这些目录。

5. 创建list.html文件

在newtest/templates/目录下创建list.html,内容如下:

通讯录

{% for user in address %}

{% endfor %}

姓名
{{ user.name }} {{ user.address }}

这个模板文件会生成一个两列的表格。在Django的模板中,{% %}表示代码调用,{{ }}表示变量引用。for … in称为模板标签(tag),Django模板有很多功能强大的标签,并且可以进行扩展。关于模板语言的深入阅读:http://www.djangoproject.com/documentation/templates/

6. 修改urls.py

找到urlpatterns,修改为:

urlpatterns = pattern(”,
(r’^list/$’, ‘newtest.list.index’),
)

7. 在Web浏览器中测试

先启动Django内置的Web服务器,然后在你的浏览器中输入http://127.0.0.1:8000/list/,你应该看到如下结果:

8. 小结

在这一讲中,我们真正开始使用Django的模板(Template)系统了。简单回顾一下我们都做了什么,我们先创建了View,在View中使用了模 板,然后创建模板目录、修改settings.py并创建了模板文件,接下来修改urls.py。在模板文件中,我们使用了模板标签(Tag),尝试了代 码调用和变量引用。

又前进了一步,让我们继续吧!

Django Step by Step 2010版(基于Django 1.1.1) 第二讲

原文发表于:2010年1月7日

1. 引言

接下来我们要学习一个比Hello World!复杂一些的例子——在Web页面中实现一个加法器。最后要得到的结果如下:

http://www.woodpecker.org.cn/obp/django/django-stepbystep/newtest/doc/tut02_01.jpg

两个用于输入的文本框,一个等号是提交按钮,以及一个显示加法结果的文本框。

通过实现这个例子,我们将学会如何处理Web页面提交的数据:获得用户输入,并做出正确的反馈。

2. 创建add.py文件

Django框架的模型称为MTV,也就是Model + Template + View,它和一般的MVC的含义其实是一样的,只是称呼不同。Model实现了对数据库的访问,Template实现了Web页面的模板,View则是 处理URL、完成最终页面的方法。我们这里创建的add.py其实就是View。

add.py的内容如下:

from django.http import HttpResponse

html = ”’

+

”’

def index(request):
if request.POST.has_key(‘a’):
a = int(request.POST[‘a’])
b = int(request.POST[‘b’])
else:
a = 0
b = 0
return HttpResponse(html % (a, b, a+b))

提示:action之所以是“/add/”而不是“/add”,是为了避免得不到POST数据(深入阅读:http://code.djangoproject.com/wiki/NewbieMistakes)。

所有View中的方法,第一个参数都是request对象,它的值由Django自动生成,有GET和POST两种属性,分别保存不同方式提交的数据。这两个属性都可以像字典一样工作(深入阅读:http://www.djangoproject.com/documentation/request_response/)。

3. 修改urls.py

修改urls.py的内容为:

from django.conf.urls.defaults import *

urlpatterns = patterns(”,
(r’^add/$’, ‘newtest.add.index’),
)

4. 在Web浏览器中测试

先启动Django内置的Web服务器,然后在你的Web浏览器中输入http://127.0.0.1:8000/add/,看看你是不是得到了正确的结果。

5. 小结

在这一讲,我们简单地展示了Django的MTV架构中的Template和View,你可以把add模块的html属性看作Template,把add 模块的index方法看作View。通过修改urls.py,让特定的View方法去处理特定的URL,从而得到我们想要的结果,这就是Django的基 本工作原理。

在form中我们使用了post而不是get,这是为了和Django设计风格统一。Django设计风格认为:使用POST表示要对数据进行修改,使用GET只是获取。认可这个风格,并养成相同的习惯,是一件非常好的事情。

关于URL映射的深入阅读:http://www.djangoproject.com/documentation/url_dispatch/

Django Step by Step 2010版(基于Django 1.1.1) 第一讲

原文发表于:2010年1月7日

1. 开篇

Django是Python下最热门的Web开发框架(Web Framework),它的功能强大、社区活跃、应用众多、发展迅速,被众多高手看好,受到了广大Python用户的喜爱。

Django项目官方提供了一些入门教程,用简短的篇幅展示了Django的主要特色。不过对于初学者来说,学习这些教程一下接触了太多东西,往往难以消化。在这里,我们要打破这种方式,从一个最简单的例子做起,记录下这个过程,形成一篇教程。

2. Django的入门体验

2.1. 安装

我的测试环境是Ubuntu 9.10,这是目前最流行的Linux桌面操作系统。

从官方软件源中安装Python和Django:

$ sudo aptitude install python

$ sudo aptitude install python-django

(注:“$”是Ubuntu 9.10终端(Terminal)的命令行提示符,下同)

我们看一下它们的版本号:

$ aptitude show python

$ aptitude show python-django

Python的版本号是2.6.4,Django的版本号是1.1.1。

2.2. 生成项目目录(Project)

我们在家目录(home)下新建一个workspace目录,用来保存源代码。

$ mkdir workspace

$ cd workspace

$ mkdir django

$ cd django

接下来我们的所有测试都在~/workspace/django/目录下进行。

Django提供了django-admin这个工具来创建项目目录:

$ django-admin startproject newtest

这样会在当前目录下新建newtest目录,newtest目录下有4个文件:

__init__.py
表示这是一个Python的包

manage.py
可执行文件。用于项目管理的简便工具,可以自动处理DJANGO_SETTINGS_MODULES和PYTHONPATH。

settings.py
Django的配置文件

urls.py
处理URL映射

2.3. 启动Web服务器(Web Server)

Django内置了一个小型的Web服务器,大大方便了程序调试。我们现在就可以在newtest目录下启动这个内置的Web服务器。

$ ./manage.py runserver

正常情况下将出现下面的提示:

Validating models…
0 errors found

Django version 1.1.1, using settings ‘newtest.settings’
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

我们在浏览器中键入:

http://127.0.0.1:8000/

然后我们将看到下面的信息:

It worked!
Congratulations on your first Django-powered page.

Of course, you haven’t actually done any work yet. Here’s what to do next:

* If you plan to use a database, edit the DATABASE_* settings in newtest/settings.py.
* Start your first app by running python newtest/manage.py startapp [appname].

You’re seeing this message because you have DEBUG = True in your Django settings file and you haven’t configured any URLs. Get to work!

恭喜你,这说明你的Django已经开始工作了!让我们继续吧!

2.4. 开始我们的第一个应用Hello World!(app)

Django中的应用是以app形式存在的,这是Django的主要特色,通过它你可以轻易地实现代码的重用和重发布。

不过为了更好地搞清楚Django在干什么,我们先绕过app,直接生成一个URL映射(URL映射做的事情就是调用一个Python方法来处理一个URL请求,得到用户想要的结果)。

在newtest目录下新建helloworld.py文件,内容为:

from django.http import HttpResponse

def index(request):
return HttpResponse(‘Hello World!’)

2.5. 修改urls.py

默认的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’^newtest/’, include(‘newtest.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)),
)

我们把它修改为:

from django.conf.urls.defaults import *

urlpatterns = pattern(”,
(r’^$’, ‘newtest.helloworld.index’),
)

上面把注释都省略了。r’^$’是一个匹配空字符串的正则表达式,当你访问http://127.0.0.1:8000/时就会调用上一节我们创建的helloworld.py模块中的index方法。

如果你已经启动了Django内置的Web服务器,那么请在Web浏览器中访问一下http://127.0.0.1:8000/。

是不是看到“Hello World!”了,心情激动吗?反正我第一次看到它的时候,心情是很激动的^_^ 原来Django也可以这么简单啊。

3. 小结

Django是一种松散的Web开发框架的组合,它既简单又复杂。简单是因为它很容易上手,可以快速开发出高效的Web应用。复杂是因为要掌握它的自动化的、高级的功能你需要学习很多东西。

接下来,我们继续一点一点地挖掘Django的功能特性吧。

Django Step by Step 2010版(基于Django 1.1.1) 前言

原文发表于:2010年1月7日

前言

limodou大侠在2006年写下了Django Step by Step,至今它仍是Django入门的经典教材。不过当时它是基于Django 0.9.5的,经过3年多的发展,如今Django已经发展到了1.1.1,其中有很多更新不是向下兼容的。趁着学习和使用Django的机会,我准备基 于Django 1.1.1重写这篇教程(其实也就是我的学习笔记,不好意思^_^),姑且就叫它Django Step by Step 2010版,在这里向limodou大侠致敬,希望与大家共勉。