mod_python is similar to (and inspired by) mod_perl : It embeds Python within Apache and loads Python code into memory when the server starts. Code stays in memory throughout the life of an Apache process, which leads to significant performance gains over other server arrangements.

Django requires Apache 2.x and mod_python 3.x, and you should use Apache’s prefork MPM, as opposed to the worker MPM.

You may also be interested in How to use Django with FastCGI, SCGI or AJP (which also covers SCGI and AJP).

<Location "/mysite/">

SetHandler python-program

PythonHandler django.core.handlers.modpython

SetEnv DJANGO_SETTINGS_MODULE mysite.settings

PythonOption django.root /mysite

PythonDebug On

</Location>

<Location "/mysite/">

SetHandler python-program

PythonHandler django.core.handlers.modpython

SetEnv DJANGO_SETTINGS_MODULE mysite.settings

PythonOption django.root /mysite

PythonDebug On

PythonPath "['/path/to/project'] + sys.path"

</Location>

PythonPath "['/usr/local/django-apps/', '/var/www'] + sys.path"

PythonPath "['c:/path/to/project'] + sys.path"

NameVirtualHost *



<VirtualHost *>

ServerName www.example.com

# ...

SetEnv DJANGO_SETTINGS_MODULE mysite.settings

</VirtualHost>



<VirtualHost *>

ServerName www2.example.com

# ...

SetEnv DJANGO_SETTINGS_MODULE mysite.other_settings

</VirtualHost>

<VirtualHost *>

ServerName www.example.com

# ...

<Location "/something">

SetEnv DJANGO_SETTINGS_MODULE mysite.settings

PythonInterpreter mysite

</Location>



<Location "/otherthing">

SetEnv DJANGO_SETTINGS_MODULE mysite.other_settings

PythonInterpreter othersite

</Location>

</VirtualHost>

assert False, the_value_i_want_to_see

<Location "/media">

SetHandler None

</Location>

<Location "/">

SetHandler python-program

PythonHandler django.core.handlers.modpython

SetEnv DJANGO_SETTINGS_MODULE mysite.settings

</Location>



<Location "/media">

SetHandler None

</Location>



<LocationMatch "".(jpg|gif|png)$">

SetHandler None

</LocationMatch>

import os

os.environ['PYTHON_EGG_CACHE'] = '/some/directory'

PythonInterpreter my_django

PythonImport /path/to/my/project/file.py my_django

File "/tmp/easy_install-nHSsgl/MySQL-python-1.2.2/setup_posix.py", line 26, in mysql_config

EnvironmentError: mysql_config not found



后来发现是由于Mysql编译安装后没有 mysql_config这个值，解决方法：

打开 setup_posix.py, 将其中line：26手动改成系统中对应的Mysql选项（这里我的是/usr/local/mysql）：

mysql_config = /usr/local/mysql/bin/mysql_config



重新执行 ：python setup.py build，没有了刚才的错误，但是出现了另外一个错误：

error： /usr/bin/ld: cannot find -lmysqlclient



网上搜索了一下这个错误，发现有几种不同的情况，主要有以下几个原因：

1.没有安装mysqlclient。解决方法：找到对应的版本进行安装。

2.安装的mysqlclient的版本不匹配。对应链接： http://www.hao32.com/webserver/258.html

3.已经安装了对应的mysqlclient但是找不到对应的链接。这是在一个国外的网站上看到的，具体网址已经找不到了，后来那位仁兄将对应的

mysql_home/lib/mysql文件夹下面libmysqlclient对应的文件全部拷贝到/usr/local/lib下面才解决了问题。



按照对应方案，问题解决。

重新执行： 

python setup.py build

python setup.py install

安装完成。

This article is not about teaching you how to program in Python, nor how to use the Django framework. It’s about showing how to promote your Django applications onto an existing Apache or Lighttpd environment.

We will conclude with a simple way that you can improve the performance of your Django application by using caching to speed up access time. This article also assumes that you are running Fedora as your web application server, but all the packages mentioned in this article are also available under the Extra Packages for Enterprise Linux repository , which means these instructions should also be valid under Red Hat Enterprise Linux or CentOS servers.

What you need

You must have Django installed:

# yum install Django

If you want to serve Django apps under Apache:

