Qt调用Python-源代码

SharpTrader0_01.pro

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++11

# You can make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
    QPython.cpp \
    main.cpp \
    mainwindow.cpp

HEADERS += \
    QPython.h \
    mainwindow.h

FORMS += \
    mainwindow.ui


INCLUDEPATH += C:/Users/Mcwhirr/AppData/Local/Programs/Python/Python37/include

LIBS += -LC:/Users/Mcwhirr/AppData/Local/Programs/Python/Python37/libs -lpython37


# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

 

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QProcess>
#include <QtDebug>
#include <QApplication>
#include "QPython.h"

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void OnReadData();

signals:
    void readyReadStandardOutput();

private:
    Ui::MainWindow *ui;
    QProcess *process1;
};
#endif // MAINWINDOW_H

QPython.h

#ifndef QPYTHON_H
#define QPYTHON_H

#undef slots
#include <Python.h>
#define slots Q_SLOTS
#include <QObject>
#include <QVariant>

/**
 * @className QPython
 * @brief excute PY
 * @author Mcwhirr
 * @date 2022-1-8
**/

class QPython
{
public:
    explicit QPython(const char *module);
    ~QPython();

    bool callPyFunc(const char *func,const QVariantList &args = QVariantList(),QVariant *backVar = nullptr);
private:
    PyObject *m_pModule = nullptr;
};



#endif // QPYTHON_H

main.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QCoreApplication>
#include <QApplication>
#include <QProcess>
#include <QDebug>
#include "QPython.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "QPython.h"
#include <QProcess>
#include <QtDebug>


MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

   QPython pyExcute("pyCon");
   QVariant var = 0;
   QVariantList args = {1,5};
   bool rc = pyExcute.callPyFunc("add",args,&var);
   QTextBrowser *textBrowser = new QTextBrowser;
   ui->textBrowser->insertPlainText(var.toString());

    QStringList args1("F:/SharpTrader0_01/SharpTrader0_01/hello.py");

    QProcess process1;
//    process1->start();
//    process1->waitForStarted();
//    process1->execute(QString("Python.exe"),args1);

    process1.start("cmd.exe");//直接启动python程序，而不是通过bash
    QByteArray Output = process1.readAllStandardOutput();
    QString str = "dir ";
    const char *cstr = str.toLocal8Bit().constData();
    process1.write(cstr);
    QString result = Output;
    qDebug()<<result;
    process1.waitForFinished();

    QStringList arguments;
    arguments << "/c" << "python D:/ProjBach_0_1/HEXCvt.py";
    QProcess process(this);
    process.start("cmd.exe", arguments);



    process.waitForStarted();
    process.waitForFinished();
    QString strResult = QString::fromLocal8Bit(process.readAllStandardOutput());
    QTextBrowser *textBrowser1 = new QTextBrowser;
    ui->textBrowser1->setText(strResult);

//    connect(process1,SIGNAL(readyReadStandardOutput()),this,SLOT(OnReadData()));
}

void MainWindow::OnReadData(){
    //打印出输出
    QByteArray Output = process1->readAllStandardOutput();
    QString result = Output;
    QTextBrowser *textBrowser1 = new QTextBrowser;
    ui->textBrowser1->setText(result);

}

MainWindow::~MainWindow()
{
    delete ui;
}

QPython.cpp

#include "QPython.h"
#include <QVariant>
#include <QtDebug>

QPython::QPython(const char *module)
{
    //设置py home 打包用
    //char homePath[] = "python37;
    //Py_SetPythonHome(homePath);
    //进行初始化
    Py_Initialize();

    PyRun_SimpleString("import sys");
    PyRun_SimpleString("sys.path.append('./')");

    //如果初始化失败 返回
    if(!Py_IsInitialized()){
        qDebug()<<__FUNCTION__<<"fail"<<"py init fail";
        return;
    }

    //加载模块，模块名称为myModule,就是mymodule.py文件
    m_pModule = PyImport_ImportModule(module);

}

QPython::~QPython()
{
    Py_Finalize();
}

bool QPython::callPyFunc(const char *func, const QVariantList &args, QVariant *backVar)
{
    if(m_pModule == nullptr){
        qDebug() << __FUNCTION__ <<"Mcwhirr"<<"module is null";
        return false;
    }
    //加载函数greateFunc
    PyObject *pFuncHello = PyObject_GetAttrString(m_pModule,func);
    //如果失败则返回
    if(!pFuncHello){
        qDebug() <<__FUNCTION__<<"Mcwhirr"<<"load function fail";
        return false;
    }

    PyObject* pArgs = PyTuple_New(args.size());
    for(int i = 0; i < args.size(); ++i){
        QVariant arg = args.at(i);
        switch (arg.type()) {
        case QVariant::String:
        {
            QString str = arg.toString( );
            std::string str2 = str.toStdString( );
            const char *ch = str2.c_str( );
            PyTuple_SetItem(pArgs,i , Py_BuildValue("s", ch));
        }
            break;
        case QVariant::Int:
            PyTuple_SetItem(pArgs,i,Py_BuildValue("i",arg.toInt()));
            break;
        case QVariant::Double:
            PyTuple_SetItem(pArgs,i,Py_BuildValue("d",arg.toDouble()));
            break;

        default:
            break;

        }
    }

    //调用函数
    auto pReturn = PyObject_CallObject(pFuncHello,pArgs);

    if(backVar){
        switch (backVar->type()) {
        case QVariant::String:
        {
            char *s = nullptr;
            PyArg_Parse(pReturn,"s",&s);
            QString str(s);
            *backVar = QVariant::fromValue(str);
        }
            break;
        case QVariant::Int:
        {
            int nResult;
            PyArg_Parse(pReturn,"i",&nResult);
            *backVar = QVariant::fromValue(nResult);
        }
            break;
        case QVariant::Double:
        {
           double dResult;
           PyArg_Parse(pReturn,"d",&dResult);
           *backVar = QVariant::fromValue(dResult);
        }
            break;
        default:
            break;
        }
    }
    return pReturn !=nullptr;
}