In this final part of the series I’m going to look at one further way we can use Boost.Python to help when using a C++ class within Python.
In the previous part we built a wrapper for a C++ class, exposing a number of class methods to Python.
However, in Python, it’s quite typical for a class to use properties as well as methods.
So to begin – let’s take a moment to look at properties within the context of classes in Python.
For example, if we had a Python class which looks like this:
def __init__ (self):
self._data = None
def set_data(self, data):
self._data = data
We could then use it, something like this:
s = example.simple()
Whilst this works, we might reasonably say that the necessity to use getter and setter functions directly is not especially Pythonic – as it’s not how most built-in objects behave.
Instead we’d expect to be able to use it more like this:
s.data = 7
We can do exactly this; if we use properties…
Continue reading “Advanced C++ / Python integration with Boost.Python (Part 3)”
Last time we looked at how to use Boost.Python to wrap a very simple piece of C++ code. This time we’re going to take that one step further along, and do the same thing for a more complex C++ example – which includes a C++ Class.
For the purposes of this example – let us assume that we have a “legacy” C++ class (i.e. one that we’re not going to change): which looks something like this:
unsigned char* exporter();
void set_data(uint8_t, uint8_t, uint8_t);
void importer(unsigned char*, int);
This (deliberately, slightly contrived) class has three methods (and a constructor). We can set the three 8-bit unsigned integers (
uint8_t) directly using the
set_data() method; we can print the data to the screen; or we can either import from or export to an
In order to be able to use the importer & exporter methods with Python (via Boost.Python) we’ll need to further wrap these – as Boost.Python won’t let us use
unsigned char* directly.
Continue reading “Advanced C++ / Python integration with Boost.Python (Part 2)”
In a previous post, I described how you could use the ctypes Python library to import a C++ class to make it usable from within Python. There is however, another way to do this; and that’s by using Boost.Python (which as the name suggests is a part of the Boost C++ library suite).
Whilst this method makes our code on the C++ side slightly more complicated; it significantly simplifies the Python code – and it let’s us use some more powerful features.
To begin let’s start with a simple example.
char const* greet()
return "hello, world";
std::string multi_bob(int n)
std::string name = "Bob";
std::string r = "";
for (int i=0;i<n;i++)
r += name;
using namespace boost::python;
Everything above the
BOOST_PYTHON_MODULE line is perfectly ordinary C++ code. The clever bit comes in when we call the
BOOST_PYTHON_MODULE macro (which is defined within the Boost.Python header)…
In this case we’re creating a Python module – with two methods: one based on our very simple
greet() function (which we’re also going to call
greet); and one based on the more complex
multi_bob(int) function. Note that for this second function, to show the fact that the linkage between the C++ & Python code can be very flexible, we give it a different name on the Python side. Also note that we don’t need to tell the macro about the signature of the function as this is handled for us by Boost.Python.
Continue reading “Advanced C++ / Python integration with Boost.Python”
I recently found myself needing to call a C++ class from within Python. I didn’t want to call a separate process (as I had previously when using Thrift – see Using Apache Thrift for Python & C++); but rather to call a C++ library directly.
Before I go on I should say that there are a lot of different ways to do this is Python – and I’ve picked one that worked for me. Other techniques are available – and opinion seems quite divided as to which (if any) technique is ‘best’.
Continue reading “Calling C++ Classes from Python, with ctypes…”
Last time we looked at how to write a server application in C++, and call it from Python. This time, we’ll do things the other way around: implementing a service in Python, and calling from C++.
Continue reading “Apache Thrift Tutorial — Part 2”
Unfortunately, whilst there are quite a few tutorials on how to use Thrift: some of them concentrate on explaining how Thrift is working behind the scenes (which is important, of course): rather than on how to use it. There also aren’t that many that concentrate on using C++. So having spent some time working through some of the tutorials (and the book Learning Apache Thrift), I though I’d have a go at writing something of a practical guide. I’m quite deliberately not going to focus on how Thrift works: if you want that, let me suggest the Apache Thrift – Quick Tutorial. I’m also going to assume that you have Thrift installed on your computer already (again, there are lots of sets of instruction on how to do this — Google will be your friend), and that you’re using a Linux or MacOS computer. You should be able to follow-along with most of this if you’re using Windows: but there will be a few differences, especially when it comes to compiling C++ files.
Continue reading “Using Apache Thrift for Python & C++”