# yum install httpd

# yum install mod_python

If you want to serve Django apps under Lighttpd:

# yum install lighttpd

# yum install lighttpd-fastcgi

# yum install python-flup

Installing memcached to ’speed up’ Django apps:

# yum install memcached

# yum install python-memcached

Starting a new Django project

1. Create a development workspace.

$ mkdir -p $LOCATION_TO_YOUR_DEV_AREA

$ cd $LOCATION_TO_YOUR_DEV_AREA

2. Start a new base Django project. This creates the boiler plate project structure.

$ django-admin.py startproject my_app

3. Start the Django development web server on port 8080 (or whatever other port you’d like).

Note: The development web server is just for testing and verification. Do not use it as a production application server!

$ python manage.py runserver 8080

4. Run your Django project under Apache with mod_python by enabling mod_python on httpd.conf (/etc/httpd/conf/httpd.conf).

After installing mod_python, a file called python.conf should already be placed in /etc/httpd/conf.d/, which enables mod_python on your system.

5. Create virtual hosts by creating a new file at /etc/httpd/conf.d/myapp.conf.

 



DocumentRoot /var/www/html/

ServerName your_domain_name

ErrorLog logs/my_app-error.log

CustomLog logs/my_app-access_log common 





SetHandler python-program

PythonHandler django.core.handlers.modpython

SetEnv DJANGO_SETTINGS_MODULE my_app.settings

PythonDebug On

PythonPath “[’/var/www/django/’] + sys.path”

  



 

Running your Django project under Lighthttpd with fastcgi

The first thing you must do is start up your FastCGI server.

./manage.py runfcgi method=prefork socket=/var/www/myapp.sock pidfile=django_myapp.pid

Then modify your lighttpd.conf file to use the FastCGI server.

server.document-root = "/var/www/django/"

fastcgi.server = (

"/my_app.fcgi" => (

"main" => (

# Use host / port instead of socket for TCP fastcgi

# "host" => "127.0.0.1",

# "port" => 3033,

"socket" => "/var/www/my_app.sock",

"check-local" => "disable",

)

),

)

alias.url = (

"/media/" => "/var/www/django/media/",

)



url.rewrite-once = (

"^(/media.*)$" => "$1",

"^/favicon.ico$" => "/media/favicon.ico",

"^(/.*)$" => "/my_app.fcgi$1",

)

Setting up caching in Django

Django has many different caching backends, including database, memory, filesystem, and the ever popular memcached. According to http://www.danga.com/memcached/, memcached is “a high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load.” It’s used by high traffic sites such as Slashdot and Wikipedia. This makes it a prime candidate for caching in your cool new web app.

First, verify that memcached is running using the memcached’s init script.

$ /etc/init.d/memcached status

memcached (pid 6771) is running... 

If it’s not running, you can manually start it.

$ /sbin/service memcached start

If you want to make sure it will automatically start every time after a reboot:

$ /sbin/chkconfig --level 35 memcached on 

Now that you have verified that memcached is running, you will want to tell your Django application to use memcached as it’s caching backend. You can do this by adding a CACHE_BACKEND entry to your settings.py file.

CACHE_BACKEND = 'memcached://127.0.0.1:11211/'

The format is “backend://host:port/” or “backend:///path” depending on the backend chosen. Since we are using memcached, we have the option to run multiple daemons on different servers and share the cache across multiple machines. If you want to do this all you must do is add in the servers:port combinations in the CACHE_BACKEND and separate them by semicolons. In this example we share the cache across three different memcached servers:

CACHE_BACKEND = 'memcached://127.0.0.1:11211;192.168.0.10:11211;192.168.0.11/'

For more information on the different types of caching that can be performed in the Django framework, please refer to their official documentation.

• Apache 2
• MySQL
• mod_python
• Python (2.4)

For the record, I'm running all of this off of OpenSuSE 10.1 - so obligatory YMMV. Please comment with suggestions or problems if so, though.

First off, make sure you've got Apache up and running. ps aux | grep httpd can tell ya for the most part. If you don't know how to do this much, though, I'm afraid you're reading the wrong tutorial.

Step 1: Install mod_python

This will vary pretty widely amongst distributions, but our goal was to have a package manager do it. One of the below will probably work for you:

