c++ - 如何用给定数量的元素初始化 boost::python::list？

Question

我有一个用于执行二进制数据编码/解码的 C 库的 python 包装器。其中一个包装函数将 python 列表作为参数并返回经过处理的 python 列表。

目前我是这样做的:

list pycf_cobs_decode(list data) {
    list decoded;
    uint32_t data_len = 0, worst_data_len = 0;
    uint8_t *cdata = NULL;
    uint8_t *cdata_dec = NULL;

    data_len = len( data );
    worst_data_len = COBS_WORST_LEN( data_len );

    // Clone the python list
    cdata = new uint8_t[ data_len ];
    for (int i=0; i<data_len; i++)
        cdata[ i ] = extract< uint8_t >( data[ i ] );

    // Decode it
    cdata_dec = new uint8_t[ worst_data_len ];
    cobs_decode( cdata, data_len, cdata_dec );

    for (int i=0; i<worst_data_len; i++)
        decoded.append( cdata_dec[ i ] );

    delete[] cdata_dec;
    delete[] cdata;
    return decoded;
}

但是，通过创建一个空列表然后将所有字节一个一个地追加是远远不够高效的(导致大量的 realloc 调用)。

1. 有没有办法将 boost::python::list 初始化为特定数量的元素？
2. 一个想法是创建一个 std::vector 并将其转换为 python 列表 ( std::vector to boost::python::list )，但发现大多数人建议无论如何都要手动附加所有元素。
3. 另一个想法是复制输入列表，覆盖内容并只附加额外的字节。但到目前为止，我也没有找到任何功能来做到这一点。
4. 也许如果我复制输入列表，删除所有元素(希望它不会在删除元素时重新分配)并将它们追加回去？

我一直试图从这些页面中找到有用的东西，但我真的不知道该找什么:

http://www.boost.org/doc/libs/1_57_0/libs/python/doc/v2/reference.html

http://www.boost.org/doc/libs/1_57_0/libs/python/doc/v2/list.html

谢谢

编辑: 意识到 std::string 也支持二进制数组并且 boost::python 自动将其转换为 python 字符串。使用 std::string，代码现在更短并且有望产生更好的性能。但是，这并不能回答问题，因为它仅适用于字符数组。

std::string pycf_cobs_decode(const std::string &data) {
    uint32_t worst_len = COBS_WORST_LEN( data.size() );
    char *cdec = new char[ worst_len ];

    // Decode it
    cobs_decode( ( const uint8_t * ) data.c_str(), data.size(), 
        ( uint8_t * ) cdec );

    std::string decoded( cdec, worst_len );
    delete[] cdec;

    return decoded;
}

Answer 1

一次添加一个项目时，内部分配的数量可能没有预期的那么多。是documented对于 list.append()，平均和摊销的最坏情况复杂度是恒定的。

Boost.Python 在允许用 C++ 编写类似 Python 的代码方面做得相当好。因此，可以使用 Python 惯用语 [None] * n 将列表分配给给定大小:

/// @brief Construct list with `n` elements.  each element is a copy 
///        of `value`.
/// @param n Iniitail container size.
/// @param item Item with which to fill the container.
boost::python::list make_list(
  const std::size_t n,
  boost::python::object item = boost::python::object() /* none */)
{
  namespace python = boost::python;
  // >>> [None] * n;
  python::list result;
  result.append(item);
  result *= n;
  return result;
}

我找不到明确说明此类操作的实现行为的文档，但该惯用语的表现通常优于追加。尽管如此，虽然 Boost.Python 没有公开所有 Python/C API 功能，但可以通过使用 PyList_New(len) 来保证一次分配。创建列表，然后通过 Boost.Python 管理和操作它。如文档中所述，当 len 大于零时，必须在将列表对象暴露给 Python 代码之前通过 PyList_SetItem() 将所有项目设置为真实对象，或者在在这种情况下，一个 boost::python::list 对象:

If len is greater than zero, the returned list object’s items are set to NULL. Thus you cannot use abstract API functions such as PySequence_SetItem() or expose the object to Python code before setting all items to a real object with PyList_SetItem().

辅助功能可能有助于隐藏这些细节。例如，可以使用具有类似填充行为的工厂函数:

