I want to extend a large C project with some new functionality, but I really want to write it in Python. Basically, I want to call Python code from C code. However, Python->C wrappers like SWIG a... More on stackoverflow.com

Hi, as the title suggests, the question is whether there is a possibility to call a scripted python module from C++, and if yes, how to do that. More on discourse.slicer.org

Here’s a different thought to the many suggestions: I like to think of Python as basically a macro/glue language over C. It has really good integration to bring C code into Python. So, why not approach your problem the other way? See Python as the “main” application, which does some slow sting processing, and has some dedicated C functions for fast offload? In general I find this a better structure to make the most of both language’s strengths. More on reddit.com

Writing a c-extension for python is not as hard as it looks, the basics are: Setup the module properties using 'PyModuleDef' Setup the funcion properties using 'PyMethodDef' From your c-function deparse the python arguments, eg PyArg_ParseTuple When your ready to return a value package it up a python object Py_BuildValue There is nothing wrong with writing c-extensions for python, especially for interfaces you already have implemented in C. In fact someone once said that "c is syntactic sugar for memory and cpu", I'll add to that and say "python is syntacti sugar for c". ABelow is an annotated template I use when I need to interface with C. Build instructions at the end. This file a a compendium from sources like this and this #include /* Function 1: A simple 'hello world' The function needs to be static as its scope should be limited only to this file and it should return a PyObject exposed to our program via the Python.h header file. The wrapper function name will contain two arguments, both of type PyObject with the first being a pointer to self and the second a pointer to the args passed to the function via the calling Python code. */ static PyObject* helloworld(PyObject* self, PyObject* args) { printf("Hello World\n"); return Py_None; } /* Example 2: Fibonacci This function uses PyArgs_ParseTuple to unpack arguments, and Py_BuildValue to return python basic types. Both of these take argument specifiers: The below table shows what I feel are the more commonly used format specifiers. Specifier C Type Description ----------- ---------- --------------------------------------------- c char Python string of length 1 converted to C char s char array Python string converted to C char array d double Python float converted to a C double f float Python float converted to a C float i int Python int converted to a C int l long Python int converted to a C long o PyObject* Python object converted to a C PyObject How do arguments work? ---------------------- If you are passing multiple arguments to a function which are to be unpacked and coerced into C types, then you simply use multiple specifiers such as:: PyArg_ParseTuple(args, "si", &charVar, &intVar). How do return types work? ------------------------- Py_BuildValue uses format specifiers very similar to how PyArg_ParseTuple(...) uses them, just in the opposite direction. Py_BuildValue also allows for returning our familiar Python data structures such as tuples and dicts. In this wrapper function I will be returning an int to Python, which I implement as follows: Wrapper Code Returned to Python ----------------------------------------- ------------------ Py_BuildValue("s", "A") "A" Py_BuildValue("i", 10) 10 Py_BuildValue("(iii)", 1, 2, 3) (1, 2, 3) Py_BuildValue("{si,si}", "a', 4, "b", 9) {"a": 4, "b": 9} Py_BuildValue("") None */ int calc_fib(int n) { if(n < 2) { return n; } else { return calc_fib(n-1)+calc_fib(n-2); } } static PyObject* fib(PyObject* self, PyObject* args) { int n; if(!PyArg_ParseTuple(args, "i", &n)) return NULL; return Py_BuildValue("i", calc_fib(n)); } // Function table // -------------- // // Our Module's Function Definition struct. We require this `NULL` to signal // the end of our method definition. // // static PyMethodDef func_table[] = { { "helloworld", helloworld, METH_NOARGS, "Prints Hello World" }, { "fib", fib, METH_VARARGS, "Calculates fib number" }, { NULL, NULL, 0, NULL } }; // Our Module Definition // --------------------- // // Here I will provide a module definition which associates the previously // defined DemoLib_FunctionsTable array to the module. This struct is also // responsible for defining the name of the module that is exposed in Python // as well as giving a module-level doc string. static struct PyModuleDef myModule = { PyModuleDef_HEAD_INIT, "myModule", "Test Module", -1, func_table }; // Initializes our module using module struct // ------------------------------------------ // // The last C-ish bit of code to write is the module's initialization function, // which is the only non-static member of the wrapper code. This function has a // very particular naming convention of PyInit_name where name is the name of // the module. This function is invoked in the Python interpreter, which // creates the module and makes it accessible. PyMODINIT_FUNC PyInit_myModule(void) { return PyModule_Create(&myModule); } // Final Steps // ----------- // // Create a setup.py with the following code:: // // from distutils.core import setup, Extension // setup(name = 'myModule', version = '1.0', \ // ext_modules = [Extension('myModule', ['test.c'])]) // // And build and install with:: // // $ python setup.py build // $ python setup.py install // // No run with:: // // $ python // >>> import myModule // >>> myModule.fib(10) // 55 // // // More on reddit.com