• SuSE: In YaST, search for mod_python in Software Management
• Ubuntu/Debian/apt-based: apt-get install libapache2-mod-python2.4
• Redhat/FC4: yum install mod_python

Step 2: Install Django

So with mod_python installed, now we can get to Django. We have been tracking along with Subversion up until now, but since we're getting ready to put a large (for us) site into production, we are planning on sticking with numbered releases, but it remains to be seen if we'll change our minds on that one in order to take advantage of the enhancements that continue to stream in. If you want to live closer to the edge, you can get the development trunk through subversion.

Note that the last command will automatically download and install 'setuptools' if you don't already have it installed.

Step 3: Create a Project

So assuming everything went well, (It did, didn't it?), we're ready to start our first django project. Start your first project by going into the directory you want to hold your django projects (preferably outside of your web document root), and typing:

As the djangoproject.com tutorial says…

django-admin.py should be on your system path if you installed Django via python setup.py. If it's not on your path, you can find it in site-packages/django/bin, where site-packages is a directory within your Python installation. Consider symlinking to django-admin.py from some place on your path, such as /usr/local/bin.

This will start you off with the basic settings and files needed for your django project. But we're not done quite yet! We have to tell apache what to do to handle mod_python requests.

Step 4: Configure Apache

To get apache to handle python requests, we first need to activate mod_python. Again, this is one of those things that will vary pretty widely through distributions, but essentially you'll need this command in Apache's httpd.conf file:

(note: Purportedly on debian this is done for you automatically - so you will likely be able to skip this step)
In OpenSuSE the best way to do this is to go into YaST-> Sysconfig Editor-> Network-> WWW-> Apache2, and append 'python' onto the APACHE_MODULES setting. There may be other ways to do this more painlessly than file editing in other distro's, as well. Let me know if there are and I will update this section.

Now that apache knows about python, we have to tell it where to -use- python. So go into your httpd.conf file (if you're using virtual hosts, pick the appropriate virtual host config file) and add this location directive:

Now save, restart apache, and browse to your server + /myProject (i.e., http://www.yourhost.com/myProject).

Did it come up with a special looking 404 error? If so, you've got Django installed, man! Better go follow the more informative and better written Django Tutorial to see how to really get rolling with it - you're ready to start developing!

1、下载需要模块。

a、apache (httpd-2.0.54.tar.gz or later)
b、mod_python (mod_python-3.3.1.tgz)
c、Django (Django-0.96.tar.gz)

默认已安装 Python (http://www.python.org)

2、安装配置环境。

首先，正常安装 apache 和 mod_python (http://www.modpython.org/),注意要打开 apache 的 DSO 功能，执行：

#...
#tar -zxvf httpd-2.0.54.tar.gz
#cd httpd-2.0.54
#./configure --prefix=/usr/local/apache2 --enable-so --enable-mods-shared=all
#make install clean
#...
#tar -zxvf mod_python-3.3.1.tgz
#cd mod_python-3.3.1
#./configure --with-apxs=/usr/local/apache2/bin/apxs --with-python=/usr/local/bin/python
#make install clean
#...
#tar -zxvf Django-0.96.tar.gz
#cd Django-0.96
#python setup.py install (If you installed Django using setup.py install, uninstalling is as simple as deleting the django directory from your Python site-packages.)
#...

这 样我们就安装好 Apache + mod_python + Django 了，你可以执行 apachectl start 测试一下能不能成功。然后我们开始配置环境，首先配置 httpd.conf 加入 LoadModule python_module modules/mod_python.so (在安装 mod_python 的时候安装程序会自动把 mod_python.so 拷贝到 apache 的 modules 目录下)，接着配置虚拟主机。

到这里你就可以利用 mod_python 来进行编程了，然后我们来配置一下 Django 并通过一个实例来让大家对这个现今最 HOT 的 python web 框架有一个大体的了解：首先，我们来学习一下用 django-admin.py 工具来简化你的工作 (当我们安装 Django 的时候，安装程序会自动把 django-admin.py 拷贝到 系统 PATH 下，所以我们可以直接使用它)。首先进入到我们的 python 程序目录 (我用的是：{DOCUMENT_ROOT}/python),执行：

#django-admin.py startproject newtest

这样就可以生成我们的测试工程了默认情况下会生成 {DOCUMENT_ROOT}/python/newtest 目录，该目录下会有如下文件：

__init__.py (表示这是一个 Python 的包)
manage.py (提供简单化的 django-admin.py 命令，特别是可以自动进行 DJANGO_SETTINGS_MODULES 和 PYTHONPATH 的处理，而没有这个命令，处理上面环境变量是件麻烦的事情)
settings.py (它是django的配置文件)
uls.py (url映射处理文件， Karrigell 没有这种机制，它通过目录/文件/方法来自动对应，而 Django 的url映射是url对于某个模块方法的映射，目前不能自动完成)

然后我们在 apache 的虚拟主机配置文件里面加上：

<Location "/newtest/">
SetHandler python-program
PythonPath "sys.path+['{DOCUMENT_ROOT}/python']"
PythonHandler django.core.handlers.modpython
SetEnv DJANGO_SETTINGS_MODULE newtest.settings
#PythonInterpreter mysite
PythonDebug On
</Location>

这 里要注意的是对于 PythonPath，必须设置成工程目录 ({DOCUMENT_ROOT}/python/newtest) 的上一级目录！这样我们就完成了 Django 和 apache 的整合了，赶快试一下吧，我们写一个 action 来测试一下 Django 的功能：

3、编写测试程序。

1> 首先，创建 ./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})

2> 然后，创建一个模版文件 ./templates/list.html :

<h2>通讯录</h2>
<table border="1">
<tr><th>姓名</th><th>地址</th></tr>
{% for user in address %}
<tr>
<td>{{ user.name }}</td>
<td>{{ user.address }}</td>
</tr>
{% endfor %}
</table>

3> 设置模版目录 (编辑 ./settings.py) :

TEMPLATE_DIRS = (
# Put strings here, like "/home/html/django_templates".
# Always use forward slashes, even on Windows.
'./templates',
)

4> 修改 urls.py :

from django.conf.urls.defaults import *

urlpatterns = patterns('',
# Example:
# (r'^newtest/', include('newtest.foo.urls')),
(r'^newtest/list/$', 'newtest.list.index'),

# Uncomment this for admin:
# (r'^admin/', include('django.contrib.admin.urls')),
)

5> 重启 Apache 并访问相应 url (http://localhost/newtest/list/) 即可看到结果页面了：

通讯录
姓名 地址
张三 地址一
李四 地址二

到这里，你已经掌握了 Django 框架的基本内容了，就可以进一步学习 Django 的其他内容了，Enjoy It ：）

2. 安装python 2.5
从官网上下载2.5版本，Python-2.5.2.tgz，解压缩后./configure, make , make install.就可以完成安装。默认安装目录为/usr/local/lib/python2.5/
3. 安装mod_python.
./configure –with-apxs=/usr/local/apache2/bin/apxs –with-python=/usr/bin/python2.5，再make， make install 即可。安装完毕后会在目录/usr/local/apache2/modules下有文件mod_python.so，这个在后面要使用到。
4. 安装django 1.0
从官网下 载1.0版本Django-1.0.tar.gz,解压缩，使用命令python setup.py install 安装，注意，如果机器里有以前的版本，一定要把以前的版本文件完全卸载活删除，django 不会覆盖以前的文件。默认安装目录为/usr/local/lib/python2.5/site-packages/django/
5.安装sqlite
这里使用到的数据库为sqlite3，所以要安装相应的包，这里 从官网下载pysqlite-2.3.5.tar.gz,安装很容易。
6.配置文件.
这里使用了最简单的配置方法，直接修改/usr/local/apache2/conf/httpd.conf
(1) ,默认端口，80，可以不修改。
(2) 在有LoadModule example字样的下面添加一下一行
LoadModule python_module modules/mod_python.so
(3) 配置ServerName，在有 #ServerName www.example.com:80字样的下面添加一下行：
ServerName yourIP:80
(4) 这是最重要的一步了。在有字样# This should be changed to whatever you set DocumentRoot to.的后面，修改<Directory> … </Directory>中间的内容为：

<Directory “/home/af/af“>
#
# Possible values for the Options directive are “None”, “All”,
# or any combination of:
#   Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews
#
# Note that “MultiViews” must be named *explicitly* — “Options All”
# doesn’t give it to you.
#
# The Options directive is both complicated and important. Please see
# http://httpd.apache.org/docs/2.2/mod/core.html#options
# for more information.
#
#Options Indexes FollowSymLinks
#PythonHandler django.core.handlers.modpython
PythonPath “['/home/af/af','/usr/local/lib/python2.5/site-packages'] + sys.path”
PythonHandler django.core.handlers.modpython
SetEnv DJANGO_SETTINGS_MODULE aftest.settings
SetHandler python-program
PythonDebug On
#
# AllowOverride controls what directives may be placed in .htaccess files.
# It can be “All”, “None”, or any combination of the keywords:
#   Options FileInfo AuthConfig Limit
#
#AllowOverride None

#
# Controls who can get stuff from this server.
#
#Order allow,deny
Allow from all

</Directory>

其中蓝色部分为要修改和添加的部分，/home/af/af是Django 工程所在的目录，aftest为项目名称。
(5)添加media。这里以安装Django自己提供的admin为例。
在上一步的</Directory>下面再添加
Alias /media /usr/local/lib/python2.5/site-packages/django/contrib/admin/media
<Location “/media”>
Options None
SetHandler None
Allow from all
</Location>
即可。

配置完毕。

from django.utils.httpwrappers import HttpResponse

from PIL import Image



import random

INK = "red", "blue", "green", "yellow"



def image(request):



# ... create/load image here ...

image = Image.new("RGB", (800, 600), random.choice(INK))



# serialize to HTTP response

response = HttpResponse(mimetype="image/png")

image.save(response, "PNG")

return response

To draw things on the fly, you can use either PIL’s ImageDraw module, or the aggdraw module:

from django.utils.httpwrappers import HttpResponse

from PIL import Image

from aggdraw import Draw, Pen, Brush, Font



import random



def graphics(request):



image = Image.new("RGB", (800, 600), "white")

draw = Draw(image)



# ... draw graphics here ...

for i in range(20):

x0 = random.randint(0, image.size[0])

y0 = random.randint(0, image.size[1])

x1 = random.randint(0, image.size[0])

y1 = random.randint(0, image.size[1])

draw.rectangle((x0, y0, x1, y1), Pen(random.choice(INK), 5))



draw.flush()



response = HttpResponse(mimetype="image/png")

image.save(response, "PNG")

return response

from django.db import models

# Create your models here.
class Person(models.Model): 
        name = models.CharField(max_length=10) 
        height = models.SmallIntegerField() 
    class Meta:
        abstract=True
  

class Man(Person): 
        job = models.CharField(max_length=20) 


class Woman(Person): 
        makeup = models.CharField(max_length=20) 

BEGIN;
CREATE TABLE `sample_woman` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `name` varchar(10) NOT NULL,
    `height` smallint NOT NULL,
    `makeup` varchar(20) NOT NULL
)
;
CREATE TABLE `sample_man` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `name` varchar(10) NOT NULL,
    `height` smallint NOT NULL,
    `job` varchar(20) NOT NULL
)
;
COMMIT;

from django.db import models

# Create your models here.
class Person(models.Model): 
        name = models.CharField(max_length=10) 
        height = models.SmallIntegerField() 


class Man(Person): 
        job = models.CharField(max_length=20) 


class Woman(Person): 
        makeup = models.CharField(max_length=20) 

BEGIN;
CREATE TABLE `sample_person` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `name` varchar(10) NOT NULL,
    `height` smallint NOT NULL
)
;
CREATE TABLE `sample_woman` (
    `person_ptr_id` integer NOT NULL UNIQUE PRIMARY KEY,
    `makeup` varchar(20) NOT NULL
)
;
ALTER TABLE `sample_woman` ADD CONSTRAINT person_ptr_id_refs_id_4baa7c33 FOREIGN
 KEY (`person_ptr_id`) REFERENCES `sample_person` (`id`);
CREATE TABLE `sample_man` (
    `person_ptr_id` integer NOT NULL UNIQUE PRIMARY KEY,
    `job` varchar(20) NOT NULL
)
;
ALTER TABLE `sample_man` ADD CONSTRAINT person_ptr_id_refs_id_78ed52db FOREIGN K
EY (`person_ptr_id`) REFERENCES `sample_person` (`id`);
CREATE UNIQUE INDEX `sample_woman_person_ptr_id` ON `sample_woman` (`person_ptr_
id`);
CREATE UNIQUE INDEX `sample_man_person_ptr_id` ON `sample_man` (`person_ptr_id`)
;
COMMIT;

Person类可以进行数据查询操作，所以有必要识别返回的类是什么的问题，这里isinstance没用，django的处理是为Person添加子类的属性，以方便你通过这些属性访问具体的子类，在这里
results=Person.objects.all()
r=results[0]
这个r就有woman和man两个属性，下面的结论摘自我在邮件列表中的答复，备忘用

这时，person_obj有 man和person两个属性 
如果访问一个不是属于该类型的就会出现DoesNotExist 异常 
实际中，不用通过捕获异常去判断，直接用 
hasattr(person_obj,'man') 或 hasattr(person_obj,'woman') 就可以判断，返回True的就是 
目标类型 

(InteractiveConsole) 


>>> from sample.models import * 
>>> results=Person.objects.all() 
>>> r=results[0] 
>>> hasattr(r,'woman') 
False 
>>> hasattr(r,'man') 
True 
>>> r.man.job 
u'computer' 
>>> r.woman 


Traceback (most recent call last): 
  File "

 
  File "C:"Python25"Lib"site-packages"django"db"models"fields 
"related.py", line 
178, in __get__ 
    rel_obj = self.related.model._default_manager.get(**params) 
  File "C:"Python25"Lib"site-packages"django"db"models"manager.py", 
line 82, in 
get 
    return self.get_query_set().get(*args, **kwargs) 
  File "C:"Python25"Lib"site-packages"django"db"models"query.py", line 
197, in g 
et 
    % self.model._meta.object_name) 
DoesNotExist: Woman matching query does not exist. 

谈谈django中图片上传的2种处理方式

    首先申明该文使用的django 版本为svn 版本，我每天都在更新 ，python 是2.5，pil 也是最新的版本。

    通常情况下用django上传图片我们会定义一个django.forms.Form的子类，比如：

Python代码

1. # coding: utf-8  
2.   
3. import django.forms as forms  
4.   
5. class PictureForm(forms.Form):   
6.     # ......     
7.     # 图片  
8.     imagefile = forms.ImageField()  
9.     # ......  

# coding: utf-8
import django.forms as forms
class PictureForm(forms.Form):
# ......
# 图片
imagefile = forms.ImageField()
# ......

     然后我们在服务端会定义一个函数来处理图片上传，我们先来看看一般的做法：

Python代码

1. # coding: utf-8  
2.   
3. from django.http import HttpResponse  
4.   
5. def addPicture(request):  
6.     if request.method == 'POST':  
7.         form = PictureForm(request.POST, request.FILES)  
8.         if form.is_valid():  
9.             f = request.FILES["imagefile"]  
10.             # des_origin_path 为你在服务器上保存原始图片的文件物理路径  
11.             des_origin_f = open(des_origin_path, "ab")  
12.             for chunk in f.chunks():  
13.                 des_origin_f.write(chunk)  
14.             des_origin_f.close()  
15.               
16.             # 图片文件被保存在硬盘上后，你可以用pil的Image.open打开进行处理，比如改变大小，加水印等等  

