Qt C++ 调用 Python——常用操作的封装 – 加载模块、获取函数、实例化类、获取类的方法和调用 Python 方法

将常见的交互操作（如加载模块、获取函数、实例化类、获取类方法和调用 Python 方法）封装起来，可以极大地简化 Qt C++ 和 Python 之间的交互。以下详细介绍了如何封装这些操作，并提供了对应的示例代码。

1. 加载模块

在 Qt C++ 中加载 Python 模块是使用 Python 功能的初始步骤。以下函数展示了如何实现此操作：

 * @brief LoadPythonModule 获取加载模块对象
 * @param moduleName      模块名称
 * @param scriptPath      脚本路径
 * @return 加载的模块对象
 */
PyObject* LoadPythonModule(const QString &moduleName, const QString &scriptPath)
{
    if (!Py_IsInitialized())
    {
        qDebug() << "Python 解释器未初始化！";
        return nullptr;
    }

    // 添加 Python 模块路径 将路径添加到sys.path
    QString pyCode = QString("import sys; sys.path.append('%1')").arg(scriptPath);

    // 将QString转换为C风格字符串
    QByteArray pyCodeBytes = pyCode.toUtf8();
    const char* pyCodeCStr = pyCodeBytes.constData();

    PyRun_SimpleString(pyCodeCStr);

    // 加载Python模块
    PyObject* pModuleObject = PyImport_ImportModule(moduleName.toStdString().c_str());
    if (!pModuleObject)
    {
        PyErr_Print();
        qDebug() << "加载模块失败！";
        return nullptr;
    }
    else
    {
        qDebug() << moduleName + "模块加载成功！";
    }

    return pModuleObject;
}

此函数首先验证 Python 解释器的初始化状态，然后将指定脚本路径添加到 Python 的 sys.path，最后尝试加载模块并返回其对象。

2. 获取模块中的函数

从已加载的模块中获取特定函数，这一步骤是调用 Python 功能的关键：

/**
 * @brief GetFuncObject 获取函数对象
 * @param moduleObject  已加载的模块对象
 * @param funcName      要获取的函数的名称
 * @return  函数对象
 */
PyObject* GetPythonFunction(PyObject *moduleObject, const QString &funcName)
{
    if (!moduleObject)
    {
        qDebug() << "模块未加载，无法调用函数！";
        return nullptr;
    }

    PyObject* pFuncObject = PyObject_GetAttrString(moduleObject, funcName.toStdString().c_str());

    if (!pFuncObject)
    {
        PyErr_Print();
        qDebug() << "获取函数失败！";
        return nullptr;
    }

    if (!PyCallable_Check(pFuncObject)) // 检查函数对象是否可调用
    {
        PyErr_Print();
        qDebug() << "函数不可调用！";
        Py_DECREF(pFuncObject);  // 释放对象
        return nullptr;
    }
    else
    {
        qDebug() << funcName + "函数加载成功";
    }

    return pFuncObject;
}

此函数从模块对象中获取指定函数，并验证其可调用性。如获取失败，将输出错误信息。

3. 获取 Python 类的实例

创建并返回指定 Python 类的实例，这对于操作 Python 类及其方法至关重要：

/**
  * @brief GetPythonClassInstance 获取 Python 类的实例
  * @param moduleObject 已加载的 Python 模块对象
  * @param className 要实例化的类的名称
  * @param args      传递给类构造函数的参数（可选）- args 可以是元组
  * @param kwargs    传递给类构造函数的字典（可选）- 传入字典 args 需要为空
  * @return Python   类的实例
  */
PyObject* GetPythonClassInstance(PyObject *moduleObject, const QString &className, PyObject *args, PyObject *kwargs)
{
if (!moduleObject)
    {
        qDebug() << "模块未加载，无法获取类实例！";
        return nullptr;
    }

    PyObject* pClassObject = PyObject_GetAttrString(moduleObject, className.toStdString().c_str());

    if (!pClassObject)
    {
        PyErr_Print();
        qDebug() << "获取类失败！";
        return nullptr;
    }

    if (!PyCallable_Check(pClassObject))
    {
        PyErr_Print();
        qDebug() << "类不可调用！";
        Py_DECREF(pClassObject);  // 释放对象
        return nullptr;
    }

    // 调用类构造函数，传递 args 和 kwargs 参数
    PyObject* pInstance = PyObject_Call(pClassObject, args ? args : PyTuple_New(0), kwargs);
    Py_DECREF(pClassObject);  // 释放类对象

    if (!pInstance)
    {
        PyErr_Print();
        qDebug() << "实例化类失败！";
        return nullptr;
    }

    qDebug() << className + "类实例化成功";
    return pInstance;
}

此函数获取模块中的指定类，并使用提供的参数实例化该类，若成功则返回实例对象。

4. 获取类的方法

从 Python 类实例中获取特定方法，这对于执行特定操作非常有用：

/**
 * @brief GetClassMethod 获取类的方法
 * @param classInstance Python 类的实例对象
 * @param methodName 要获取的方法的名称
 * @return 类的方法
 */
PyObject* GetClassMethod(PyObject* classInstance, const QString& methodName)
{
    if (!classInstance)
    {
        qDebug() << "类实例未创建，无法获取方法！";
        return nullptr;
    }

    PyObject* pMethodObject = PyObject_GetAttrString(classInstance, methodName.toStdString().c_str());

    if (!pMethodObject)
    {
        PyErr_Print();
        qDebug() << "获取方法失败！";
        return nullptr;
    }

    if (!PyCallable_Check(pMethodObject))
    {
        PyErr_Print();
        qDebug() << "方法不可调用！";
        Py_DECREF(pMethodObject);  // 释放对象
        return nullptr;
    }

    qDebug() << methodName + "方法加载成功";
    return pMethodObject;
}

此函数从类实例中获取指定方法，并验证其可调用性。

5. 调用 Python 函数

执行 Python 函数并返回其结果，这是 Python 与 C++ 交互的终端操作：

/**
 * @brief CallPythonFunction 调用 Python 函数
 * @param funcObject  要调用的函数对象
 * @param args        传递给函数的参数元组（可选）     - args 可以是元组
 * @param kwargs      传递给函数的关键字参数字典（可选）- 传入字典 args 需要为空
 * @return 函数调用的结果
 */
PyObject* CallPythonFunction(PyObject* funcObject, PyObject* args = nullptr, PyObject* kwargs = nullptr)
{
    if (!funcObject)
    {
        qDebug() << "函数对象无效，无法调用函数！";
        return nullptr;
    }

    if (!PyCallable_Check(funcObject))
    {
        PyErr_Print();
        qDebug() << "函数对象不可调用！";
        return nullptr;
    }

    // 调用函数，传递 args 和 kwargs 参数
    PyObject* pResult = PyObject_Call(funcObject, args ? args : PyTuple_New(0), kwargs);

    if (!pResult)
    {
        PyErr_Print();
        qDebug() << "调用函数失败！";
        return nullptr;
    }

    qDebug() << "函数调用成功";
    return pResult;
}

此函数调用指定的 Python 函数，并传递可选的参数和关键字参数。