Interfacing C++ with Python to boost your legacy apps with Python interfaces

Interfacing C/C++ with
Python
Ovidiu Farauanu
Iasi C/C++ Developers Meetup
15.01.2025

Embedding Python in C/C++
- Python is an old language and conservative language, but still very popular (TIOBE language of the
year 2024, 2021, 2020, 2018, …)
- Python can be easily embedded into C/C++ applications or other technologies that expose a C-based
FFI
- In principle it works more or less the same way as when Lua or JavaScript are embedded (except Lua is
not refcounted but stack based)
- We won’t use any C++ specific API, the Python API is a C level API; C++ wrappers can be created
- Valid only for the CPython implementation (pypy requires cpyext to use the CPython C API)

Fundamentals
- Python.h header is the include entry point and contains several other header files that define all the
interfaces used to interact with the Python code
- The PyObject structure is the cornerstone of the Python’s object system enabling Python’s dynamic
object model
- Official documentation: https://docs.python.org/3.8/c-api/index.html

Environment variables
PYTHONHOME - Change the location of the standard Python libraries.
PYTHONPATH - Augment the default search path for module files.
export PYTHONHOME=/c/msys64/mingw64
export PYTHONPATH="$SCRIPT_DIR:/c/msys64/mingw64/lib/python3.11"

Functions
Py_Initialize - Initialize the Python interpreter. In an application embedding Python, this should be called
before using any other Python/C API functions
Py_Finalize - Undo all initializations made by Py_Initialize() and subsequent use of Python/C API
functions, and destroy all sub-interpreters
Py_IsInitialized - Return true (nonzero) when the Python interpreter has been initialized, false (zero) if not.
After Py_FinalizeEx() is called, this returns false until Py_Initialize() is called again.
PyRun_SimpleString - Executes the Python source code from command in the __main__ module
PyImport_ImportModule - Import a module. This is best described by referring to the built-in Python function
__import__().

# simple.py
def plus(a, b):
return a + b

#include <Python.h>
int main(int argc, char const *argv[])
{
// Initialize python access
Py_Initialize();
// Import the simple.py code
PyObject* module = PyImport_ImportModule("simple");

Functions
PyObject_GetAttrString - Retrieve an attribute named attr_name from object o.
PyCallable_Check - Determine if the object o is callable. Return 1 if the object is callable and 0 otherwise. This
function always succeeds.
PyTuple_New - Return a new tuple object of size len, or NULL on failure.
PyTuple_SetItem - Insert a reference to object o at position pos of the tuple pointed to by p.
PyObject_CallObject - Call a callable Python object callable, with arguments given by the tuple args
PyLong_AsLong - Return a C long representation of obj.
Py_DECREF - Decrement the reference count for object o.

// Access the attribute named plus
PyObject* func = PyObject_GetAttrString(module, "plus");
// Make sure the attribute is callable
if (func && PyCallable_Check(func)) {
// Create a tuple to contain the function's args
PyObject* args = PyTuple_New(2);
PyTuple_SetItem(args, 0, PyLong_FromLong(4));
PyTuple_SetItem(args, 1, PyLong_FromLong(7));
// Execute the plus function in simple.py
PyObject* ret = PyObject_CallObject(func, args);
Py_DECREF(args);
Py_DECREF(func);
Py_DECREF(module);

// Convert the value to long and print
long retVal = PyLong_AsLong(ret);
std::cout << "Result: " << retVal << std::endl;
// prints ‘Result: 11’

g++ -I${PYTHON_INC} main.cpp -L/c/msys64/mingw64/lib -lpython3.11
# required to be able to load python modules from the current folder
SCRIPT_DIR=$(dirname "$(realpath "$0")")
EXT_DIR=$SCRIPT_DIR/build/lib.mingw_x86_64-cpython-311
export PYTHONHOME=/c/msys64/mingw64
export PYTHONPATH="$SCRIPT_DIR:$EXT_DIR:/c/msys64/mingw64/lib/python3.11"

Functions
PyArg_ParseTuple - Parse the parameters of a function that takes only positional parameters into local
variables.
PyLong_FromLong - Return a new PyLongObject object from a C long long, or NULL on failure.
PyModule_Create - Create a new module object, given the definition in def.

// A simple function: adds two numbers
static PyObject* example_add(PyObject* self, PyObject* args) {
int a, b;
// Parse the input tuple
if (!PyArg_ParseTuple(args, "ii", &a, &b)) {
return NULL;
}
// Return the sum
return PyLong_FromLong(a + b);
}
Create a Python Extension

// Method definitions
static PyMethodDef ExampleMethods[] = {
{"add", example_add, METH_VARARGS, "Add two integers."},
{NULL, NULL, 0, NULL} // Sentinel
};

// Module definition
static struct PyModuleDef examplemodule = {
PyModuleDef_HEAD_INIT,
"example", // Name of the module
NULL, // Module documentation (optional)
-1, // Size of per-interpreter state (-1 if no state)
ExampleMethods
};

// Module initialization function
PyMODINIT_FUNC PyInit_example(void) {
return PyModule_Create(&examplemodule);
}

# setup.py
from setuptools import setup, Extension
module = Extension(
"example",
sources=["examplemodule.c"],
extra_compile_args=["-std=c99"], # GCC flag for C99 standard
extra_link_args=[],
)
setup(
name="example",
version="1.0",
description="A simple C extension for Python using GCC",
ext_modules=[module],
)

# Build the extension
python setup.py build
# Calling C extension from python code
import example
res = example.add(10, 20)
print(res)

Some extras: C++ wrappers
for the Python module. A good exercise

Some extras: C++ wrappers
The constructor

Interfacing C++ with Python to boost your legacy apps with Python interfaces

More Related Content

Similar to Interfacing C++ with Python to boost your legacy apps with Python interfaces (20)

More from Ovidiu Farauanu (13)

Recently uploaded (20)

Interfacing C++ with Python to boost your legacy apps with Python interfaces