# coding: utf-8
from django.http import HttpResponse
def addPicture(request):
if request.method == 'POST':
form = PictureForm(request.POST, request.FILES)
if form.is_valid():
f = request.FILES["imagefile"]
# des_origin_path 为你在服务器上保存原始图片的文件物理路径
des_origin_f = open(des_origin_path, "ab")
for chunk in f.chunks():
des_origin_f.write(chunk)
des_origin_f.close()
# 图片文件被保存在硬盘上后，你可以用pil的Image.open打开进行处理，比如改变大小，加水印等等

     在上面这种传统的做法中，是把图片文件保存到硬盘上后，再由pil图形库从硬盘上加载，再进行图片处理，明显多了很多的硬盘IO操作，如果你是一个图片处理量很大的应用，显然不想看到这样的局面。那我们来看看另外一个做法：

Python代码

1. # coding: utf-8  
2.   
3. from django.http import HttpResponse  
4. import ImageFile  
5.   
6. def addPicture(request):  
7.     if request.method == 'POST':  
8.         form = PictureForm(request.POST, request.FILES)  
9.         if form.is_valid():  
10.             f = request.FILES["imagefile"]  
11.             parser = ImageFile.Parser()  
12.             for chunk in f.chunks():  
13.                 parser.feed(chunk)  
14.             img = parser.close()  
15.             # 在img被保存之前，可以进行图片的各种操作，在各种操作完成后，在进行一次写操作  
16.             img.save("yoursavepath")  

