Calling Python scripts in C requires the implementation of Python C API. First, initialize the interpreter, then import the module and call the functions, and finally clean up the resources; the specific steps are: 1. Initialize the Python interpreter with Py_Initialize(); 2. Load the Python script module with PyImport_Import(); 3. Obtain the objective function through PyObject_GetAttrString(); 4. Use PyObject_CallObject() to pass parameters to call the function; 5. Calling Py_DECREF() and Py_Finalize() to release resources and close the interpreter; in the example, the greet and add functions of hello.py are successfully called and the results are output. The entire process needs to ensure that the Python development environment is configured correctly, the script path is accessible, and attention should be paid to the matching of memory management and version. The final program can run normally and output the expected results.

Calling Python scripts in C is a common requirement, especially when it is necessary to take advantage of Python's rich libraries (such as NumPy, Pandas, machine learning models, etc.). C can be directly embedded and executed through the Python C API . Here is a simple, runnable example showing how to call a Python script from C.

? Prerequisites

1. Install Python development environment (including header files and libraries)
2. Linking Python libraries at compile time (such as libpython3.x )
3. Use a compiler that supports C 11 and above

? Example structure

 project/
├── main.cpp // C main program ├── hello.py // Python script to be called

1. Write Python script: hello.py

 # hello.py
def greet(name):
    return f"Hello, {name} from Python!"

def add(a, b):
    return ab

# Directly executed code print("Python script is running...")

2. C program: main.cpp

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

int main() {
    // Initialize the Python interpreter Py_Initialize();

    if (!Py_IsInitialized()) {
        std::cerr << "Failed to initialize Python" << std::endl;
        return -1;
    }

    // Import Python script (assuming the file name is hello.py)
    PyObject* pName = PyUnicode_DecodeFSDefault("hello");
    PyObject* pModule = PyImport_Import(pName);

    if (!pModule) {
        PyErr_Print();
        std::cerr << "Failed to load module &#39;hello&#39;" << std::endl;
        Py_Finalize();
        return -1;
    }

    // Call greet(name) function {
        PyObject* pFunc = PyObject_GetAttrString(pModule, "greet");
        if (pFunc && PyCallable_Check(pFunc)) {
            PyObject* pArgs = PyTuple_New(1);
            PyTuple_SetItem(pArgs, 0, PyUnicode_FromString("Alice"));

            PyObject* pResult = PyObject_CallObject(pFunc, pArgs);

            if (pResult) {
                const char* result = PyUnicode_AsUTF8(pResult);
                std::cout << "Result from Python: " << result << std::endl;
                Py_DECREF(pResult);
            } else {
                PyErr_Print();
            }

            Py_DECREF(pArgs);
            Py_XDECREF(pFunc);
        } else {
            std::cerr << "Function &#39;greet&#39; not found or not callable" << std::endl;
        }
    }

    // Call the add(a, b) function {
        PyObject* pFunc = PyObject_GetAttrString(pModule, "add");
        if (pFunc && PyCallable_Check(pFunc)) {
            PyObject* pArgs = PyTuple_New(2);
            PyTuple_SetItem(pArgs, 0, PyLong_FromLong(10));
            PyTuple_SetItem(pArgs, 1, PyLong_FromLong(20));

            PyObject* pResult = PyObject_CallObject(pFunc, pArgs);

            if (pResult) {
                long result = PyLong_AsLong(pResult);
                std::cout << "add(10, 20) = " << result << std::endl;
                Py_DECREF(pResult);
            } else {
                PyErr_Print();
            }

            Py_DECREF(pArgs);
            Py_XDECREF(pFunc);
        } else {
            std::cerr << "Function &#39;add&#39; not found or not callable" << std::endl;
        }
    }

    // Clean Py_DECREF(pModule);
    Py_DECREF(pName);
    Py_Finalize();

    return 0;
}

3. Compile command (Linux/macOS)

Assuming using Python 3.8, first confirm your Python configuration:

 python3-config --includes --libs

Then compile:

 g main.cpp -o run \
    $(python3-config --includes --libs) \
    -lpython3.10 # Adjust according to your actual version

For example:

 g main.cpp -o run `python3-config --includes --libs`

?? Note: On some systems it may be necessary to specify -lpython3.x explicitly, or use pkg-config python3 --cflags --libs .

4. Operation results

 ./run

Output:

 Python script is running...
Results from Python: Hello, Alice from Python!
add(10, 20) = 30

? FAQs and Suggestions

• Make sure hello.py is in the current working directory , otherwise Python cannot find the module.
• Use PyRun_SimpleString("exec(open('script.py').read())"); to execute the contents of the .py file.
• In multi-threaded environments, you need to pay attention to GIL (global interpreter lock).
• When publishing the program, you need to make sure that the target machine has the corresponding version of Python installed.

? Summary

• Start the Python interpreter with Py_Initialize()
• Loading .py files with PyImport_Import
• Use PyObject_GetAttrString to get the function
• Call the function with PyObject_CallObject and pass the parameters
• Remember Py_DECREF to prevent memory leaks
• Finally Py_Finalize() cleans up resources

Basically that's it. As long as the environment is configured correctly, this example can be run quickly. In actual projects, you can also encapsulate them into classes or tool functions to simplify calls.

The above is the detailed content of C call python script from C example. For more information, please follow other related articles on the PHP Chinese website!