使用C ++和Python访问数组

Question

I am working on a simulation of a mini-galaxy consisting of about a 100,000 stars. The visual representation I want to do in Python, the large calculations in C++. Using ctypes, I am able to call a C++ function from Python.

What I basicly want is an array that is there in the RAM, that can be accessed both by python and C++. Then upon calling a function update() in python, C++ updates the array. It is important that C++ really only changes the values in the array. Copying it all the time would become quite time consuming.

I am quite a beginner, especially in C++, So I don't really know where to find the right information, and what keywords to use. Thoughts on how to do it are of course welcome, but some informational links would also be greatly appreciated.

Best,

Answer 1

You can build C++ python wrapper module using the python C/C++ API:

https://docs.python.org/2/extending/extending.html

I would create a C++ module ( dataUpdater ) using python API offering a service, lets call it, update which should receive the Python object you want to load data into.

At your Python side I would call dataUpdater.update whenever I want to load the data from C++

EDIT:

Other option is to make your C++ module to behave like a data structure offering data access services such as:

• getValueAt(index)
• setValueAt(index)
• getSize()

And using it at python side:

for i in xrange(dataUpdater.getSize()):
    val = dataUpdater.getValueAt(i)
    ...

Answer 2

You should totally check the Python documentation on this issue:

https://docs.python.org/2/extending/

Having the doc in mind you can define a new Type; assuming that stars would be a double precision array:

typedef struct {
    PyObject_HEAD
    double * Stars;
} Galaxy;

Then define the Math operations method ... (python doc)

static PyObject* Galaxy_calc(Galaxy *self, PyObject *args)
{
     double * Star_temp;   

     /* Your Array is referenced by self->Stars*/
     Star_temp = self->Stars;

     /* Do the math in C++ */
     // All necessary calculations go here.
};

It is fairly easy to include these methods in the new type defined (Galaxy), you just have to set the variables:

static PyMethodDef Galaxy_methods[] = 
{
    {"calc", (PyCFunction)Galaxy_calc, METH_VARARGS,"Performs stelar calculations."},
    {NULL}  /* Sentinel */
};


static PyMemberDef Galaxy_members[] = 
{    {"Stars", T_OBJECT_EX, offsetof(Galaxy, Galaxy), 0, "Galaxy Stars"},
    {NULL}  /* Sentinel */
};

Now just include the Galaxy_methods var on the adequate position under

static PyTypeObject Galaxy_GalaxyType = {
    PyObject_HEAD_INIT(NULL)
    0,                         /*ob_size*/
    "Galaxy.Galaxy ",           /*tp_name*/
    sizeof(Galaxy),            /*tp_basicsize*/
    0,                         /*tp_itemsize*/
    (destructor)Galaxy_dealloc, /*tp_dealloc*/
    0,                         /*tp_print*/
    0,                         /*tp_getattr*/
    0,                         /*tp_setattr*/
    0,                         /*tp_compare*/
    0,                         /*tp_repr*/
    0,                         /*tp_as_number*/
    0,                         /*tp_as_sequence*/
    0,                         /*tp_as_mapping*/
    0,                         /*tp_hash */
    0,                         /*tp_call*/
    0,                         /*tp_str*/
    0,                         /*tp_getattro*/
    0,                         /*tp_setattro*/
    0,                         /*tp_as_buffer*/
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,          /*tp_flags*/
    "Galaxy objects",          /* tp_doc */
    0,                         /* tp_traverse */
    0,                         /* tp_clear */
    0,                         /* tp_richcompare */
    0,                         /* tp_weaklistoffset */
    0,                         /* tp_iter */
    0,                         /* tp_iternext */
    Galaxy_methods,            /* tp_methods */
    Galaxy_members,            /* tp_members */
    0,                         /* tp_getset */
    0,                         /* tp_base */
    0,                         /* tp_dict */
    0,                         /* tp_descr_get */
    0,                         /* tp_descr_set */
    0,                         /* tp_dictoffset */
   (initproc)Galaxy_init,      /* tp_init */
    0,                         /* tp_alloc */
    Galaxy_new,                /* tp_new */
};

Use python documentation refered above to implement new, alloc, dealloc and init methods (these are quite simple) and it is done!

Answer 3

Doing this correctly is actually quite complicated. First, you should use the package numpy for the array in Python. Then, you would define a C interface, as described in https://docs.python.org/2/c-api/ . (This is a reference manual, so you may want to read, and experiment with https://docs.python.org/2/extending/index.html first.) Most importantly, you will want to use the buffer interface ( https://docs.python.org/2/c-api/buffer.html#bufferobjects ) to access the numpy arrays.

ctypes seems to have some support for contiguous arrays as well, but I've no experience with it. If you do any processing of the arrays on the Python side, however, you'll want to use numpy , which I don't think ctypes will support.

Answer 4

Here is how another proposal on how to accomplish this task, using Boost.Python.

Let's organize the code in 3 files: a setup.py to take care of compiling the extension code, a Python script that just uses the extension code, and the extension code itself:

.
├── galaxy.cpp
├── main.py
└── setup.py

galaxy.cpp : note that exceptions are not handled, so you can produce a segmentation fault by assigning to a Star that has not been initialized, and other C++ oddities. If you modify this code, take care to always name the BOOST_PYTHON_MODULE as the file itself.

#include <vector>

#include <boost/python.hpp>

class Star {
public:
    Star(double mass): mass(mass) {}

    bool set_mass(double given_mass) {
        this->mass = given_mass;
        return true;
    }
private:
    double mass;
};

class Galaxy {
public:
    Galaxy(const boost::python::list& masses) {
        for (size_t i = 0; i < len(masses); i++) {
            double mass = boost::python::extract<double>(masses[i]);
            stars.push_back(Star(mass));
        }
    }

    bool update(int star_number, double mass) {
        return this->stars[star_number].set_mass(mass);
    }

private:
    std::vector<Star> stars;
};

BOOST_PYTHON_MODULE(galaxy)
{
    using namespace boost::python;
    class_<Galaxy>("Galaxy", init< boost::python::list >())
        .def("update", &Galaxy::update)
    ;
}

setup.py : note that Boost has been installed on my machine using Macports; you may need to adjust the path where it can be found, in the include_dirs variable.

from distutils.core import setup
from distutils.extension import Extension

setup(name="galaxies",
      ext_modules=[
          Extension(
              "galaxy", ["galaxy.cpp"],
              include_dirs=["/opt/local/include"],
              libraries=["boost_python-mt"])])

Finally, use the Galaxy object to do whatever you need in main.py . Note that in this example the object is constructed from a Python list (which means you are actually passing the array at least once between Python and C++), but this is not a must: you can have the C++ code read a file of data, and just pass its path from Python.

import galaxy

sombrero = galaxy.Galaxy([0.1, 22.3, 33.4])
sombrero.update(0, 24.5)

Here is how to compile and run the example:

$ python setup.py build_ext --inplace && python main.py

Answer 5

And there is always this:

http://www.boost.org/doc/libs/1_55_0/libs/python/doc/

"Welcome to version 2 of Boost.Python, a C++ library which enables seamless interoperability between C++ and the Python programming language."