The Python API is a C/C++ programming toolset that enables developers to write code that integrates Python and C++. The first part of the article shows how the Python API makes it possible to access Python code in a C/C++ application. The second part explains how to code extension modules in C++ that can be imported into regular Python code.

PyObject *mod = PyImport_ImportModule("simple");

PyObject *mod, *attr;
mod = PyImport_ImportModule("simple");
if (mod != nullptr) {
    if (PyObject_HasAttrString(mod, "plus") == 1) {
        attr = PyObject_GetAttrString(mod, "plus");
    }
}

PyObject* attr = PyObject_GetAttrString(mod, "my_attr");
PyObject* str = PyObject_Str(attr);
PyObject* ucode = PyUnicode_AsEncodedString(str, "utf-8", NULL);
const char* bytes = PyBytes_AsString(ucode);
std::cout << bytes << std::endl;

#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <iostream>

int main() {

    PyObject *module, *func, *args, *ret;

    // Initialize python access
    Py_Initialize();

    // Import the simple.py code
    module = PyImport_ImportModule("simple");
    if (module) {

        // Access the attribute named plus
        func = PyObject_GetAttrString(module, "plus");

        // Make sure the attribute is callable
        if (func && PyCallable_Check(func)) {

            // Create a tuple to contain the function's args
            args = PyTuple_New(2);
            PyTuple_SetItem(args, 0, PyLong_FromLong(4));
            PyTuple_SetItem(args, 1, PyLong_FromLong(7));

            // Execute the plus function in simple.py
            ret = PyObject_CallObject(func, args);
            Py_DECREF(args);
            Py_DECREF(func);
            Py_DECREF(module);

            // Check the return value
            if (ret) {

                // Convert the value to long and print
                long retVal = PyLong_AsLong(ret);
                std::cout << "Result: " << retVal << std::endl;
            }
            else {

                // Display error
                PyErr_Print();
                std::cerr << "Couldn't access return value" << std::endl;
                Py_Finalize();
                return 1;
            }
        }
        else {

            // Display error
            if (PyErr_Occurred())
                PyErr_Print();
            std::cerr << "Couldn't execute function" << std::endl;
        }
    }
    else {

        // Display error
        PyErr_Print();
        std::cerr << "Couldn't access module" << std::endl;
        Py_Finalize();
        return 1;
    }

    // Finalize the Python embedding
    Py_Finalize();
    return 0;
}

def plus(a, b):
    return a + b

Result: 11

python
>>> import plustwo
>>> x = plustwo.addtwo(5)
>>> x
7

PyMODINIT_FUNC PyInit_plustwo() {
    return PyModule_Create(&moduleDef);
}

static struct PyModuleDef moduleDef = {
    PyModuleDef_HEAD_INIT, 
    "plustwo", 
    "This module contains a function (addtwo) that adds two to a number\n", 
    -1, 
    funcs  // Array containing a PyMethodDef for each module function
};

#define PY_SSIZE_T_CLEAN
#include <Python.h>

// The code to be executed when the module function is called
static PyObject* plustwo_addtwo(PyObject* self, PyObject* arg) {
    long longArg = PyLong_AsLong(arg) + 2;
    return PyLong_FromLong(longArg);
}

// Array of PyMethodDef structures - describe the module's functions
static PyMethodDef funcs[] = {
    {"addtwo", (PyCFunction)plustwo_addtwo, METH_O, "This adds two to a number\n"},
    {NULL, NULL, 0, NULL}
};

// The PyModuleDef structure describes the module
static struct PyModuleDef moduleDef = {
    PyModuleDef_HEAD_INIT, 
    "plustwo", 
    "This module contains a function (addtwo) that adds two to a number\n", 
    -1, 
    funcs
};

// Called when the interpreter imports the module
PyMODINIT_FUNC PyInit_plustwo() {
    return PyModule_Create(&moduleDef);
}

python
>>> import plustwo
>>> x = plustwo.addtwo(5)
>>> x
7

PyObject *mod = PyImport_ImportModule( " 단순" );

파이오브젝트 *mod, *attr;
mod = PyImport_ImportModule( " 단순" );
if (mod != nullptr ) {
     if (PyObject_HasAttrString(mod, " plus" ) == 1 ) {
        attr = PyObject_GetAttrString(mod, " 더하기" );
    }
}