# coding: utf-8
from django.http import HttpResponse
import ImageFile
def addPicture(request):
if request.method == 'POST':
form = PictureForm(request.POST, request.FILES)
if form.is_valid():
f = request.FILES["imagefile"]
parser = ImageFile.Parser()
for chunk in f.chunks():
parser.feed(chunk)
img = parser.close()
# 在img被保存之前，可以进行图片的各种操作，在各种操作完成后，在进行一次写操作
img.save("yoursavepath")

     在上面的做法中，我们利用pil的ImageFile直接从django接收的数据流中构建出图形对象，进行处理后，在保存，减少了硬盘的读操作。现在网 上有些例子使用StringIO对象来作为pil Image.open的输入，经过我多次尝试，在ubuntu以及winxp、centos上都要报异常，我想可能跟pil的版本有关，或许以前的低版本 pil的确可以处理。

• Code snippet posted on Djangosnippets. The file is saved by declaring a save() method in the form class. This method is invoked when calling form.save(), which is standard Django newforms practice. (Note that this snipped uses clean_data. As of Django version 0.96, clean_data has been renamed to cleaned_data, so you will have to change the code or it won’t work)
• Django image upload and validation. The author uses a model for the file and its related data. The uploaded file is saved by calling the save_FOO_file method. (This method is automatically provided by Django for fields declared as models.ImageField or models.FileField in the model. See the db-api documentation.)
• Django image upload, form_for_instance and monkey-patching. The example code creates a form class from request.user by calling form_for_instance. The resulting class in then monkey-patched to insert the avatar image validation code. (Although the code is interesting the monkey patch seems unnecessary. I wouldn’t mind inserting the avatar validation method in a UserProfileForm class derived from form.Forms. The code would be certainly clearer: I think KISS takes precedence over DRY in this case.)

