A Brief Look at Mod_Python

Python’s Apache interpreter is available as an Apache module, mod_python. This module reduces the time it takes to deliver a given page to a client. It is also capable of a great deal more, including interacting with Apache itself in various powerful ways. This article gives you just a taste of what mod_python can do.


You enter in an address, requesting a page from Apache. It’s not just any old page, though. It’s a CGI script written in Python. A few moments later, you’re staring at the results. However, what exactly does Apache do with your request? As with all CGI scripts, Apache spawns a new process – in this case, the Python interpreter – and then spits out that process’ output. It works, but it isn’t the fastest way, nor is it the most efficient way.

Other languages have presented different solutions to this problem. Languages such as PHP have embedded their interpreters into Apache. Other languages, such as Perl, offer Apache modules (in Perl’s case, mod_perl) that do this. These “other languages” include Python, though not enough people realize this.

This article deals with Python’s own module for Apache, mod_python, and the benefits it provides to both man and machine.

A Quick Look at Mod_Python

As I stated eariler, mod_python embeds the Python interpreter into Apache. This reduces the time needed to deliver a given page to a client. Starting the Python interpreter, waiting for it to finish executing, and then catching its output not only takes time, but it takes up valuable resources as well.

This, however, is not the only benefit provided by mod_python. Mod_python can interact with Apache, giving you extraordinary power. You can change the way Apache handles tasks and utilize the Apache API.

Languages that can be embedded straight into HTML, such as PHP, are very popular. CGI does not allow this. However, mod_python does. You’ve seen Java Server Pages (JSP) and Active Server Pages (ASP); this article will introduce you to Python Server Pages (PSP).

Interesting? Yes. Let’s move on.

{mospagebreak title=Installing Mod_Python}

First, head on over to the mod_python website:


Download the latest version for your platform.

To install mod_python on a Unix enviroment, you perform the usual ritual:

$ ./configure
$ make
$ su
# make install

You may, however, need to help the configure script out a bit by pointing it to apxs (which is included with Apache and is needed to compile mod_python) or Python itself:

$ ./configure -with apxs=/some/strange/place/apxs -with-python=/some/strange/place/apxs

With Windows, things are easier. Although mod_python’s official site no longer offers an easy installation option for Windows, a gentleman by the name of Nicolas Lehuen provides one on his website:


You can download it here:


Install it, and you’re almost good to go.

You’ll then need to configure Apache (on either platform). Load  httpd.conf into your favorite text editor. Add this:

LoadModule python_module libexec/mod_python.so

If you used the Windows installer I mentioned, use this instead:

LoadModule python_module modules/mod_python.so

Failing both of those, try searching for the location of mod_python.

We’ll have to set mod_python as the handler for Python files. Add this to httpd.conf:

AddHandler python-program .py

Finally, we must give .htaccess a bit of power. Search httpd.conf for the string “AllowOverride” set it to “All.” You should end up with this:

AllowOverride All

{mospagebreak title=Getting Started}

I’m sure many of you are coming from a CGI background and have several CGI scripts sitting around. Fortunately for you, mod_python can emulate a CGI enviroment and run your old scripts. Create a directory called pycgi. Create a .htaccess file and add this to it:

PythonHandler mod_python.cgihandler

We’ll now create a simple “CGI” script:

import cgi
formData = cgi.FieldStorage()
if ‘name’ in formData:
name = formData [ ‘name’ ].value
   name = ‘John Doe’

print ‘Content-type: text/html’
print ‘Hello, ‘, name + ‘.’

You should not, however, rely on this method. It has a few problems, and mod_python offers much more efficient methods of doings things, as I explained at the beginning of the article. Let’s not waste a perfectly good Apache module on CGI emulation.

Instead, we’ll move on to mod_python’s publisher handler. The publisher handler allows us to easily deliver Python powered pages to clients. Instead of having a separate page for everything, mod_python’s publisher handler allows us to have a Python function for everything.

Create a directory named pypublish. We’ll use this to play around with the publisher handler. Create a .htaccess file with this in it:

PythonHandler mod_python.publisher

Now create a file named test.py and fill it with this:

def index():
   return “This is only a test.”
def peyton():
   return “Peyton wrote this.”

Obviously, it contains two functions. Let’s see how those functions relate to the script’s output. Open up your Web browser and head over to the page you just created:


As you can see, the index function is executed, and the results are delivered to you. Now let’s try something different. Append “/peyton” to the URL:


The peyton function is now executed. This interesting feature can be convenient in developing applications.

Now let’s make a script that is a bit more complicated. Let’s process data from a form – a task vital to functional websites. We’ll create a form that asks for the reader’s favorite color, the time he or she woke up and his or her favorite language. All this will go in the index function. When the form is submitted, the data will be sent to the process function to be made pretty and displayed. Create a file appropriately named form.py:

def index():
  out = “<form method=’POST’ action=’form.py/process’>”
 out = out + “What is your favorite color?<br>”
  out = out + “<input type=’text’ name=’color’><br>”
  out = out + “What time did you wake up this morning?<br>”
  out = out + “<input type=’text’ name=’waket’><br>”
  out = out + “What is your favorite language?<br>”
  out = out + “<select name=’flang’><option>Python</option></select><br>”
  out = out + “<input type=’submit’ value=’Process’>”
  out = out + “</form>”
  return out
def process ( color, waket, flang ):
  return “Your favorite color is ” + color + “, you woke up at ” + waket + ” and you like ” + flang + “.”

The index functon contains no suprises. It just displays form data, so I won’t bother going into detail there. The process function, however, is a bit different. As you can see, it takes three arguments. Notice that the three arguments correspond to the names of the form fields. The way the publisher handler handles this is pretty interesting. Try switching around the arguments or even taking out a few (just remember to take out the variable in the return statement, too). The function still executes fine. The publisher handler automatically puts in the correct arguments. Pretty neat, huh?

{mospagebreak title=Creating Handlers and Working with the API}

I stated earlier in the article that it is possible to change the way Apache does things. This is done through handlers. Apache does its work in steps, or phases. Each of these steps can be performed by a handler. Mod_python registers a handler for each step, which can be populated by Python instructions.

This feature of mod_python is rather interesting, and we can do things with it that are equally as interesting. Let’s say we want to change the way text documents are viewed, putting the document inside a pretty layout. We can do this by creating a handler that takes over at the stage where content is gathered and delivered to the user. This might sound a bit confusing, so it’s best for me to show you rather than tell you. Create a directory named pyhandler and drop this inside its .htaccess file:

AddHandler mod_python .txt
PythonHandler headerfooter

This tells Apache that .txt files are to be handled by mod_python. It then tells mod_python that the file headerfooter.py should be called to handle the .txt files. Create headerfooter.py and add this to it:

from mod_python import apache

def handler ( request ):
  request.content_type = ‘text/html’
  request.write ( “<html>” )
  request.write ( “<head>” )
  request.write ( “<title>Text Document</title>” )
  request.write ( “</head>” )
  request.write ( “<body bgcolor=’#D2D2D2′>” )
  request.write ( “<table align=’center’ bgcolor=’#000000′ cellspacing=’1px’ cellpadding=’5px’ width=’60%’>” )
  request.write ( “<tr><td bgcolor=’#FFFFFF’ align=’center’>” )
  request.write ( file ( request.filename ).read().replace( ‘n’, ‘<br>’ ) )
  request.write ( “</td></tr>” )
  request.write ( “</table>” )
  request.write ( “</body>” )
  request.write ( “</html>” )
  return apache.OK

That’s quite a mouthful, so let’s break it down. The first line imports the module apache. This allows us to interact with Apache. We then define a method, handler, that accepts one parameter, request. The request object contains information about (drumroll please) the request.

The next line’s function is a bit more obvious. We send out the content type of the page. We then print out a layout using the write method and print the contents of the text file, whose name is contained in the filename method of the request object. We then tell Apache that everything went fine.

{mospagebreak title=Python Server Pages}

Now I’ll introduce Python Server Pages. Languages like PHP have been made popular due to their ability to be embedded directly into HTML. Python Server Pages allow Python code to be embedded into HTML pages. Python Server Pages aren’t terribly difficult to understand, and I believe showing you would be a lot better than telling you, so we’ll jump right in. Create a directory named pypsp, and add this to its .htaccess file:

AddHandler mod_python.psp
PythonHandler mod_python.psp

Now let’s get into some code. Python code is enclosed between less-than and greater-than signs, postfixed and prefixed with percent signs. For example:

<% # Python code here %>

You can also print out single items by putting an equal sign in, just as you would with PHP:


Here an example:

# Import a Module
import math
<title>Python Server Pages Test</title>
The square root of 25 is <%=math.sqrt ( 25 )%>. The square root of 50 is <%=math.sqrt ( 50 )%>.

Save it as test.psp and point your browser to it. Interesting, eh?


As you’ve seen throughout this article, mod_python is a very powerful addition to the Apache Web server. It allows control over even Apache itself through handlers, which are easily created with mod_python. The publisher handle and the psp handle make Web development in Python a lot easier than it already is, and allow it to better compete with popular Web development languages such as PHP and ASP.

What this article outlines is definitely not all of mod_python. Mod_python contains much more power than this article can tell about, but that power is the topic of another article on another day. Until then, good luck.

[gp-comments width="770" linklove="off" ]

chat sex hikayeleri Ensest hikaye