You have a small number of C functions that have been compiled into a shared library

or DLL. You would like to call these functions purely from Python without having to

write additional C code or using a third-party extension tool.

For small problems involving C code, it is often easy enough to use the ctypes module

that is part of Python’s standard library. In order to use ctypes, you must first make

etc.). For the purposes of this recipe, assume that a shared library, libsample.so, has

# sample.py

import ctypes

import os

# Try to locate the .so file in the same directory as this file

_file = 'libsample.so'

_path = os.path.join(*(os.path.split(__file__)[:-1] + (_file,)))

# int gcd(int, int)

gcd = _mod.gcd

gcd.argtypes = (ctypes.c_int, ctypes.c_int)

gcd.restype = ctypes.c_int

# int in_mandel(double, double, int)

in_mandel = _mod.in_mandel

in_mandel.argtypes = (ctypes.c_double, ctypes.c_double, ctypes.c_int)

in_mandel.restype = ctypes.c_int

# int divide(int, int, int *)

def divide(x, y):

rem = ctypes.c_int()

quot = _divide(x, y, rem)

return quot,rem.value

# void avg(double *, int n)

# Cast from array.array objects

def from_array(self, param):

if param.typecode != 'd':

raise TypeError('must be an array of doubles')

ptr, _ = param.buffer_info()

return ctypes.cast(ptr, ctypes.POINTER(ctypes.c_double))

# Cast from lists/tuples

def from_list(self, param):

val = ((ctypes.c_double)*len(param))(*param)

from_tuple = from_list

# Cast from a numpy array

def from_ndarray(self, param):

return param.ctypes.data_as(ctypes.POINTER(ctypes.c_double))

DoubleArray = DoubleArrayType()

_avg = _mod.avg

_avg.argtypes = (DoubleArray, ctypes.c_int)

_avg.restype = ctypes.c_double

def avg(values):

return _avg(values, len(values))

# struct Point { }

class Point(ctypes.Structure):

_fields_ = [('x', ctypes.c_double),

('y', ctypes.c_double)]

# double distance(Point *, Point *)

>>> import sample

>>> sample.gcd(35,42)

>>> sample.in_mandel(0,0,500)

>>> sample.in_mandel(2.0,1.0,500)

>>> sample.divide(42,8)

>>> sample.avg([1,2,3])

>>> p1 = sample.Point(1,2)

>>> p2 = sample.Point(4,5)

>>> sample.distance(p1,p2)

>>>

There are several aspects of this recipe that warrant some discussion. The first issue

concerns the overall packaging of C and Python code together. If you are using ctypes

to access C code that you have compiled yourself, you will need to make sure that the

shared library gets placed in a location where the sample.py module can find it. One

possibility is to put the resulting .so file in the same directory as the supporting Python

code. This is what’s shown at the first part of this recipe—sample.py looks at the __file__

variable to see where it has been installed, and then constructs a path that points to a

libsample.so file in the same directory.

If the C library is going to be installed elsewhere, then you’ll have to adjust the path

accordingly. If the C library is installed as a standard library on your machine, you might

be able to use the ctypes.util.find_library() function. For example:

>>> from ctypes.util import find_library

>>> find_library('m')

>>> find_library('pthread')

>>> find_library('sample')

>>>

Again, ctypes won’t work at all if it can’t locate the library with the C code. Thus, you’ll

need to spend a few minutes thinking about how you want to install things.

Once you know where the C library is located, you use ctypes.cdll.LoadLibrary()

to load it. The following statement in the solution does this where _path is the full

pathname to the shared library: