Qt C++中调用python,并将软件打包发布，python含第三方依赖

工作中遇到qt c++调用我的python 代码，并且想要一键打包，这里我根据参考的以及个人实践的结果来简单实现一下。

环境：windows系统，QT Creater 4.5， python 3.8（anaconda虚拟环境）

1. 简单QT调用python程序

1.创建QT工程

中间省略3个步骤图。创建完成后，如图。

首先提示各位从python过来的同仁，QT中有时候对项目“重新构建”，项目并不真正的重新构建，如果这样的话，我们需要在工程文件夹下找到对应的构建后的项目，即比较长的这个（对应的是debug模式下的编译构建），删除掉，再点击重新构建。

2. 配置python 环境

使用QT 调用python需要加载Python.h头文件，我们在Headers/mainwindow.h里面引入Python.h。但原始配置是找不到Python.h的，所以首先我们需要将安装好的python路径配置到QT的配置文件（.pro）中。 

打开(项目名.pro)文件，按照如下格式填写。这里我将一个python 环境的DLLs,include,Lib,libs和python3.dll, python38.dll 以及vcruntime.dll 复制过来，为该项目单独做个python环境。

（参考在QT C++中调用 Python并将软件打包发布（裸机可运行）_互联网集市）

我是创建一个python_38的python环境，拷贝了miniconda3/envs/cat虚拟环境中的DLLs,include,Lib,libs和python3.dll, python38.dll 以及vcruntime140.dll （这个python环境要能够支撑后面的python代码的运行，就是在原来的虚拟环境中，下面的python代码也可以执行的）

1. INCLUDEPATH += -I D:\output\envs\python_38\include # python.h
2. LIBS += -LD:\output\envs\python_38\libs -lpython38 # python38.lib

其中 INCLUDEPATH 里面配置的是python.h的路径，LIBS配置的是python38.lib的路径。（参考Qt调用Python详细图文过程记录_python_脚本之家）

问题1：出现C2059错误

解决办法：在object.h中把slots改成slots1。Python将slots作为变量，而Qt将slots作为关键字，所以冲突了，再次编译该问题就没有了（参考Qt调用Python详细图文过程记录_python_脚本之家）

问题2 

如果出现找不到python38_d.lib是因为系统默认我们采用的是debug模式编译的（图片左下角所示）

我们可以

1在D:\output\envs\python_38\libs 复制python38.lib，粘贴成python38_d.lib

2 将编译模式修改成release模式。

以下操作在release模式进行

再次编译，如果不报错，则表示编译成功，点击运行，出现弹窗。

为了方便调试我们的程序是否成功，我们在mainwindow.h中加入QDebug

然后再mainwindow.cpp中编写如下，运行。（参考C++调用python脚本 - 知乎）

1. #include "mainwindow.h"
2. #include "ui_mainwindow.h"
4. MainWindow::MainWindow(QWidget *parent) :
5. QMainWindow(parent),
6. ui(new Ui::MainWindow)
7. {
8. ui->setupUi(this);
9. // 初始化python解释器.C/C++中调用Python之前必须先初始化解释器
10. Py_Initialize();
11. // 判断python解析器的是否已经初始化完成
12. if(!Py_IsInitialized())
13. qDebug()<<"[db:] Py_Initialize fail";
14. else
15. qDebug()<<"[db:] Py_Initialize success";
16. // 执行 python 语句
17. PyRun_SimpleString("print('hello world') ");
18. // 并销毁自上次调用Py_Initialize()以来创建并为被销毁的所有子解释器。
19. Py_Finalize();
22. }
24. MainWindow::~MainWindow()
25. {
26. delete ui;
27. }

代码能够解释执行python语句，并输出hello world，表示我们配置运行成功。

3. 调用python脚本

把python脚本嵌入近c++语句中，肯定不是我们想要的，我们想要的是QT C++能够调用执行python脚本的。

我们写一个简单的python脚本py_test.py，为了证明调用成功，我们使用python写一个空文件，内容如下。

1. def write_file():
2. with open("a.txt", "w") as f:
3. f.write("test")

将其放到py_scripts文件夹下，py_scripts与build-simple_test-Desktop_Qt_5_10_0_MSVC2015_64bit-Release文件夹的相对位置如下所示，即同属于./qt文件夹下