Interesting, there seems to be no easy way of limiting the uploaded file size. The file can be rejected at validation time, but the data would have already been transfered.

A file upload recipe

After reading those posts, I think that a good recipe for handling file uploads in Django would be:

• Write a django model for the uploaded file and its related data. Using a Django model makes sense, because it is usually necessary for the application to keep track of the uploaded files.
• Write a subclass of form.Forms and declare a clean_FOO method for each models.FileInput or models.ImageInput fields declared in the model class. These clean_FOO methods are used to validate the uploaded files.
• use a django view to receive the POST data, or display the form if no data is posted or errors are found.
• validate the uploaded file or files by triggering the standard django newforms validation mechanism: is_valid().
• save the file or files getting the data directly from the request.FILES object, by writing a save() method for the subclassed form or by calling save_FOO_file for the model instance.

A simpler way to upload a file

The following short Django example uses no data models, does no data validation, and saves the file directly to disk using python standard file functions. It is just a simple test I wrote to get familiar with the request.FILES object. This is not production code: it could be used to execute an arbitrary script on the server.
The directory where the file is to be saved must be writable by the user that is running the Django server script. (The example uses MEDIA_ROOT as defined in settings.py.)

file: views.py

file: fileupload.html

     下面将开发环境的安装配置过程写下来，供后来者参考。

一、安装Eclipse SDK。

到 http://download.eclipse.org/eclipse/downloads/ 找SDK最新的Release版本，最新的版本是 3.3.2

下载。一开始我选择的是台湾的[Taiwan] National Center for High-Performance Computing (http) ，速度只有5kB/s，还是小日本的快，118kB/S,， Japan Advanced Institute of Science and Technology (http) ，做事情应该也这样，一个明显很缓慢，就要当即力断换其他的。

