Embedding Python in C/C++

Embedding Python in C/C++ is also relatively simple. First, you need to add Python’s include file directory and lib file directory in VC:
Under VC6.0, open tools->options->directories->show directories for, add the inlude directory in the Python installation directory to the include files item, and add the libs directory to library files item.
Under VC2005, open the tools->options->Projects and Solutions->VC++ directory, and then do the same work.

The code is as follows:

//在debug下执行出错，“无法找到python31_d.lib文件”，后查到原因是：在debug下生成必须要有python31_d.lib文件，否则只能在release下生成
#include <python.h>
int main()
{
    Py_Initialize();
    PyRun_SimpleString("Print &#39;hi, python!&#39;");
    Py_Finalize();
    return 0;
}

Py_Initialize function prototype is: void Py_Initialize(), this function must be used when embedding Python scripts. It initializes the Python interpreter and is used when using other Python/C This function must be called before the API. You can use the Py_IsInitialized function to determine whether the initialization is successful and return True if successful.
PyRun_SimpleString function prototype is int PyRun_SimpleString(const char *command), used to execute a piece of Python code. Note: Do you need to maintain indentation between statements?
Py_Finalize function prototype is void Py_Finalize(), used to close the Python interpreter and release the resources occupied by the interpreter.

PyRun_SimpleFile function can be used to run ".py" script files. The function prototype is as follows:
int PyRun_SimpleFile(FILE *fp, const char *filename);
its where fp is the open file pointer, and filename is the name of the python script file to be run. However, since this function is officially released by visual studio Compiled with 2003.NET, if other versions of the compiler are used, the FILE definition may cause a crash due to version reasons. At the same time, for simplicity, you can use the following method to replace this function:
PyRun_SimpleString("execfile('file.py')"); //Use execfile to run python files

Py_BuildValue() is used to convert numbers and strings into corresponding data types in Python (in C language, all Python types are declared as PyObject types), function The prototype is as follows:
PyObject *Py_BuildValue(const char *format, …..);
PyString_String() is used to convert PyObject* type variables into char* type that can be processed by C language. The specific prototype is as follows:
char* PyString_String(PyObject *p);

List operation function:
PyObject * PyList_New(Py_ssize_t len);
int PyList_SetItem(PyObject *list, Py_ssize_t index, PyObject *item);
PyObject * PyList_GetItem(PyObject *list, Py_ssize_t index);
int PyList_Append(PyObject *list, PyObject *item);
int PyList_Sort(PyObject *list);
int PyList_Reverse(PyObject *list);
Py_ssize_t PyList_Size(PyObject *list);

Tuple operation function:
int PyTuple_New(Py_ssize_t len);
int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o);
PyObject * PyTuple_GetItem(PyObject *p, Py_ssize_t pos);
int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize); //Note that it is a ** pointer

Dictionary operation function:
PyObject * PyDict_New();
int PyDict_SetItem(PyObject *p, PyObject *key, PyObject *val);
int PyDict_SetItemString(PyObject *p, const char *key, PyObject *val);
PyObject* PyDict_GetItem(PyObject *p, PyObject *key);
PyObject* PyDict_GetItemString(PyObject *p, const char *key);
//corresponds to PyDict_SetItemString
int PyDict_DelItem(PyObject *p, PyObject *key);
int PyDict_DelItemString(PyObject *p, char *key);
//corresponds to PyDict_SetItemString
int PyDict_Next(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue);
PyObject* PyDict_Items(PyObject *p);
PyObject* PyDict_keys(PyObject *p);
PyObject* PyDict_Values(PyObject *p);

Using Python objects in C/C++ should handle reference counting issues correctly, otherwise it can easily lead to memory leaks. When using Python/C After functions in the API create lists, tuples, dictionaries, etc., you should use macros such as Py_CLEAR() and Py_DECREF() to destroy these objects after completing operations on them. The prototype is as follows:
void Py_CLEAR(PyObject *o);
void Py_DECREF(PyObject *o);
Among them, for the Py_CLEAR function, the parameter can be a NULL pointer, which means no operation is performed, but the Py_DECREF function cannot be a NULL pointer, otherwise an error will occur.

Use the PyImport_Import() function to import a Python module in C and return a module object. The function prototype is:
PyObject* PyImport_Import(PyObject *name);
The PyModule_GetDict() function can obtain the function list in the Python module and return a dictionary. The key in the dictionary is the function name and the value is the calling address of the function. The prototype is as follows:
PyObject* PyModule_GetDict(PyObject *module);
Use the PyObject_CallObject() function and PyObject_CallFunction() function to call functions in Python from C. The prototype is as follows:
PyObject* PyObject_CallObject(PyObject *callable_object, PyObject *args);
//args is in tuple form
PyObject* PyObject_CallFunction(PyObject *callable, char *format, ...);
//format is a parameter type similar to "iss", followed by the specified parameters
You can use PyCallable_Check(func) to determine whether the function can be called, and return True if it can.

The above is the content of embedding Python in C/C++. For more related articles, please pay attention to the PHP Chinese website (www.php.cn)!