0Pricing
C++ Academy · Aula

Chamar Python a partir de C++ com pybind11

Empacote código C++ como um módulo Python usando pybind11

Chamar Python a partir de C++ com pybind11 é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Por que usar pybind11?

pybind11 é uma biblioteca composta apenas por cabeçalhos que cria vinculações Python para código C++ com um mínimo de código repetitivo. É usada pelo SciPy, TensorFlow e muitos outros projetos.

Um módulo mínimo

Defina um módulo Python em um único arquivo com a macro PYBIND11_MODULE.

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

int add(int a, int b) { return a + b; }

PYBIND11_MODULE(mymodule, m) {
    m.def("add", &add, "Add two integers");
}

Compilando o módulo

Compile-o como um módulo de extensão Python — geralmente com CMake ou setuptools.

# CMake
find_package(pybind11 REQUIRED)
pybind11_add_module(mymodule mymodule.cpp)

Uso a partir do Python

Importe-o e use-o como qualquer módulo Python.

# Python
import mymodule
print(mymodule.add(2, 3))   # 5

Expondo classes

Use py::class_ para vincular uma classe C++. Construtores, métodos e propriedades correspondem a equivalentes em Python.

class Point {
public:
    Point(int x, int y) : x_(x), y_(y) {}
    int x() const { return x_; }
    int y() const { return y_; }
private:
    int x_, y_;
};

PYBIND11_MODULE(geom, m) {
    py::class_<Point>(m, "Point")
        .def(py::init<int, int>())
        .def("x", &Point::x)
        .def("y", &Point::y);
}

Conversões de tipos

O pybind11 converte automaticamente tipos comuns:

  • std::string ↔ Python str
  • std::vector<T> ↔ Python list
  • std::map ↔ Python dict
  • Tipos numéricos ↔ Python int/float

Interoperabilidade com NumPy

Passe matrizes do NumPy como py::array_t<T>. Acesse o buffer para realizar operações sem cópia.

void scale(py::array_t<double> arr, double factor) {
    auto buf = arr.mutable_unchecked<1>();
    for (size_t i = 0; i < buf.size(); ++i)
        buf(i) *= factor;
}

Lambdas como vinculações

Vincule uma lambda diretamente quando quiser transformar argumentos ou encapsular um comportamento.

m.def("show", [](const Point& p) {
    return "(" + std::to_string(p.x()) + ", " + std::to_string(p.y()) + ")";
});

Liberando o GIL

Para cálculos C++ longos, libere o GIL para que outras threads Python possam ser executadas.

m.def("slow", []() {
    py::gil_scoped_release release;
    // expensive C++ work, no Python access
});

Desempenho

O pybind11 acrescenta uma sobrecarga mínima — geralmente algumas centenas de nanossegundos por chamada. Isso é insignificante para funções não triviais, mas importa em laços intensivos com funções chamadas de baixo custo.

Alternativas

Outras pontes entre Python e C++:

  • Boost.Python — mais antiga e pesada
  • SWIG — oferece suporte a muitas linguagens
  • nanobind — mais nova e mais rápida que o pybind11

Casos de uso no mundo real

O pybind11 é ideal para:

  • Encapsular uma biblioteca C++ para usuários de Python
  • Acelerar caminhos críticos do Python com código C++
  • Compartilhar núcleos numéricos entre aplicações C++ e ferramentas Python

Verificação rápida

Qual macro o pybind11 usa para declarar um módulo Python?

Recapitulação

O pybind11 torna quase fácil encapsular C++ para Python. Declare módulos com PYBIND11_MODULE, vincule funções com m.def e classes com py::class_. As conversões integradas abrangem tipos da STL; as matrizes do NumPy não exigem cópia.

Perguntas Frequentes

A aula “Chamar Python a partir de C++ com pybind11” é grátis?

Sim — o texto completo de “Chamar Python a partir de C++ com pybind11” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Chamar Python a partir de C++ com pybind11”?

Empacote código C++ como um módulo Python usando pybind11 Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Chamar Python a partir de C++ com pybind11”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. extern C e a ABI de C
  2. Chamar Python a partir de C++ com pybind11
  3. C++ para fronteiras FFI de Rust
  4. Usar SWIG para ligações entre várias linguagens
← Voltar para C++ Academy