下载完毕之后，将eclipse SDK解压到某个目录下，我的放在e:"eclipse就可以了。

如果要使用中文的，最好是使用跟SDK配套的语言包，否则也不能完全汉化（最后我选择了纯英文的，没汉化）。根据网上的资料，汉化前不要启动Eclipse，否则不能完全汉化。将语言包也解压到同一目录下即可。

二、安装Pydev

到 http://sourceforge.net/projects/pydev/ 这里找最新版本下载，最新版本是1.3.15

下 载后解压，将plugins目录下所有文件挪到Eclipse的相应目录下，将feature目录下所有文件挪到Eclipse的相应目录下，最后启动 Eclipse，在Help－》Software Upates－》Manage Configuration，然后弹出的界面即可看到pydev的插件。

另一种安装插件的方法是：Help－》Software Upates－》Find and Install－》Search for new features to install-》New remote site－》随便起个name如pydev，url填 http://pydev.sf.net/updates/ －》然后照着提示下载安装即可。

两种方法我都尝试了一下，为保险起见，我选择的是第二种方法。

三 、Pydev的配置
在Eclipse IDE 下， 打开 Window->Preferences... 对话框，从右侧的树形列表中选择“ PyDev”->“Interpreter Python”， 点击New按钮，从Python的安装路径下选择Python.exe，然后会弹出一个对话框让你勾选System PYTHONPATH，我是都选了，应该无所谓。最后点Ok，退出。

四、进行Django项目开发

1、建立PyDev Project

Eclipse IDE－》File－》New－》Other－》Pydev－》选择Pydev Project－》起一个项目的名称（例如demo）－》选择路径，如E:"work－》选择适合你的Python版本（我的是2.5）－》将下面的勾去掉，不要建立src文件－》Finish

2、建立Django Project

（1）django-admin.py startproject demo。

（2） 把生成的Django项目目录拷贝到Eclipse刚刚建立的项目下的目录里。回到刚才的Elicpse IDE－》在PyDev Package视图中右键单击新建的项目，从弹出的菜单中选择“Refresh”，即可看到Django的项目工程。添加、删除文件和目录的操作都可以通 过右键菜单来完成。

(3)右键单击PyDev项目－》属性－》选择PyDev－》PYTHONPATH－》然后将src目录 (项目文件路径） 添加到项目代码中去－》确定

（4）对Pydev项目进行配置： 选择Pydev的项目名称－》Run菜单－》Open Run Dialog－》Python Run－》右键New－》在Main面板中写入项目名称，通过Browse载入项目名称和Main Module，Main Module选择manage.py－》在Augement面板中,argument必须是 runserver --noreload，下面的working directory加入你的base directory。

打完收工，接下来开始写Django应用吧。

最后补一个用SourceInsight看Python工程的方法：
1、到http://www.sourceinsight.com/public/languages/下载Python.CLF文件，这是python的语言支持包。
2、打开SourceInsight->Options > Preferences －> Languages －> Import －> Select (.CLF)
3、再做的：－> Document Types - > Add Type (Give it a name : 填Python－>.给出类型名：我填的是*.py ) 在下面的下拉框里面选择之前导入的文件，然后确定。Source Insight 就可以识别该类型的文件了。

• Go to Window->Preferences->Preferences->PyDev->Python Interpretter and add the django source file to the PYTHONPATH settings.
• Create a new PyDev pyhon project. Make sure you uncheck the ‘create src folder’ option.
• Create project on the command line using django e.g. django-admin.py startproject mysite
• In your newly created project directory create a src directory in it, and move the django generated source files here
• In eclipse, right-click your project and select refresh
• Right-click on the project and select Properties->PyDev – PYTHONPATH, and add your src folder to the project source settings

That should be it. I still get red underlines on the Django source imports even thought PyDev seems to know about them – to test this is working properly, open up your urls.py file and ctrl click on the patterns call – it should take you to defaults.py.

Now you can go ahead and create your database & super user.

Launching to built-in server

Open up manage.py and hit F9. This should print out the usage information for the server. To actually start the server, select Run->Run…, and in the Arguments tab for manage.py enter runserver—noreload. The noreload argument gives you output.

Thanks go to PyDev creator Fabio Zadrozny for his guide which got me going.