+

C extension module using Python

Code # 1:

# include & lt; math.h & gt; 

 

extern int gcd ( int , int ); 

extern int in_mandel ( double x0, double y0, int n); 

extern int divide ( int a, int b, int * remainder); 

extern double avg ( double * a, int n); 

 

typedef struct Point

{

double x, y; 

} Point; 

 

extern double distance (Point * p1, Point * p2); 

The title will match the library that was compiled separately. The code below illustrates the basics of writing extension functions with this assumption.

Code # 2:

# include "Python.h"
# include "sample.h"

 
/ * int gcd (int, int) * /

static PyObject * py_gcd (PyObject * self, PyObject * args)

{

int x, y, result; 

if (! PyArg_ParseTuple ( args, "ii" , & amp; x, & amp; y))

{

return NULL; 

}

result = gcd (x, y); 

return Py_BuildValue ( "i" , result); 

}

 
/ * int division (int, int, int *) * /

static PyObject * py_divide (PyObject * self, PyObject * args)

{

int a, b, quotient, remainder; 

if (! PyArg_ParseTuple ( args, "ii" , & amp; a, & amp; b))

{

return NULL; 

}

quotient = divide (a, b, & amp; remainder); 

return Py_BuildValue ( "(ii)" , quotient, remainder); 

}

Code # 3: Module Method Table and Structure

/ * Module method table * /

static PyMethodDef SampleMethods [] =

{

{ " gcd " , py_gcd, METH_VARARGS, " Greatest common divisor " },

{ "divide " , py_divide, METH_VARARGS, " Integer division " },

{NULL, NULL, 0, NULL}

}; 

 
/ * Modular structure * /

static struct PyModuleDef samplemodule =

{

PyModuleDef_HEAD_INIT,

"sample" , / * module name * /

"A sample module" , / * Document line (can be NULL) * /

- 1, / * Size of the state of each translator or -1 * /

SampleMethods / * Method table * /

}; 

 
/ * Module initialization function * /
PyMODINIT_FUNC

PyInit_sample ( void )

{

return PyModule_Create (& amp; samplemodule); 

}

Code # 4: Create a python file setup.py to build an extension.

# setup.py

from distutils.core import setup, Extension

 

setup (name = ` sample` ,

ext_modules = [

Extension ( `sample` ,

  [ ` pysample.c` ],

include_dirs = [ `/ some / dir` ],

define_macros = [( `FOO` , `1` )],

  undef_macros = [ `BAR ` ],

  library_dirs = [ `/ usr / local / lib` ],

  libraries = [ ` sample` ]

)

]

)

Code No. 5: Now just use python3 buildlib.py build_ext --inplace to build the resulting library.

 bash% python3 setup.py build_ext --inplace running build_ext building `sample` extension gcc -fno-strict-aliasing -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -I / usr / local / include / python3.3m -c pysample.c -o build / temp.macosx -10.6-x86_64-3.3 / pysample.o gcc -bundle -undefined dynamic_lookup build / temp.macosx-10.6-x86_64-3 .3 / pysample.o -L / usr / local / lib -lsample -o sample.so bash% 

The above code will create a shared library named sample.so .

Code # 6:

import sample

 

print ( "gcd =" , sample.gcd ( 35 , 42 ))

 

print ( " distance: " , sample.divide ( 42 , 8 ))

Output:

 gcd = 7 distance = ( 5, 2) 

" Extending and embedding the Python interpreter " — this is Python documentation that you can read before trying to do any handwritten extensions.

In extension modules, functions can be written as shown in the code snippet below.

Code # 4:

static PyObject * py_func (PyObject * self , PyObject * args)

{

...

}

  • PyObject — a C data type that represents any Python object. At a very high level, an extension function is a C function that takes a tuple of Python objects (in PyObject * args ) and returns a new Python object as a result. The self argument of the function is not used for simple extension functions, but comes into play if you want to define new classes or object types in C.
  • Function PyArg_ParseTuple () is used to convert values ​​from Python to C representation. As input, it accepts a format string that specifies the required values, such as "i" for an integer and "d" for double, as well as the addresses of C variables in to put the converted results.
  • Py_BuildValue() is used to create Python objects from C data types. It also accepts format code to indicate the desired type. In extension functions, it is used to return results back to Python. One feature of Py_BuildValue () is that it can create more complex kinds of objects such as tuples and dictionaries.
Get Solution for free from DataCamp guru