changelog.rst

#include <pybind11/embed.h>
namespace py = pybind11;

int main() {
    py::scoped_interpreter guard{}; // start the interpreter and keep it alive

    py::print("Hello, World!"); // use the Python API
}
from cpp_module import CppBase1, CppBase2

class PyDerived(CppBase1, CppBase2):
    def __init__(self):
        CppBase1.__init__(self)  # C++ bases must be initialized explicitly
        CppBase2.__init__(self)
// new
PYBIND11_MODULE(example, m) {
    m.def("add", [](int a, int b) { return a + b; });
}

// old
PYBIND11_PLUGIN(example) {
    py::module m("example");
    m.def("add", [](int a, int b) { return a + b; });
    return m.ptr();
}
struct Example {
    Example(std::string);
};

py::class_<Example>(m, "Example")
    .def(py::init<std::string>()) // existing constructor
    .def(py::init([](int n) { // custom constructor
        return std::make_unique<Example>(std::to_string(n));
    }));
struct Base {
    int foo() { return 42; }
}

struct Derived : Base {}

// Now works, but previously required also binding `Base`
py::class_<Derived>(m, "Derived")
    .def("foo", &Derived::foo); // function is actually from `Base`
struct Aggregate {
    int a;
    std::string b;
};

py::class_<Aggregate>(m, "Aggregate")
    .def(py::init<int, const std::string &>());
py::class_<TrampolineClass>("MyClass")
  .alias<MyClass>()
  ....
py::class_<MyClass, TrampolineClass>("MyClass")
  ....
py::class_<Pet>(m, "Pet")
    .def("set", py::overload_cast<int>(&Pet::set), "Set the pet's age")
    .def("set", py::overload_cast<const std::string &>(&Pet::set), "Set the pet's name");
py::module m = /* ... */
m.attr("constant") = 123;