PyObject* attr = PyObject_GetAttrString(mod, " my_attr" );
PyObject* str = PyObject_Str(attr);
PyObject* ucode = PyUnicode_AsEncodedString(str, " utf-8" , NULL);
const  char * 바이트 = PyBytes_AsString(ucode);
std::cout  < < 바이트 < <  std::endl ;

#define PY_SSIZE_T_CLEAN
 #include < Python.h > #include < iostream > int main() { 
 



    PyObject *모듈, *func, *args, *ret;

    // 파이썬 액세스 초기화
     Py_Initialize();

    // simple.py 코드 가져오기
     module = PyImport_ImportModule( " simple" );
    if (모듈) {

        // plus func라는 속성에 액세스
         = PyObject_GetAttrString(module, " plus" );

        // 속성이 호출 가능한지 확인
         if (func && PyCallable_Check(func)) {

            // 함수의 인수를 포함할 튜플을 만듭니다.
             args = PyTuple_New( 2 );
            PyTuple_SetItem(args, 0 , PyLong_FromLong( 4 ));
            PyTuple_SetItem(args, 1 , PyLong_FromLong( 7 ));

            // simple.py에서 더하기 함수를 실행합니다.
             ret = PyObject_CallObject(func, args);
            Py_DECREF(인자);
            Py_DECREF(펑크);
            Py_DECREF(모듈);

            // 반환값 확인
             if (ret) {

                // 값을 long으로 변환하고
                 long을 출력합니다 . retVal = PyLong_AsLong(ret);
                std::cout  < <  " 결과: "  < < retVal < <  std::endl ;
            }
            다른 {

                // 오류 표시
                 PyErr_Print();
                std::cerr  < <  " 반환 값에 액세스할 수 없습니다."  < <  std::endl ;
                Py_Finalize();
                반환  1 ;
            }
        }
        다른 {

                        // (PyErr_Occurred()) 인 경우 오류 표시

                PyErr_Print();
            std::cerr  < <  " 함수를 실행할 수 없습니다."  < <  std::endl ;
        }
    }
    다른 {

        // 오류 표시
         PyErr_Print();
        std::cerr  < <  " 모듈에 액세스할 수 없습니다."  < <  std::endl ;
        Py_Finalize();
        반환  1 ;
    }

    // Python 임베딩을 마무리합니다.
     Py_Finalize();
    반환  0 ;
}

def plus(a, b):
     a + b 반환

결과: 11

파이썬
>>> 플러스투 가져오기
>>> x = plustwo.addtwo( 5 )
>>> 엑스
7

PyMODINIT_FUNC PyInit_plustwo() {
     return PyModule_Create(&moduleDef);
}

정적  구조체 PyModuleDef moduleDef = {
    PyModuleDef_HEAD_INIT,
    " plustwo" , 
     " 이 모듈에는 숫자에 2를 더하는 함수(addtwo)가 포함되어 있습니다\n" ,
    - 1 ,
    funcs   // 각 모듈에 대한 PyMethodDef를 포함하는 배열 function
 };

#define PY_SSIZE_T_CLEAN
 #include < Python.h > // 모듈 함수가 호출될 때 실행할 코드
 static PyObject* plustwo_addtwo(PyObject* self, PyObject* arg) {
     long longArg = PyLong_AsLong(arg) + 2 ;
    return PyLong_FromLong(longArg); 


}

// PyMethodDef 구조의 배열 - 모듈의 함수를 설명합니다.
 static PyMethodDef funcs[] = {
    { " addtwo" , (PyCFunction)plustwo_addtwo, METH_O, " 이것은 숫자에 2를 더합니다\n" },
    {NULL, NULL, 0 , NULL}
};

// PyModuleDef 구조체는 모듈
 정적  구조체를 설명합니다. PyModuleDef moduleDef = {
    PyModuleDef_HEAD_INIT,
    " plustwo" , 
     " 이 모듈에는 숫자에 2를 더하는 함수(addtwo)가 포함되어 있습니다\n" ,
    - 1 ,
    기능
};

// 인터프리터가 모듈을 가져올 때 호출됨
 PyMODINIT_FUNC PyInit_plustwo() {
     return PyModule_Create(&moduleDef);
}

파이썬
>>> 플러스투 가져오기
>>> x = plustwo.addtwo( 5 )
>>> 엑스
7