学习需要坚持！
django+fastcgi+flup+MsQLdb构建python的web开发环境
django+fastcgi+flup+MsQLdb构建python的web开发环境
环境需求：
前端：nginx+fastcgi
后端：django-&mysqldb
所需软件包：
/releases/1.3/Django-1.3.1.tar.gz
/snapshots/setuptools-0.6c12dev_r88846-py2.7.egg
/dist/ez_setup.py
wget /software/flup/dist/flup-1.0.2.tar.gz
一、安装python2.7.2软件包
tar jxvf Python-2.7.2.tar.bz2
cd Python-2.7.2
./configure && make && make install
二、安装MySQLdb
yum -y install python-devel mysql-devel zlib-devel openssl-devel
安装setuptools:
方法(一)、下载后直接执行python ez_setup.py会自动搜索安装相应版本
方法(二)、easy_install& setuptools-0.6c12dev_r88846-py2.7.egg
setuptools安装后才能安装mysqldb不然安装不成功
tar zxvf MySQL-python-1.2.3.tar.gz
cd MySQL-python-1.2.3
python setup.py build
python setup.py install
测试导入MySQLdb模块
&&& import MySQLdb
三、安装flup和django
tar zxvf flup-1.0.2.tar.gz
cd flup-1.0.2
python setup.py& install
tar zxvf Django-1.3.1.tar.gz
cd Django-1.3.1
python setup.py install
django-admin.py startproject webpj&& 创建一个目录webpj,里面包含基本配置文件
清单如下：
__init__.py
settings.py
python manage.py startapp jobs&& 创建一个应用
清单如下：
__init__.py
四、配置fastcgi支持python应用：
添加localtion:
location / {
root /data/wwwroot/python/websit01;
fastcgi_pass 127.0.0.1:9001;#django的启动端口
include fastcgi_django.
fastcgi_django.conf 内容如下：
fastcgi_param& SCRIPT_FILENAME&&& $document_root$fastcgi_script_
fastcgi_param& QUERY_STRING&&&&&& $query_
fastcgi_param& REQUEST_METHOD&&&& $request_
fastcgi_param& CONTENT_TYPE&&&&&& $content_
fastcgi_param& CONTENT_LENGTH&&&& $content_
fastcgi_param& REQUEST_URI&&&&&&& $request_
fastcgi_param& DOCUMENT_URI&&&&&& $document_
fastcgi_param& DOCUMENT_ROOT&&&&& $document_
fastcgi_param& SERVER_PROTOCOL&&& $server_
fastcgi_param& GATEWAY_INTERFACE& CGI/1.1;
fastcgi_param& SERVER_SOFTWARE&&& nginx/$nginx_
fastcgi_param& REMOTE_ADDR&&&&&&& $remote_
fastcgi_param& REMOTE_PORT&&&&&&& $remote_
fastcgi_param& SERVER_ADDR&&&&&&& $server_
fastcgi_param& SERVER_PORT&&&&&&& $server_
fastcgi_param& SERVER_NAME&&&&&&& $server_
五、修改django配置并启动服务
修改settings.py中的
DATABASES参数根据情况修改
LANGUAGE_CODE = 'zh-cn'
TIME_ZONE = 'Asia/Shanghai'
python manage.py runfcgi method=threaded host=127.0.0.1 port=9001
本文标签：
除非注明，文章均为()原创，转载请保留链接:
----===== 博主信息 =====----python下的web开发框架-Django,django模板的使用
python下的web开发框架-Django,django模板的使用
模板是简单的文本文件，它可以是html格式或是xml,csv等格式的
模板包括变量，括它会被值所替代当运行时，以及标签它控制模板的逻辑运算如if,else等
下面是一个简单的模板，我们将会对它做详细的说明
{% extends "base_generic.html"
{% block title %}{{ section.title
}}{% endblock %}
{% block content %}
&h1&{{ section.title
{% for story in story_list
&a href="{{ story.get_absolute_url
story.headline|upper }}
&p&{{ story.tease|truncatewords:"100"
{% endfor %}
{% endblock %}
{{ variable }}
双括号里面的叫变量,当你前面如果存入一个变量的话，它将会用变量名所对应的值来替换双括号里面的值
使用 (.)来获得变量的属性（技术上当你在变量后输入.后它会依次去找对应的字典，属性，方法，列表index的值）
在上面的例子中。{{ section.title }}将会被section对象的title属性的值所替换
如果你使用的变量的不存在的话，模板系统将会插入''值也就是空值来做为默认值
你可以改变变量的显示方式如：全部大写，使用过滤
{{ name|lower
}}就是一个简单的过滤，类似于linux操作系统的管道,它将会显示变量name的值，但是显示name的值之前经过lower这个过滤器，它将会把变量值转换成小写,我们使用|来提供一个过滤器
过滤可以以"链接",就是把一个变量经过过滤后的值再次过滤
如：{{ text|escape|linebreaks }}
就是输出text变量的值，然后转换为使用&p&的格式来显示
(需要验证是什么意思)
一些过滤要参数，如{{ bio|truncatewords:30
}}，这个过滤器将会量示bio变量的前30个字符
过滤参数如果包含空格必须引用，如：{{ list|join:", "
}}，join一个列表使用,做为分隔附
django提供了三十个内置的过滤器，具体的就不一一说了，下面列几个常用的
{{ value|default:"nothing" }}
如果value的值没有提供或者为空，这时这个变量的值将会被设为nothing
{{ value|length }}
返回value变量的长度,value可以为String或者是列表list
如：value值如为 ['a', 'b', 'c', 'd'],将会输出4
{{ value|striptags }}
去掉html标签显示，如：如果你的value值为"&b&Joel&/b&
&button&is&/button&
&span&slug&/span&"
将会去掉html标签显示为:"Joel is a slug"
当然，我们也可以自己实现过滤器。
%}类似于这样的就是标签，相对于变量，它复杂许多。它包括，创建文本输出，控制流程以及逻辑的以及引用外部资源（包部模板）
一些标签要求开始和结束标记，类似于html的&&&/&
{% tag %} ... tag contents ... {% endtag %}
Django有一大把的标签，下面我们列几个常用的给大家参考
迭代列表里面的每一个值，如：下面的列子，我们将输出每一个athletes列表里面的athlete的name属性
{% for athlete in athlete_list %}
&li&{{ athlete.name
{% endfor %}
if and else
判断一个变量，如果变量的值为"true"则代码块或变量会被执行
{% if athlete_list %}
&&& Number of
athletes: {{ athlete_list|length }}
{% else %}
{% endif %}
在上面的代码中，如果athlete_list的值不为空，将会执行 Number of athletes: {{
athlete_list|length }}代码，输出athlete_list的长度
ifequal and ifnotequal
显示内容，如果两个参数相同或不相同。如：
{% ifequal athlete.name coach.name
{% endifequal %}
athlete.name的值和coach.name的值相同执行...处的代码
{% ifnotequal athlete.name "Joe" %}
{% endifnotequal %}
如果athlete.name的值不等于Joe，则执行下面的代码
block and extends
使用模板继承，一个非常好的重用模板的方式
当然，你可以自已写标签
属于模板一部分的注释，使用{# #}
{# greeting #}hello
上面代码中，有用的只有hello.其他的为注释
非常有用的功能，虽然有点复杂，它可以允许你先建立模板的骨架。然后一块一块的组合起来
下面我们用一个简单的例子来介绍模板继承
&!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
&html xmlns=""
xml:lang="en" lang="en"&
&link rel="stylesheet" href="style.css"
&title&{% block title %}My amazing
site{% endblock %}&/title&
&div id="sidebar"&
{% block sidebar %}
&&&&&&&&&&&
href="/"&Home&/a&&/li&
&&&&&&&&&&&
href="/blog/"&Blog&/a&&/li&
{% endblock %}
&div id="content"&
{% block content %}{% endblock %}
在上面这个模板中，我们叫它为base.html.因为它定义了一个简单地的html页面纲要，我们只需要创建它的子模板去填充它空白的blocks内容即可
在这个模板中。我们空义了三块{% block %}标签，三块{%
block %}标签我们可以使用它的子标签来填充它。我们需要子标签来覆盖它
下面我们写一个它的子标签：
{% extends "base.html" %}
{% block title %}My amazing blog{%
endblock %}
{% block content %}
{% for entry in blog_entries %}
&h2&{{ entry.title
&p&{{ entry.body
{% endfor %}
{% endblock %}
{% extends %}
标签告诉了我们该html的父模板为base.html
下面同样的block将会替换掉父标签中的内容,运行后，结果将会是:
&!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
&html xmlns=""
xml:lang="en" lang="en"&
&link rel="stylesheet" href="style.css"
&title&My amazing
blog&/title&
&div id="sidebar"&
&&&&&&&&&&&
href="/"&Home&/a&&/li&
&&&&&&&&&&&
href="/blog/"&Blog&/a&&/li&
&div id="content"&
&p&This is my first
entry.&/p&
&p&This is my second
entry.&/p&
当然，如果子模板中没有定义变量的话，父模板会用它的内容来替代。
需要的话，模板也可以多重继承。下面是使用模板继承需要的一些心得:
1.创建base.html模板，它主要是存放模板的设计结构
2.创建base_SECTIONNAME.html板模，它继承base.html，它会包括页面的样式，设计
3.创建具体的模板，对于每一个要用到的页面，它继承base_SECTIONNAME.html,只需要存放要显示的变量就可以了
上面的方法可以最大程度的让代码可以重用，而且方面增加页面的内容
下面列一些注意点
1.如果你使用{% extends %}在模板中，必须是模板的第一个标签，否则，模板继承将会出错而不能工作
2.如果你的基础模板中有大量的{% block
%}是好事，记住，子模板不需要定义所有的父定义过的blocks
3.如果你发现你的子模板中有重复的内容，也许意味着你将要移动你的{%
block %}到父模板中去
4.如果你需要获得父模中block的内容，{{ block.super
}} 变量不能使用，它仅仅是当你想覆盖父模板中相同块的内容.
5.为了增加可读性，block的名字一定要起有意义的
同一个模板中，不能有重复的{% block %}标签。
自动忽略html
当模板中生产html,会对显示变量的值生产一些影响
Hello, {{ name }}.
如果我们在页面输入name变量的值为&script&alert('hello')&/script&
这时模板发送的name值为Hello,
&script&alert('hello')&/script&
这时就会默认的调用js来弹出hello语句。。。。这是我们不希望看到的
还有。如果name包含'&'符号，如&b&username
结果将会显示:Hello,
&b&username,这时输出的name值将会加粗。。
还有。一此恶意客户的攻击。对于这些情况。我们给出两点建议
1.确定每一个变量都经过escape
过滤器的过滤，它将会转换有害的html转为没害的。就是在django里面的标准解决方法。
2.你可以使用django定义的来代替一些值如
如何关闭html过滤使用过滤器
This will be escaped: {{ data
This will not be escaped: {{ data|safe }}
safe过滤器将会把html标签做为字符串来处理
显示时，如果输入;&b&
将会用如下形式：
This will be escaped: &b&
如何关闭html语法使用标签
{% autoescape off %}
&&& Hello {{
{% endautoescape %}
autoescape将会关闭html语法显示.
String的自动转换:
{{ data|default:"3 & 2" }} 用第一种方法
{{ data|default:"3 & 2" }} 不好的方法。将会出错
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。在 Django 中构建 Oracle 数据库支持的 Web 应用程序
开发人员：Python
在 Django 中构建 Oracle 数据库支持的 Web 应用程序
了解如何配置 Django 以便与 Oracle 数据库交互，并使用 ORM 进行数据库连接。
作者：Yuli Vasiliev
2009 年 8 月发布
产能在软件开发环境中意味着及时完成工作的能力。开发人员经常发现自己在重复执行相同的任务，这无疑会降低其产能。这是框架能够派上用场的地方：使用适当的框架，您可以将重点放在项目需求上，而不是处理低级、棘手的实施细节。
Django 是基于 Python 的 Web 应用程序框架，最初旨在简化数据库驱动的、面向新闻的 Web 应用程序的开发。其后，它已经发展成功能完备的 Web 框架，经常用来简化数据库支持的复杂 Web 应用程序的开发。
Django 的对象关系映射器 (ORM) 位于框架的中心，介于数据模型（您在 django.db.models.Model 类之上构建的 Python 类）和基础关系数据库对象之间。定义数据模型之后，您将能够通过映射到基础数据库中的对象的 Python 对象，来创建、检索、更新以及删除数据库数据。需要强调的是，除了 PostgreSQL、MySQL 和 SQLite 之外，Django 还正式支持 Oracle 数据库，可让您使用 ORM 特性访问和操作 Oracle 数据库数据。
安装 Django
如果您尚未安装 Django，现在可以进行安装。首先，确保您已安装 Python 2.3 或更高版本。此外，请务必安装 cx_Oracle 驱动程序（针对 Oracle 的 Python DB-API 实施），以便 Python 可与 Oracle 数据库交互。有关详细信息，您可以参阅 Przemyslaw Piotrowski 撰写的另一篇 OTN 文章&&。然后，您可以从 Django Software Foundation 网站的 Download 页面获得 Django，地址为
。撰写本文时，最新的正式版本为 1.1。
安装非常简单。只需解压缩已下载的程序包，将目录更改到 Django 的解压缩目录，然后运行以下命令：
python setup.py install
上述命令将启动安装过程，此过程只需几秒。确保安装成功的最简单方法是通过 Python 交互式解释器。在交互式解释器会话中，只需输入以下命令：
import django
如果一切正常，您应该不会看到错误消息。
假设您已安装 Django，现在可以尝试创建您的第一个 Django 项目，并在其中创建一个应用程序。
在 Django 中，项目包括特定网站的配置和应用程序。因此，单个项目实际上可能包括多个应用程序。然而，为了简单起见，在此创建的项目只包括一个应用程序。
首先，您可能要创建一个用于存储 Django 项目的文件夹，从操作系统提示符进入此文件夹，然后发出以下命令：
django-admin.py startproject myproj
结果，应该显示 myproj 文件夹及其内含的以下四个文件：__init__.py、manage.py、settings.py 以及 urls.py。这四个文件的每一个都在项目中起着特定作用。
包括 __init__.py 是为了让此目录成为 Python 程序包，以便您能够通过点符号引用项目的各部分；例如，myproj.settings。
manage.py 表示与上述 django-admin.py 提供相同命令但旨在用于此特定项目的命令行实用程序。
settings.py 是包含项目设置的配置文件。在此，您可以指定数据库连接信息、时区和语言代码、有关项目中所安装的应用程序的信息，以及一些其他设置。
urls.py 又称为 URLconf，是包含将 URL 模式映射到 Python 回调函数的 Python 代码的配置文件。
您可以看到，即使 Django 项目的配置文件也是以 Python 源代码文件的形式提供。此方法被证明很有优势，因为它使您能够动态指定设置和/或从其他配置文件中导入设置。
现在您已创建项目，可以继续下一环节，在此项目内创建一个应用程序。为此，进入先前由 django-admin.py 生成的 myproj 文件夹，并发出以下命令：
manage.py startapp myapp
在 Linux 上，您可能需要发出：
chmod +x manage.py
./manage.py startapp myapp
上述命令应该生成文件夹 myapp 及其内含的以下四个文件：__init__.py、models.py、views.py 以及 tests.py。同样，__init__.py 用于使此目录成为 Python 程序包。Tests.py 可用于为应用程序构建测试套件。此外，您将使用其余的两个文件分别定义应用程序的模型和视图：
models.py 用于包含模型（您在 django.db.models.Model 类之上构建的 Python 类），其中每个模型都映射到一个数据库表。
views.py 用于包含视图（Python 函数），其中每个视图或者返回 HttpResponse 对象（内容将显示在所请求页面上），或者引发 HTTP 异常。
下一步是将新创建的应用程序与项目相关联。为此，您需要编辑 myproj 文件夹中的 settings.py 文件，将字符串&myproj.myapp&追加到 INSTALLED_APPS 字节组中，如下所示：
INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'myproj.myapp'
您已完成了应用程序主干的构建。然而，在可以查看应用程序是否正常工作之前，需要执行一些额外步骤。当然，这些步骤可能会有所不同，具体取决于您希望应用程序执行的操作。例如，如果您要构建不与数据库交互的简单应用程序，则不需要将数据库信息放在 settings.py 配置文件以及设计数据模型中。但在大多数情况下，您至少需要执行以下五个步骤：
在 settings.py 中指定数据库信息
在 urls.py 中配置 URL 模式
在继续上述步骤之前，让我们看一下 Django 应用程序的高级视图，以便您可以更好地了解 Django 中的组件如何工作。下图示意性地显示了 Django 应用程序如何工作以满足用户请求。
根据此图中的图示，工作方式如下：
用户输入支持 Django 的站点的 URL 或在此站点的已加载页面上执行操作，从而将请求发送到托管此站点的 Web 服务器。
Django 的 URL 调度程序遍历 urls.py 文件中的 URL 模式，并选择第一个与用户请求的 URL 匹配的模式，然后调用与所发现模式相关联的视图（Python 回调函数）。
视图使用数据模型获得数据库数据，然后加载指定模板（已嵌入特殊模板标记的 HTML 页面；它类似于 Java 中的 JavaServer Page），并向其传递上下文（包括映射到模板变量名称的已获得数据）。
最后，视图返回由已呈现模板填充的 HttpResponse 对象，如果出现错误，则返回 HTTP 异常。
您可以看到，Django 基于将 Web 应用程序逻辑分为模型、视图和模板的概念，因此有效地将业务逻辑和展示分离开来。通常，这类似于当今许多其他 Web 框架中使用的模型-视图-控制器 (MVC) 范例。然而，在 Django 中，视图更像控制器，介于模型和模板之间。而 Django 模板更接近于 MVC 视图，因为这些模板负责使用从模型中获得的数据生成适当的用户界面。
现在您已掌握 Django 的概念，让我们继续在本部分开头启动的项目，构建一个与 Oracle 数据库交互的简单应用程序。
配置 Django 以便与 Oracle 数据库交互
您必须先告诉 Django 如何连接到数据库，才能利用 Django 的数据库相关特性。您可以通过在项目的 settings.py 配置文件中配置数据库相关设置来执行此操作。对于在上一部分开头创建的项目，您需要编辑 django-admin.py 生成的 myproj 目录中的 settings.py。
在文本编辑器中打开 settings.py 文件，并根据您的数据库编辑与数据库相关的设置。例如，您可能按如下方式编辑它们：
DATABASE_ENGINE = 'oracle'
DATABASE_NAME = 'XE'
DATABASE_USER = 'hr'
DATABASE_PASSWORD = 'hr'
DATABASE_HOST = 'localhost'
DATABASE_PORT = '1521'
上述方式假设您在数据库中安装了 HR 演示模式并解除了锁定。然而，在实际项目中，您很可能会使用针对特定应用程序设计的自定义模式。需要注意的是，Django 可以省去您自己创建基础表的麻烦。完成数据模型的构建之后，您可以运行 manage.py syncdb 命令以自动创建数据库表 & 针对 models.py 文件中的每个数据模型创建一个数据库表。但为了简单起见，本文中的示例将使用 HR 演示模式中已经存在的表。
现在您已指示 Django 与特定 Oracle 数据库交互，可以继续构建数据模型。
与模型的对象关系映射
如前所述，Django 支持与模型的对象关系映射，其中每个模型映射到单个数据库表，并表示子类为 django.db.models.Model 标准类的 Python 类。
以下示例说明如何针对现有表定义模型。在此示例中，您将使用 HR 的 employees 表，仅针对此表的选定字段定义模型字段。在 myproj/myapp 目录中打开 models.py 文件并进行编辑，添加 employees 类，如下所示：
from django.db import models
# Create your models here.
class employees(models.Model):
employee_id = models.IntegerField(primary_key=True)
first_name = models.CharField(max_length=20, null = True)
last_name = models.CharField(max_length=25)
email = models.CharField(max_length=25)
class Meta:
db_table = &employees&
请注意，此处使用了一些模型字段选项。通过设置 primary_key = True，可显式指定此字段是模型的主键。max_length 是 CharField 这一字符串字段所需的参数。如果将可选的 null 参数设置为 True，即表示告诉 Django 将空值作为 NULL 保存到数据库中。默认情况下，此参数设置为 False。要查看字段选项和字段类型的完整列表，您可以参阅 Django
中的 Model 字段参考页面。
在上述示例中，另一个需要注意的事项是类 Meta 的使用，您可以通过此类为模型提供元数据选项。在此特定示例中，您使用 db_table 选项显式指定模型要映射到的表的名称。实际上，默认情况下，Django 假设表的名称由模型类的名称和应用程序名称组成（通过下划线 (_) 符号分隔）。因此，在此特定示例中，Django 将查找名为 myapp_employees 的表。当然，db_table 并不是您可用于模型内部类 Meta 的唯一选项。您可以在 Django 文档的 Model Meta 选项页面上查看可用的 Meta 选项列表。
此处讨论的示例很简单，因为它仅显示到单个数据库表的映射。但实际上，您通常必须处理一组通过外键约束相互关联的基础数据库表。为了解决此问题，Django 提供了 ForeignKey 字段类型，可让您定义表示多对一关系的模型字段。
幸运的是，HR 演示模式仅包含一组通过外键约束相互关联的表。例如，您可能选择 departments 表（其 manager_id 字段是 employees 表中 employee_id 的外键），并定义以下模型（将其添加到 models.py 文件中）：
class departments(models.Model):
department_id = models.IntegerField(primary_key=True)
department_name = models.CharField(max_length=30)
manager = models.ForeignKey(employees, null = True)
class Meta:
db_table = &departments&
看一下上述模型定义，您可能已经注意到，它针对外键模型字段使用名称 manager，而不是实际在 departments 表中使用的 manager_id。实际上，在模型中使用的 manager 字段引用相应的 employees 对象，而非此对象的 employee_id 字段。当外键字段名称要引用基础表中的相应列时，Django 会隐式地将 _id 追加到此名称中。然而，在某些情况下，表中外键字段的名称结尾可能不包含 _id。如果是这种情况，您可以使用外键模型字段的 db_column 参数显式指定表列名称。虽然在此特定示例中无需如此，但您可以使用以下语法在 departments 表中显式指定外键列的名称：
manager = models.ForeignKey(employees, db_column = 'manager_id', null = True)
除了上述通过 ForeignKey 定义的多对一关系之外，Django 还支持一对一和多对多关系，您可以在模型中分别通过 OneToOneField 和 ManyToManyField 字段来定义。
使用数据库抽象 API
完成模型构建之后，您可以继续下一环节，构建将使用这些模型的视图。您可以在此使用 Django 数据库抽象 API 创建、检索、更新以及删除映射到基础数据库中的对象的 Python 对象（模型）。
让我们借助在上一部分中创建的模型，创建一个将从 employees 和 departments 数据库表中获取数据的简单视图。在 myproj/myapp 目录中，打开 views.py 文件并进行编辑，如下所示：
# Create your views here.
from django.template import Context, loader
from django.http import HttpResponse
from myproj.myapp.models import employees, departments
def index(request):
department_list = departments.objects.exclude(manager__employee_id__exact = None).order_by('manager__employee_id')
tmpl = loader.get_template(&index.html&)
cont = Context({'departments': department_list})
return HttpResponse(tmpl.render(cont))
在此，您添加了一个简单视图（实际上是一个名为 index 的函数），它将填充部门列表 (department_list)，其中仅包括那些具有经理的部门（这意味着，必须填写基础表中的 manager_id 字段）。然后，该视图加载 index.html 模板（将在&创建表示层&部分中讨论），并向其传递 department_list 以便呈现。最后，向 Django 返回包含 HttpResponse 对象的已呈现页面。
在此，最有趣的部分是从 departments 模型中获取数据。请注意 departments 模型类的 objects 属性的用法。通过此属性，您可以访问 models.Manager 对象（不要将它与 departments 模型中定义的 manager 字段混淆）。models.Manager 对象会附加到模型对象中，提供可让您在模型的基础表中查询数据的方法。这些方法将返回一个 QuerySet 对象，其中包含以模型对象的形式检索的数据库数据。QuerySet 对象还提供一组有用的方法，允许您进一步处理返回的模型对象。需要注意的是，一些 QuerySet 方法会返回新的 QuerySet 对象，而其他方法仅对现有 QuerySet 进行求值，然后根据此求值返回一些信息。可以在 Django 文档的 QuerySet API 参考页面上找到完整的 QuerySet 方法列表。
在此讨论的示例中，models.Manager 的 exclude 方法用于将检索的 departments 对象仅限于那些具有相关 employees 对象的对象。然后，QuerySet 的 order_by 方法返回按 departments.manager.employee_id 字段排序的新 QuerySet 对象。它类似于以下 Oracle SQL 查询：
SELECT * FROM departments WHERE manager_id IS NOT NULL ORDER BY manager_
除了此处使用的 exclude 方法之外，您还可以通过 objects 属性调用其他三种方法来查询模型数据。清单如下：
all & 返回包含所有从模型基础表中获取的模型对象的 QuerySet。
filter & 返回仅包含那些与指定条件匹配的模型对象的 QuerySet。
exclude & 返回包含与指定条件不匹配的模型对象的 QuerySet。
get & 返回与指定条件匹配的单个模型对象。
由于 employees HR 表中的员工 ID 从 100 开始，因此在上一示例中，您可以用 filter 替代 exclude 以便使用数据填充 department_list，如下所示：
department_list = departments.objects.filter(manager__employee_id__gte = 100).order_by('manager__employee_id')
与原始版本一样，要考虑到在 departments 和 employees 模型之间定义的多对一关系（之讨论过），在此情况下，SQL 对应物可能基于 departments 表查询，如下所示：
SELECT * FROM departments WHERE manager_id &= 100 ORDER BY manager_
此处讨论的所有模型查询方法（all 方法除外）都采用查找参数以缩小检索模型对象的结果集。因此，在上述示例中，您结合使用以下查找参数和 filter 方法来查询 departments 对象：
manager__employee_id__gte = 100
您可能已经猜到，上述查找参数适合以下模式：field__subfield__lookuptype=value，其中参数由双下划线分隔的关键字组成。在此，manager 是引用 employees 对象的 departments 模型的字段。而 employee_id 是 employees 模型的字段。gte 是表示大于或等于的标准字段查找。可以在此示例中使用上述组合，因为 departments 和 employees 模型通过多对一关系关联。然而，当查询非相关数据时，您应使用以下模式：field__lookuptype=value。例如，为了获得 employee_id 为 100 的 employees 对象，您可以按如下方式查询 employees 模型：
emp = employees.objects.get(employee_id__exact = 100)
实际上，您可能需要发出包含复杂 select 列表和/或复杂 WHERE 子句的查询。例如，您要根据以下查询获得 employees 对象：
SELECT employees.*, (email||'@') as email_address FROM
您如何告诉 Django 向依赖 employees 模型的查询的 select 列表中添加另一个字段？这就是 QuerySet 方法 extra 能够派上用场的地方。
employee_list = employees.objects.all().extra(select={'email_address': &(email||'@')&})
结果，Django 将自动向此处检索的每个 employees 对象添加 extra 属性 email_address。
当然，您不仅可以使用 extra 方法增强 QuerySet 隐式生成的查询的 select 列表。您还可以指定显式 WHERE 子句并向查询的 FROM 子句添加表，以及提供要绑定到 WHERE 子句中指定的相应占位符的动态参数。以下是您可以传递到 extra 方法的参数列表：
select & 将额外字段添加到 QuerySet 隐式生成的查询的 select 列表
where & 在 QuerySet 查询中指定显式 WHERE 子句
tables & 在 QuerySet 查询的 from 列表中包括其他表
order_by & 按照通过 select 或 tables 参数添加的字段对 QuerySet 进行排序
params & 传入将安全绑定到 WHERE 子句中指定的占位符的动态参数
到目前为止，您已了解说明如何使用 Django 数据库抽象 API 查询基础数据库数据的示例。然而，除了查询之外，您还可以使用 API 创建、更新以及删除数据库数据。
以下代码段说明如何使用此处讨论的 employees 和 departments 模型在 departments 数据库表中创建新的记录：
emp = employees.objects.get(employee_id__exact=100)
new_dept = departments(department_id = 1000, department_name = 'test', manager = emp)
new_dept.save()
结果，应该在 departments 表中显示新行。需要注意的是，model.save 方法还可用于更新现有行：
dept = departments.objects.get(department_id__exact=1000)
dept.department_name = 'new name'
dept.save()
最后，要删除行，请使用 model.delete：
dept = departments.objects.get(department_id__exact=1000)
dept.delete()
默认情况下，Django 使用自动提交事务模式。这意味着，它可立即提交通过数据更改模型方法（例如上一部分中的 model.save 和 model.delete）进行的更改。但是，您可以使用 django.db.transaction 模块提供的事务修饰程序，针对特定视图函数更改此默认行为。您具有以下三个选项：
@transaction.autocommit（默认）
@mit_on_success
@mit_manually
例如，您可能指示 Django 在视图函数内使用单个事务，并在最后仅当此函数成功返回时提交，如下所示：
from django.http import HttpResponse
from myproj.myapp.models import employees, departments
from django.http import Http404
from django.db import transaction
@mit_on_success
def newdept(request, emp_id, dept_id, dept_name):
new_dept = departments(department_id = dept_id, department_name = dept_name, manager = None)
new_dept.save()
emp = employees.objects.get(employee_id__exact = emp_id)
new_dept.manager = emp
new_dept.save()
except employees.DoesNotExist:
raise Http404
return HttpResponse(&The %s department record has been inserted.& %dept_name)
上述 newdept 视图函数仅当成功返回时才自动提交在其内执行的所有操作。如果引发异常，则回滚所有未定更改。但是，如果您删除 newdept 视图函数前面的修饰词或者用 @transaction.autocommit 替代此修饰词，事务行为将发生更改。如果无法找到指定员工，仍将产生 HTTP 404 异常。但此时，第一个 new_dept.save 进行的更改将立即提交到数据库，产生 manager_id 字段为空的部门记录。
需要注意的是，上面列出的代码可以通过 django.shortcuts 模块中定义的 get_object_or_404 函数大大简化。修改如下所示：
from django.shortcuts import get_object_or_404
@mit_on_success
def newdept(request, emp_id, dept_name, dept_id):
new_dept = departments(department_id = dept_id, department_name = dept_name, manager = None)
new_dept.save()
emp = get_object_or_404(employees, employee_id__exact = emp_id)
new_dept.manager = emp
new_dept.save()
return HttpResponse(&The %s department record has been inserted.& %dept_name )
然而，如果您已选择 commit_manually 修饰程序，则不会选择上述语法。在这种情况下，您需要分别使用 mit 或 transaction.rollback 显式提交或回滚事务。因此，try-except 语法似乎更适用于这种情况：
from django.db import transaction
@mit_manually
def newdept(request, emp_id, dept_id, dept_name):
new_dept = departments(department_id = dept_id, department_name = dept_name, manager = None)
new_dept.save()
emp = employees.objects.get(employee_id__exact = emp_id)
new_dept.manager = emp
new_dept.save()
except employees.DoesNotExist:
transaction.rollback()
raise Http404
return HttpResponse(&The %s department record has been inserted.& %dept_name)
将上述 newdept 视图添加到 myproj/myapp/views.py 中。
创建表示层
如上所述，Django 模板旨在使用 django.template.Context 对象在视图中显示传递给它们的信息。回到在前面的&使用数据库抽象 API&部分中讨论的 index 视图函数，让我们创建在此视图中使用的模板 index.html。
首先，在 myapp 目录内创建一个名为 templates 的目录。默认情况下，这是 Django 查找模板的目录。然后，在 myapp/templates 目录内创建 index.html，并将以下代码插入文件中：
&h1&Managers of departments&/h1&
&table border = 1px cellpadding=&3& style=&font-family:Arial&&
&th&empid&/th&
&th&first name&/th&
&th&first name&/th&
&th&email&/th&
&th&department name&/th&
{% for department in departments %}
&td&{{department.manager.employee_id}}&/td&
&td&{{department.manager.first_name}}&/td&
&td&{{department.manager.last_name}}&/td&
&td&{{department.manager.email}}&/td&
&td&{{department.department_name}}&/td&
{% endfor %}
模板中的代码非常简单。您使用标准 HTML 标记定义标题和表元素，嵌入 Django 的模板语言元素，这些语言元素的变量标记位于双花括号 {{ ..}} 中，而块标记位于 {% ..%} 对中。要了解有关 Django 模板语言的更多信息，您可以参阅 Django 文档中的&The Django template language&页面。
对于此处讨论的 Django 应用程序，最后一个难题是 URLconf，它应该包含传入请求与视图函数匹配的 URL 模式。虽然您可以完全在项目级别定义这些模式，但将应用程序的 URL 从项目的配置中分离出来被认为是个较好的做法。因此，按如下方式编辑 myproj 目录中的 urls.py 文件：
urlpatterns = patterns('',
url(r'^myapp/', include('myproj.myapp.urls')),
然后，在 myapp 目录中创建 urls.py 文件，并将以下代码插入其中：
from django.conf.urls.defaults import *
from myapp.views import index, newdept
urlpatterns = patterns('',
url(r'^(?P&emp_id&\d+)/(?P&dept_name&\w+)/(?P&dept_id&\d+)/$' , newdept),
url(r'^$', index),
您可能已经猜到，第一种模式旨在处理向&事务管理&部分中讨论的 newdept 视图发出的请求，第二种模式用于向 index 视图发出的请求。
使用 Django 开发 Web 服务器
现在该测试您刚构建的 Django 应用程序了。为此，您可以使用 Django 的内置开发 Web 服务器。首先，从操作系统提示符进入 myproj 目录，并发出以下命令：
manage.py runserver
结果，您应该看到一些告知您开发服务器正在运行的输出行，以及此服务器所在的地址（默认情况下，应该为 http://127.0.0.1:8000/）。剩下的就是将您的浏览器指向 http://127.0.0.1:8000/myapp/。结果应该如下图所示：
要测试 newdept 视图，您可以在 Web 浏览器中输入以下 url：http://localhost:8000/myapp/100/test/1000/。这应该将新记录插入 departments 表中，此记录的 department_id 为 1000，department_name 为 test，manager_id 为 100。
将 Django 用于 Apache
Django 的内置开发 Web 服务器仅适用于测试，这意味着它并不是生产服务器。如果要将它用于生产，您需要慎重考虑。
您可以通过 mod_python 模块（用于在 Apache 内嵌入 Python）将 Django 部署到 Apache。因此，首先确保您已将 mod_python 模块安装到 Apache 服务器上（可以在
找到详细信息）。然后，您可以将以下 Location 块添加到 Apache 的 httpd.conf 配置文件中（在 PythonPath 中使用实际路径）：
& Location &/myapp/&&
SetHandler python-program
PythonPath &['/home/user/myprojects', '/home/user/myprojects/myproj'] + sys.path&
PythonHandler django.core.handlers.modpython
SetEnv DJANGO_SETTINGS_MODULE myproj.settings
PythonDebug On
& /Location&
重新启动 Apache 之后，您就可以测试应用程序了。如果您的 Apache 服务器在 localhost 上运行，您可以将浏览器指向 http://localhost/myapp/ 以测试 index 视图，指向 http://localhost/myapp/100/test/1000/ 以查看 newdept 是否正常工作。
正如您在本文中了解的那样，Django 是一个功能强大的 Web 框架，可让您迅速创建数据库驱动的 Web 应用程序。您还可以轻而易举地将 Django 连接到 Oracle 数据库。此外，Django 还具有绝佳的 ORM 特性。
Yuli Vasiliev 是一名软件开发人员、自由撰稿人和顾问，目前专攻开源开发、Java 技术、数据库和面向服务的体系结构 (SOA)。他撰写了
Beginning Database-Driven Application Development in Java EE:Using GlassFish（Apress，2008）和
PHP Oracle Web Development（Packt，2007）。
客户与活动
服务与商店
电话: 800-810-8-6698