/// @brief Construct list with `n` elements.  each element is a copy 
///        of `value`.
/// @param n Iniitail container size.
/// @param item Item with which to fill the container.
boost::python::list make_list(
  const std::size_t n,
  boost::python::object item = boost::python::object() /* none */)
{
  namespace python = boost::python;
  python::handle<> list_handle(PyList_New(n));
  for (std::size_t i=0; i < n; ++i)
  {
    // PyList_SetItem will steal the item reference.  As Boost.Python is
    // managing the item, explicitly increment the item's reference count
    // so that the stolen reference remains alive when this Boost.Python
    // object's scope ends.
    Py_XINCREF(item.ptr());

    PyList_SetItem(list_handle.get(), i, item.ptr());
  }
  return python::list{list_handle};
}

或者在范围内工作的工厂函数:

/// @brief Construct a list from a given range of [first,last).  The
///        copied range includes all elements between `first` to `last`,
///        including `first`.
/// @param first Input iterator to the initial item to copy.
/// @param last Input iterator to one after the final item to be copied.
template <typename Iterator>
boost::python::list make_list(Iterator first, Iterator last)
{
  namespace python = boost::python;
  const auto size = std::distance(first, last);
  python::handle<> list_handle{PyList_New(size)};
  for (auto i=0; i < size; ++i, ++first)
  {
    python::object item{*first};

    // PyList_SetItem will steal the item reference.  As Boost.Python is
    // managing the item, explicitly increment the item's reference count
    // so that the stolen reference remains alive when this Boost.Python
    // object's scope ends.
    Py_XINCREF(item.ptr());

    PyList_SetItem(list_handle.get(), i, item.ptr());
  }
  return boost::python::list{list_handle};
}

---

这是一个完整的例子demonstrating通过模拟 COBS_WORST_LEN() 和 cobs_decode() 函数，通过累积对进行解码。由于在构造返回的列表时解码值是已知的，因此我选择使用范围工厂函数来防止必须遍历列表并设置值两次:

#include <boost/python.hpp>

#include <iostream>
#include <vector>

#include <boost/python/stl_iterator.hpp>

/// Mockup that halves the list, rounding up.
std::size_t COBS_WORST_LEN(const std::size_t len)
{
  return (len / 2) + (len % 2);
}

/// Mockup that just adds adjacent elements together.
void cobs_decode(
  const boost::uint8_t* input,
  const std::size_t size,
  boost::uint8_t* output)
{
  for (std::size_t i=0; i < size; ++i, ++input)
  {
    if (i % 2 == 0)
    {
      *output = *input;
    }
    else
    {
      *output += *input;
      ++output;
    }
  }
}

/// @brief Construct a list from a given range of [first,last).  The
///        copied range includes all elements between `first` to `last`,
///        including `first`.
/// @param first Input iterator to the initial value to copy.
/// @param last Input iterator to one after the final element to be copied.
template <typename Iterator>
boost::python::list make_list(Iterator first, Iterator last)
{
  namespace python = boost::python;
  const auto size = std::distance(first, last);
  python::handle<> list_handle{PyList_New(size)};
  for (auto i=0; i < size; ++i, ++first)
  {
    python::object item{*first};

    // PyList_SetItem will steal the item reference.  As Boost.Python is
    // managing the item, explicitly increment the item's reference count
    // so that the stolen reference remains alive when this Boost.Python
    // object's scope ends.
    Py_XINCREF(item.ptr());

    PyList_SetItem(list_handle.get(), i, item.ptr());
  }
  return boost::python::list{list_handle};
}

/// @brief Decode a list, returning the aggregation of paired items.
boost::python::list decode(boost::python::list py_data)
{
  namespace python = boost::python;

  // Clone the list.
  std::vector<boost::uint8_t> data(len(py_data));
  std::copy(
    python::stl_input_iterator<boost::uint8_t>{py_data},
    python::stl_input_iterator<boost::uint8_t>{},
    begin(data));

  // Decode the list.
  std::vector<boost::uint8_t> decoded(COBS_WORST_LEN(data.size()));
  cobs_decode(&data[0], data.size(), &decoded[0]);

  return make_list(begin(decoded), end(decoded));
}

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;
  python::def("decode", &decode);
}

交互使用:

>>> import example
>>> assert(example.decode([1,2,3,4]) == [3,7])

此外，由于 Boost.Python 可以抛出异常，因此可能值得考虑使用内存管理容器，例如 std::vector 或智能指针，而不是原始动态数组。