boost::python: Python list to std::vector

Question

Finally I\'m able to use std::vector in python using the [] operator. The trick is to simple provide a container in the boost C++ wrapper which handles the internal vector s

Answer 1

Based on the above answers I created an example of accessing python lists in C++ as well as returning a python list from a C++ function:

#include <boost/python.hpp>
#include <string>

namespace py = boost::python;

// dummy class
class drow{
    public:
        std::string word;
        drow(py::list words);
        py::list get_chars();
};

// example of passing python list as argument (to constructor)
drow::drow(py::list l){
    std::string w;
    std::string token;
    for (int i = 0; i < len(l) ; i++){
        token = py::extract<std::string>(l[i]);
        w += token;
    }
    this -> word = w;
}

// example of returning a python list
py::list drow::get_chars(){
    py::list char_vec;
    for (auto c : word){
        char_vec.append(c);
    }
    return char_vec;
}

// binding with python
BOOST_PYTHON_MODULE(drow){
    py::class_<drow>("drow", py::init<py::list>())
        .def("get_chars", &drow::get_chars);
}

For a build example and a test python script take a look here

Thank you Arlaharen & rdesgroppes for the pointers (pun not intended).

Answer 2

To make your C++ method accept Python lists you should use boost::python::list

void massadd(boost::python::list& ns)
{
    for (int i = 0; i < len(ns); ++i)
    {
        add(boost::python::extract<double>(ns[i]));
    }
}

Answer 3

To get automatic conversion from python lists, you have to define a converter, which

1. checks if the list is convertible to your type (i.e. that it is a sequence; additionally, you can also check whether all elements are of required type, but that can be handled in the second step as well)
2. returns the new object, if the first step succeeded; throw exception if a sequence element is not convertible to what you need.

I can't find now anything else than my code, you can copy&paste this template (it is specialized at the end of that file for various contained types).

Answer 4

Here's what I use:

#include <boost/python/stl_iterator.hpp>

namespace py = boost::python;

template< typename T >
inline
std::vector< T > to_std_vector( const py::object& iterable )
{
    return std::vector< T >( py::stl_input_iterator< T >( iterable ),
                             py::stl_input_iterator< T >( ) );
}

Should you find the input type (py::object) too liberal, feel free to specify stricter types (py::list in your case).