修改mainwindow.cpp内容，如下

1. #include "mainwindow.h"
2. #include "ui_mainwindow.h"
4. MainWindow::MainWindow(QWidget *parent) :
5. QMainWindow(parent),
6. ui(new Ui::MainWindow)
7. {
8. ui->setupUi(this);
9. // 初始化python解释器.C/C++中调用Python之前必须先初始化解释器
10. Py_Initialize();
11. // 判断python解析器的是否已经初始化完成
12. if(!Py_IsInitialized())
13. qDebug()<<"[db:] Py_Initialize fail";
14. else
15. qDebug()<<"[db:] Py_Initialize success";
16. // 执行 python 语句
17. PyRun_SimpleString("print('hello world') ");
19. // 导入sys模块设置模块地址，以及python脚本路径
20. PyRun_SimpleString("import sys");
21. // 该相对路径是以build...为参考的
22. PyRun_SimpleString("sys.path.append('../py_scripts')");
23. // 加载 python 脚本
24. PyObject *pModule = PyImport_ImportModule("py_test"); // 脚本名称，不带.py
25. if(!pModule) // 脚本加载成功与否
26. qDebug()<<"[db:] pModule fail";
27. else
28. qDebug()<<"[db:] pModule success";
30. // 创建函数指针
31. PyObject* pFunc= PyObject_GetAttrString(pModule,"write_file"); // 方法名称
32. if(!pFunc || !PyCallable_Check(pFunc)) // 函数是否创建成功
33. qDebug()<<"[db:] pFunc fail";
34. else
35. qDebug()<<"[db:] pFunc success";
36. // 调用函数
37. PyObject_CallObject(pFunc, NULL); // 无参调用
38. // 并销毁自上次调用Py_Initialize()以来创建并为被销毁的所有子解释器。
39. Py_Finalize();
41. }
43. MainWindow::~MainWindow()
44. {
45. delete ui;
46. }

执行完成后，会在build-simple_test-Desktop_Qt_5_10_0_MSVC2015_64bit-Release文件夹下生成一个a.txt文件。

2. 有参调用

以上为对python的无参调用，这里我们使用对python的有参调用。

因为python 是没有显性定义的，而C++是有定义的，我们要简单了解下python与C++的数据的类型 。类型对应参考（如何在C++中使用一个Python类-[PyImport_ImportModule、PyModule_GetDict、PyDict_GetItemString、PyObject_CallFuncti]-CSDN博客），简单来说就是s对应字符串，i对应整型，f对应float。使用方法可以参考（Qt项目中C++调用Python函数传多参问题_qt调用python_平头猿小哥的博客-CSDN博客）

这里就复制粘贴使用方法参考的文档，稍作修改，连带返回值和列表的使用都有了。

QT C++源码如下

1. #include "mainwindow.h"
2. #include "ui_mainwindow.h"
4. MainWindow::MainWindow(QWidget *parent) :
5. QMainWindow(parent),
6. ui(new Ui::MainWindow)
7. {
8. ui->setupUi(this);
9. // 初始化python解释器.C/C++中调用Python之前必须先初始化解释器
10. Py_Initialize();
11. // 判断python解析器的是否已经初始化完成
12. if(!Py_IsInitialized())
13. qDebug()<<"[db:] Py_Initialize fail";
14. else
15. qDebug()<<"[db:] Py_Initialize success";
16. // 执行 python 语句
17. PyRun_SimpleString("print('hello world') ");
19. // 导入sys模块设置模块地址，以及python脚本路径
20. PyRun_SimpleString("import sys");
21. // 该相对路径是以build...为参考的
22. PyRun_SimpleString("sys.path.append('../py_scripts')");
23. // 加载 python 脚本
24. PyObject *pModule = PyImport_ImportModule("py_test"); // 脚本名称，不带.py
25. if(!pModule) // 脚本加载成功与否
26. qDebug()<<"[db:] pModule fail";
27. else
28. qDebug()<<"[db:] pModule success";
30. // 创建函数指针，有参调用
31. PyObject* pFunc= PyObject_GetAttrString(pModule, "process_data"); // 有参调用的
32. // 定义一个随机器
33. QRandomGenerator generator;
34. // 创建一个定长元组，用来存放传入参数
35. PyObject* pyArgs = PyTuple_New(20);
36. // 每个元组类似于结构体，包含字符串，整型和浮点类型数据
37. // 填充元组
38. for (int i = 0; i < 20; ++i) {
39. PyObject* pyTuple = PyTuple_New(3); //元组由三部分组成
40. // 组合下字符串
41. QString qst = "test string " + QString::number(i);
42. QByteArray baq = qst.toLatin1();
44. PyTuple_SetItem(pyTuple, 0, Py_BuildValue("s", baq.data())); // 字符串
45. PyTuple_SetItem(pyTuple, 1, Py_BuildValue("i", generator.generate() % 100)); // 整型
46. PyTuple_SetItem(pyTuple, 2, Py_BuildValue("f", 3.14f)); // 浮点型
47. PyTuple_SetItem(pyArgs, i, pyTuple); // 将结构体填充到列表中
48. }
49. // 调用python函数
50. PyObject* pyResult = PyObject_CallObject(pFunc, pyArgs);
52. int list_len = PyObject_Size(pyResult);// 计算返回过来的列表长度
53. qDebug() << list_len;
55. // 判单是否成功
56. if (pyResult == NULL) { PyErr_Print(); }
57. else {
58. // 解析返回值
59. for (int i = 0; i < 20; ++i) { // 已知列表长度有20个，预先不知道的话就使用上面定义的list_len
60. PyObject* pyTuple = PyList_GetItem(pyResult, i);
61. QString strVal = QString::fromUtf8(PyUnicode_AsUTF8(PyList_GetItem(pyTuple, 0)));
62. int intVal = PyLong_AsLong(PyList_GetItem(pyTuple, 1));
63. double floatVal = PyFloat_AsDouble(PyList_GetItem(pyTuple, 2));
64. qDebug() << strVal << intVal << floatVal; // 打印
65. }
66. }
67. // 清理Python变量
68. Py_DECREF(pyArgs);
69. Py_DECREF(pFunc);
70. Py_DECREF(pModule);
71. Py_DECREF(pyResult);
74. // 并销毁自上次调用Py_Initialize()以来创建并为被销毁的所有子解释器。
75. Py_Finalize();
77. }
79. MainWindow::~MainWindow()
80. {
81. delete ui;
82. }

python源码如下，文件名称仍然是 py_test.py

1. def process_data(*args):
2. result = []
3. f = open("b.txt", "w")
4. for arg in args: # 从元组中读取数据
5. strVal, intVal, floatVal = arg # 按顺序一一对应取数据
6. f.write(strVal + " " + str(intVal) + '\n') # 写文档
7. # process the data
8. processed_strVal = strVal.upper()
9. processed_intVal = intVal + 1
10. processed_floatVal = floatVal ** 2
11. sub_result = [processed_strVal, processed_intVal, processed_floatVal]
12. result.append(sub_result) # 按列表格式返回数据
13. f.close()
14. return result

--------------------------------------------------------------------------------------------------------------------------- 

具体修改内容是

1.创建对有参函数的调用，和一个定长元组，用来存放传入参数，中间还有个随机生成器

1. // 创建函数指针，有参调用
2. PyObject* pFunc= PyObject_GetAttrString(pModule, "process_data"); // 有参调用的
3. // 定义一个随机器
4. QRandomGenerator generator;
5. // 创建一个定长元组，用来存放传入参数
6. PyObject* pyArgs = PyTuple_New(20);

2.填充元组数据

每个元组类似于结构体，包含字符串，整型和浮点类型数据

1. for (int i = 0; i < 20; ++i) {
2. PyObject* pyTuple = PyTuple_New(3); //元组由三部分组成
3. // 组合下字符串
4. QString qst = "test string " + QString::number(i);
5. QByteArray baq = qst.toLatin1();
7. PyTuple_SetItem(pyTuple, 0, Py_BuildValue("s", baq.data())); // 字符串
8. PyTuple_SetItem(pyTuple, 1, Py_BuildValue("i", generator.generate() % 100)); // 整型
9. PyTuple_SetItem(pyTuple, 2, Py_BuildValue("f", 3.14f)); // 浮点型
10. PyTuple_SetItem(pyArgs, i, pyTuple); // 将结构体填充到列表中
11. }

