Beginning Python - From Novice to Professional

370 CHAPTER 17 ■ EXTENDING PYTHON
/* An initialization function for the module (the name is
significant): */
PyMODINIT_FUNC initpalindrome() {
Py_InitModule("palindrome", PalindromeMethods);
}
Most of the added stuff in Listing 17-6 is total boilerplate. Where you see palindrome, you
could insert the name of your module, while where you see is_palindrome, insert the name of
your function. If you have more functions, simply list them all in the PyMethodDef array. One
thing is worth noting, though: The name of the initialization function must be initmodule,
where module is the name of your module; otherwise, Python won’t find it.
So, let’s compile! You do this just like in the section on SWIG, except that there is only one
file to deal with now. Here is an example using gcc (remember to add -fPIC in Solaris):
gcc -I$PYTHON_HOME -I$PYTHON_HOME/Include -shared palindrome2.c -o palindrome.so
Again, you should have a file called palindrome.so, ready for your use. Put it somewhere in
your PYTHONPATH (such as the current directory) and away we go:
>>> from palindrome import is_palindrome
>>> is_palindrome('foobar')
0
>>> is_palindrome('deified')
1
And that’s it. Now go play. (But be careful; remember the Waldi Ravens quote from the
Introduction.)
A Quick Summary
Extending Python is a huge subject. The tiny glimpse provided by this chapter included the
following:
Extension philosophy. Python extensions are useful mainly for two things: for using
existing (legacy) code, or for speeding up bottlenecks. If you’re writing your own code
from scratch, try to prototype it in Python, find the bottlenecks, and factor them out as
extensions if needed. Encapsulating potential bottlenecks beforehand can be useful.
Jython and IronPython. Extending these implementations of Python is quite easy: You
simply implement your extension as a library in the underlying implementation (Java for
Jython and C# or some other .NET language for IronPython) and immediately the code is
usable in your Python.
Extension approaches. There are plenty of tools for extending or speeding up your code:
for making the incorporation of C code into your Python program easier, for speeding up
common operations such as numeric array manipulation, or for speeding up Python itself.
Such tools includ SWIG, Psyco, Pyrex, Weave, NumPy, ctypes, subprocess, and modulator.