3.对mainwindow.h的修改

 因为用到了QRandomGenerator ,所以在mainwindow.h中引入#include 头文件

1. #include
2. #include "Python.h"
3. #include
4. #include

 4.调用python函数，并输出使用返回值

注意我们传参的时候是使用元组(tuple)，返回的时候使用的列表(list)，这个见python代码

1. // 调用python函数
2. PyObject* pyResult = PyObject_CallObject(pFunc, pyArgs);
4. int list_len = PyObject_Size(pyResult);// 计算返回过来的列表长度
5. qDebug() << list_len;
7. // 判单是否成功
8. if (pyResult == NULL) { PyErr_Print(); }
9. else {
10. // 解析返回值
11. for (int i = 0; i < 20; ++i) { // 已知列表长度有20个，预先不知道的话就使用上面定义的list_len
12. PyObject* pyTuple = PyList_GetItem(pyResult, i);
13. QString strVal = QString::fromUtf8(PyUnicode_AsUTF8(PyList_GetItem(pyTuple, 0)));
14. int intVal = PyLong_AsLong(PyList_GetItem(pyTuple, 1));
15. double floatVal = PyFloat_AsDouble(PyList_GetItem(pyTuple, 2));
16. qDebug() << strVal << intVal << floatVal; // 打印
17. }
18. }

 5.python代码的修改

仍然使用py_test文件，在文件中定义process_data函数。读取tuple内容，将结构体用list包装，并使用list 返回内容如下：

1. def process_data(*args):
2. result = []
3. f = open("b.txt", "w")
4. for arg in args: # 从元组中读取数据
5. strVal, intVal, floatVal = arg # 按顺序一一对应取数据
6. f.write(strVal + " " + str(intVal) + '\n') # 写文档
7. # process the data
8. processed_strVal = strVal.upper()
9. processed_intVal = intVal + 1
10. processed_floatVal = floatVal ** 2
11. sub_result = [processed_strVal, processed_intVal, processed_floatVal]
12. result.append(sub_result) # 按列表格式返回数据
13. f.close()
14. return result

 执行结果是会在build-simple_test-Desktop_Qt_5_10_0_MSVC2015_64bit-Release文件夹下生成一个b.txt文件，并且qt端输出内容。

3. 打包部署

以上我们已经实现QT C++调用python的程序，现在我们要将项目部署在一个没有python环境下的机器上，QT打包发布成exe执行的。对代码的改动不多，对文件夹的修改移动比较多，注意一点。

由于.pro只修改一行，这里只附上mainwindow.cpp的源码

1. #include "mainwindow.h"
2. #include "ui_mainwindow.h"
4. MainWindow::MainWindow(QWidget *parent) :
5. QMainWindow(parent),
6. ui(new Ui::MainWindow)
7. {
8. ui->setupUi(this);
10. // 设置 python 路径
11. Py_SetPythonHome((wchar_t*)(L"./python_38")); // 相对位置以exe为参考
12. // 初始化python解释器.C/C++中调用Python之前必须先初始化解释器
13. Py_Initialize();
14. // 判断python解析器的是否已经初始化完成
15. if(!Py_IsInitialized())
16. qDebug()<<"[db:] Py_Initialize fail";
17. else
18. qDebug()<<"[db:] Py_Initialize success";
19. // 执行 python 语句
20. PyRun_SimpleString("print('hello world') ");
22. // 导入sys模块设置模块地址，以及python脚本路径
23. PyRun_SimpleString("import sys");
24. // 该相对路径是以build...为参考的
25. PyRun_SimpleString("sys.path.append('./py_scripts')"); //以exe为参考位置
26. // 加载 python 脚本
27. PyObject *pModule = PyImport_ImportModule("py_test"); // 脚本名称，不带.py
28. if(!pModule) // 脚本加载成功与否
29. qDebug()<<"[db:] pModule fail";
30. else
31. qDebug()<<"[db:] pModule success";
33. // 创建函数指针，有参调用
34. PyObject* pFunc= PyObject_GetAttrString(pModule, "process_data"); // 有参调用的
35. // 定义一个随机器
36. QRandomGenerator generator;
37. // 创建一个定长元组，用来存放传入参数
38. PyObject* pyArgs = PyTuple_New(20);
39. // 每个元组类似于结构体，包含字符串，整型和浮点类型数据
40. // 填充元组
41. for (int i = 0; i < 20; ++i) {
42. PyObject* pyTuple = PyTuple_New(3); //元组由三部分组成
43. // 组合下字符串
44. QString qst = "test string " + QString::number(i);
45. QByteArray baq = qst.toLatin1();
47. PyTuple_SetItem(pyTuple, 0, Py_BuildValue("s", baq.data())); // 字符串
48. PyTuple_SetItem(pyTuple, 1, Py_BuildValue("i", generator.generate() % 100)); // 整型
49. PyTuple_SetItem(pyTuple, 2, Py_BuildValue("f", 3.14f)); // 浮点型
50. PyTuple_SetItem(pyArgs, i, pyTuple); // 将结构体填充到列表中
51. }
52. // 调用python函数
53. PyObject* pyResult = PyObject_CallObject(pFunc, pyArgs);
55. int list_len = PyObject_Size(pyResult);// 计算返回过来的列表长度
56. qDebug() << list_len;
58. // 判单是否成功
59. if (pyResult == NULL) { PyErr_Print(); }
60. else {
61. // 解析返回值
62. for (int i = 0; i < 20; ++i) { // 已知列表长度有20个，预先不知道的话就使用上面定义的list_len
63. PyObject* pyTuple = PyList_GetItem(pyResult, i);
64. QString strVal = QString::fromUtf8(PyUnicode_AsUTF8(PyList_GetItem(pyTuple, 0)));
65. int intVal = PyLong_AsLong(PyList_GetItem(pyTuple, 1));
66. double floatVal = PyFloat_AsDouble(PyList_GetItem(pyTuple, 2));
67. qDebug() << strVal << intVal << floatVal; // 打印
68. }
69. }
70. // 清理Python变量
71. Py_DECREF(pyArgs);
72. Py_DECREF(pFunc);
73. Py_DECREF(pModule);
74. Py_DECREF(pyResult);
77. // 并销毁自上次调用Py_Initialize()以来创建并为被销毁的所有子解释器。
78. Py_Finalize();
80. }
82. MainWindow::~MainWindow()
83. {
84. delete ui;
85. }

具体修改如下：

1. 修改编译输出目录（生成exe的目录），到 qt_output

在项目.pro中添加

DESTDIR = $$PWD/../qt_output

与python路径合在一起展示如下。

1. FORMS += \
2. mainwindow.ui
4. DESTDIR = $$PWD/../qt_output
6. INCLUDEPATH += -I D:\output\envs\python_38\include # python.h
7. LIBS += -LD:\output\envs\python_38\libs -lpython38 # python38.lib

编译后结果如下 ，qt_output中只有exe文件，可知这个PWD的路径是以build-simple_test-Desktop_Qt_5_10_0_MSVC2015_64bit-Release为参考的

 2.将python 环境拷贝到qt_output目录下

即将python_38文件夹复制到qt_output目录下。

3.在QT C++ 中指定python 库地址

在初始化之前，添加

Py_SetPythonHome((wchar_t*)(L"./python_38")); // 相对位置以exe为参考

1. ui->setupUi(this);
3. // 设置 python 路径
4. Py_SetPythonHome((wchar_t*)(L"./python_38")); // 相对位置以exe为参考
5. // 初始化python解释器.C/C++中调用Python之前必须先初始化解释器
6. Py_Initialize();

4.将python脚本文件移入qt_output文件夹中，并修改相对路径

1. // 导入sys模块设置模块地址，以及python脚本路径
2. PyRun_SimpleString("import sys");
3. // 该相对路径是以build...为参考的
4. PyRun_SimpleString("sys.path.append('./py_scripts')"); //以exe为参考位置
5. // 加载 python 脚本
6. PyObject *pModule = PyImport_ImportModule("py_test"); // 脚本名称，不带.py

2,3,4,步执行完成后，文件夹中内容如下。

程序中运行，会在exe同文件夹下生成 b.txt

在文件夹中，点击exe文件直接运行，会出现找不到Qt5Core.dll和Qt5Widgets.dll错误。

这就用到windeployqt命令了 ，

5.开始键输入找到如图的客户端，打开后

输入windeployqt D:\workspace\qt\qt_output\simple_test.exe 具体内容根据项目路径来写，运行完成后会在qt_output文件夹中生成程序运行所需要的依赖包（具体叫啥不知道，这个是qt的东西）。

qt_output文件夹内除了以前的这些文件外，又多了些文件夹和文件（依赖库） 。

再点击simple_test.exe，则出现QT的弹窗，并且生成新的b.txt文件。

6. 经验证，还需要将python_38文件夹里面的python38.dll文件移到外面来，放在和simple.exe同一级别。

4. python 中带有第三方包的部署（忘了参考哪个了，主要是找不到参考的那个网页了）

我们首先修改下py_test.py的内容，引入numpy包，因为numpy是第三方的包。修改如下：

1. import numpy as np
3. def write_file():
4. with open("a.txt", "w") as f:
5. f.write("test")
8. def process_data(*args):
9. result = []
10. f = open("b.txt", "w")
11. for arg in args: # 从元组中读取数据
12. strVal, intVal, floatVal = arg # 按顺序一一对应取数据
13. f.write(strVal + " " + str(intVal) + '\n') # 写文档
14. # process the data
15. processed_strVal = strVal.upper()
16. processed_intVal = intVal + 1
17. processed_floatVal = floatVal ** 2
18. sub_result = [processed_strVal, processed_intVal, processed_floatVal]
19. result.append(sub_result) # 按列表格式返回数据
20. f.close()
21. arr = np.array(result)
22. return result

 在返回之前，生成一个并不使用的变量arr = np.array(result)，这个我们就是为了测试第三方包而做的，生成的arr没有任何意义。

再次点击simple_test.exe不会生成b.txt，表示python脚本程序运行错误，第三方包调用失败。

解决方法

1.使用pyinstaller生成依赖文件

这个就需要我们python 的一个包了，需要pip(conda)安装pyinstaller。因为我这里供QT C++ 使用的python环境(D:\workspace\qt\qt_output\python_38)是从D:\miniconda3\envs\cat虚拟环境中复制出来的部分，所以我使用的是激活cat的虚拟环境，并再这里面执行pyinstaller，生成依赖文件。

1. (cat) PS D:\tmp> conda activate cat
2. (cat) PS D:\tmp> cd d:/tmp
3. (cat) PS D:\tmp> pyinstaller D:\workspace\qt\qt_output\py_scripts\py_test.py

1.激活环境，2.生成的依赖在那个文件夹中（随便写的一个文件夹），3.对那个python文件生成依赖

执行完成之后，会在d:/tmp中生成两个文件夹，dist 和 build 

2.我们将dist/py_test/_internal 中的所有文件（夹）全部复制到QT编译生成的qt_output文件夹中

将得到依赖包的qt_output文件夹放在在新机器上部署执行带有第三方包就没有问题了

经本人测试包括cv2包也可以，但是本人对matlablib这个包没有导入成功。

其他说明

1.qt生成的文件一定要注意他们的相对位置，是相对于哪一个文件的位置。

2.QT C++调用python 后，我没有能够进行调试，不知道是什么原因不能调试。

3.python 和C++ 的数据类型，有些QT C++数据类型传到python中不好使用，主要我对QT和C++不了解。

4.带有第三方打包的就比普通打包部署多一步，这一步需要pyinstaller生成动态链接库等文件，复制进和QT C++ 生成的exe同一个文件夹中。

参考网页

Qt调用Python详细图文过程记录_python_脚本之家

在QT C++中调用 Python并将软件打包发布（裸机可运行）_互联网集市

C++调用python脚本 - 知乎

如何在C++中使用一个Python类-[PyImport_ImportModule、PyModule_GetDict、PyDict_GetItemString、PyObject_CallFuncti]-CSDN博客

Qt项目中C++调用Python函数传多参问题_qt调用python_平头猿小哥的博客-CSDN博客

C++调用Python（混合编程）函数整理总结_jindayue的博客-CSDN博客

PyObject_CallObject, PyObject_Call, PyObject_CallFunction使用例子-CSDN博客

Qt C++ Python 混合编程测试文档 - 知乎