PyQT5 （六十六） Javascript 调用 PyQt5 代码 的案例

最新推荐文章于 2023-05-25 11:31:47 发布
最新推荐文章于 2023-05-25 11:31:47 发布
阅读量807 收藏 4
点赞数
分类专栏： pyqt5 文章标签： qt python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gixome/article/details/120965784
版权

Javascript 调用 PyQt5 代码 的案例
PyQt5 和 Javascript 交互
什么叫交互
互相调用
PyQt5 <--> Javascript
JavaScript 调用Python函数计算阶乘
将Python 的 一个对象映射到JavaScript中

import os
import sys

from PyQt5.QtCore import QUrl, QObject, pyqtSlot
from PyQt5.QtGui import QIcon
from PyQt5.QtWebChannel import QWebChannel
from PyQt5.QtWebEngineWidgets import QWebEngineView
from PyQt5.QtWidgets import QMainWindow, QHBoxLayout, QPushButton, QMessageBox, QApplication, QVBoxLayout, QWidget

'''
Javascript 调用 PyQt5 代码 的案例
PyQt5 和 Javascript 交互
什么叫交互
互相调用
PyQt5 <--> Javascript
JavaScript 调用Python函数计算阶乘
将Python 的 一个对象映射到JavaScript中
'''


class Factorial(QObject):
    @pyqtSlot(int, result=int)
    def factorial(self, n):
        if n == 0 or n == 1:
            return 1
        else:
            return self.factorial(n - 1) * n


# f=Factorial()
# print(f.factorial(10))

channel = QWebChannel()
factorial = Factorial()


class PyFactorialDemo(QWidget):

    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        # 设置定位和左上角坐标
        self.setGeometry(300, 300, 360, 260)
        # 设置窗口标题
        self.setWindowTitle('PyQt5 调用 Javascript代码 的演示')
        # 设置窗口图标
        # self.setWindowIcon(QIcon('../web.ico'))

        self.layout = QVBoxLayout()
        self.browser = QWebEngineView()
        url = os.getcwd() + '/f.html'
        print(url)
        self.browser.load(QUrl.fromLocalFile(url))
        # self.setCentralWidget(self.browser)
        channel.registerObject("obj", factorial)
        self.browser.page().setWebChannel(channel)
        self.layout.addWidget(self.browser)

        # button = QPushButton('设置全名')
        # button.clicked.connect(self.fullname)
        # self.layout.addWidget(button)
        self.setLayout(self.layout)

    # 用于获取返回值的回调函数
    def js_callback(self, result):
        print(result)

    # 执行js的函数,传参数,并获取返回值
    def fullname(self):
        self.value = '李 成龙'
        self.browser.page().runJavaScript('fullname("' + self.value + '");', self.js_callback)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    # 设置应用图标
    app.setWindowIcon(QIcon('../web.ico'))
    w = PyFactorialDemo()
    w.show()
    sys.exit(app.exec_())

 f.html

<html>
<head>
    <meta charset="UTF-8">
    <title>A Demo Page</title>
    <script src="./qwebchannel.js"></script>
    <script language="javascript">
        function callback(result){
            alert('计算结果:' + result);
        }

        document.addEventListener("DOMContentLoaded",function(){
            new QWebChannel( qt.webChannelTransport,function(channel){
                window.obj = channel.objects.obj;
            });
        });

        function onFactorial(){
            if(window.obj){
                var n = parseInt(document.getElementById('n').value);
                console.log(n);
                window.obj.factorial(n,callback);
            }
        }
    </script>
</head>
<body>
<form>
    <label>请输入N:</label>
    <input type="text" id="n"/>
    <br>
    <input type="button" value="计算阶乘" onclick="onFactorial()"></input>
</form>
</body>
</html>

qwebchannel.js

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Copyright (C) 2016 Klar채lvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtWebChannel module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

"use strict";

var QWebChannelMessageTypes = {
    signal: 1,
    propertyUpdate: 2,
    init: 3,
    idle: 4,
    debug: 5,
    invokeMethod: 6,
    connectToSignal: 7,
    disconnectFromSignal: 8,
    setProperty: 9,
    response: 10,
};

var QWebChannel = function(transport, initCallback)
{
    if (typeof transport !== "object" || typeof transport.send !== "function") {
        console.error("The QWebChannel expects a transport object with a send function and onmessage callback property." +
                      " Given is: transport: " + typeof(transport) + ", transport.send: " + typeof(transport.send));
        return;
    }

    var channel = this;
    this.transport = transport;

    this.send = function(data)
    {
        if (typeof(data) !== "string") {
            data = JSON.stringify(data);
        }
        channel.transport.send(data);
    }

    this.transport.onmessage = function(message)
    {
        var data = message.data;
        if (typeof data === "string") {
            data = JSON.parse(data);
        }
        switch (data.type) {
            case QWebChannelMessageTypes.signal:
                channel.handleSignal(data);
                break;
            case QWebChannelMessageTypes.response:
                channel.handleResponse(data);
                break;
            case QWebChannelMessageTypes.propertyUpdate:
                channel.handlePropertyUpdate(data);
                break;
            default:
                console.error("invalid message received:", message.data);
                break;
        }
    }

    this.execCallbacks = {};
    this.execId = 0;
    this.exec = function(data, callback)
    {
        if (!callback) {
            // if no callback is given, send directly
            channel.send(data);
            return;
        }
        if (channel.execId === Number.MAX_VALUE) {
            // wrap
            channel.execId = Number.MIN_VALUE;
        }
        if (data.hasOwnProperty("id")) {
            console.error("Cannot exec message with property id: " + JSON.stringify(data));
            return;
        }
        data.id = channel.execId++;
        channel.execCallbacks[data.id] = callback;
        channel.send(data);
    };

    this.objects = {};

    this.handleSignal = function(message)
    {
        var object = channel.objects[message.object];
        if (object) {
            object.signalEmitted(message.signal, message.args);
        } else {
            console.warn("Unhandled signal: " + message.object + "::" + message.signal);
        }
    }

    this.handleResponse = function(message)
    {
        if (!message.hasOwnProperty("id")) {
            console.error("Invalid response message received: ", JSON.stringify(message));
            return;
        }
        channel.execCallbacks[message.id](message.data);
        delete channel.execCallbacks[message.id];
    }

    this.handlePropertyUpdate = function(message)
    {
        message.data.forEach(data => {
            var object = channel.objects[data.object];
            if (object) {
                object.propertyUpdate(data.signals, data.properties);
            } else {
                console.warn("Unhandled property update: " + data.object + "::" + data.signal);
            }
        });
        channel.exec({type: QWebChannelMessageTypes.idle});
    }

    this.debug = function(message)
    {
        channel.send({type: QWebChannelMessageTypes.debug, data: message});
    };

    channel.exec({type: QWebChannelMessageTypes.init}, function(data) {
        for (const objectName of Object.keys(data)) {
            new QObject(objectName, data[objectName], channel);
        }

        // now unwrap properties, which might reference other registered objects
        for (const objectName of Object.keys(channel.objects)) {
            channel.objects[objectName].unwrapProperties();
        }

        if (initCallback) {
            initCallback(channel);
        }
        channel.exec({type: QWebChannelMessageTypes.idle});
    });
};

function QObject(name, data, webChannel)
{
    this.__id__ = name;
    webChannel.objects[name] = this;

    // List of callbacks that get invoked upon signal emission
    this.__objectSignals__ = {};

    // Cache of all properties, updated when a notify signal is emitted
    this.__propertyCache__ = {};

    var object = this;

    // ----------------------------------------------------------------------

    this.unwrapQObject = function(response)
    {
        if (response instanceof Array) {
            // support list of objects
            return response.map(qobj => object.unwrapQObject(qobj))
        }
        if (!(response instanceof Object))
            return response;

        if (!response["__QObject*__"] || response.id === undefined) {
            var jObj = {};
            for (const propName of Object.keys(response)) {
                jObj[propName] = object.unwrapQObject(response[propName]);
            }
            return jObj;
        }

        var objectId = response.id;
        if (webChannel.objects[objectId])
            return webChannel.objects[objectId];

        if (!response.data) {
            console.error("Cannot unwrap unknown QObject " + objectId + " without data.");
            return;
        }

        var qObject = new QObject( objectId, response.data, webChannel );
        qObject.destroyed.connect(function() {
            if (webChannel.objects[objectId] === qObject) {
                delete webChannel.objects[objectId];
                // reset the now deleted QObject to an empty {} object
                // just assigning {} though would not have the desired effect, but the
                // below also ensures all external references will see the empty map
                // NOTE: this detour is necessary to workaround QTBUG-40021
                Object.keys(qObject).forEach(name => delete qObject[name]);
            }
        });
        // here we are already initialized, and thus must directly unwrap the properties
        qObject.unwrapProperties();
        return qObject;
    }

    this.unwrapProperties = function()
    {
        for (const propertyIdx of Object.keys(object.__propertyCache__)) {
            object.__propertyCache__[propertyIdx] = object.unwrapQObject(object.__propertyCache__[propertyIdx]);
        }
    }

    function addSignal(signalData, isPropertyNotifySignal)
    {
        var signalName = signalData[0];
        var signalIndex = signalData[1];
        object[signalName] = {
            connect: function(callback) {
                if (typeof(callback) !== "function") {
                    console.error("Bad callback given to connect to signal " + signalName);
                    return;
                }

                object.__objectSignals__[signalIndex] = object.__objectSignals__[signalIndex] || [];
                object.__objectSignals__[signalIndex].push(callback);

                // only required for "pure" signals, handled separately for properties in propertyUpdate
                if (isPropertyNotifySignal)
                    return;

                // also note that we always get notified about the destroyed signal
                if (signalName === "destroyed" || signalName === "destroyed()" || signalName === "destroyed(QObject*)")
                    return;

                // and otherwise we only need to be connected only once
                if (object.__objectSignals__[signalIndex].length == 1) {
                    webChannel.exec({
                        type: QWebChannelMessageTypes.connectToSignal,
                        object: object.__id__,
                        signal: signalIndex
                    });
                }
            },
            disconnect: function(callback) {
                if (typeof(callback) !== "function") {
                    console.error("Bad callback given to disconnect from signal " + signalName);
                    return;
                }
                object.__objectSignals__[signalIndex] = object.__objectSignals__[signalIndex] || [];
                var idx = object.__objectSignals__[signalIndex].indexOf(callback);
                if (idx === -1) {
                    console.error("Cannot find connection of signal " + signalName + " to " + callback.name);
                    return;
                }
                object.__objectSignals__[signalIndex].splice(idx, 1);
                if (!isPropertyNotifySignal && object.__objectSignals__[signalIndex].length === 0) {
                    // only required for "pure" signals, handled separately for properties in propertyUpdate
                    webChannel.exec({
                        type: QWebChannelMessageTypes.disconnectFromSignal,
                        object: object.__id__,
                        signal: signalIndex
                    });
                }
            }
        };
    }

    /**
     * Invokes all callbacks for the given signalname. Also works for property notify callbacks.
     */
    function invokeSignalCallbacks(signalName, signalArgs)
    {
        var connections = object.__objectSignals__[signalName];
        if (connections) {
            connections.forEach(function(callback) {
                callback.apply(callback, signalArgs);
            });
        }
    }

    this.propertyUpdate = function(signals, propertyMap)
    {
        // update property cache
        for (const propertyIndex of Object.keys(propertyMap)) {
            var propertyValue = propertyMap[propertyIndex];
            object.__propertyCache__[propertyIndex] = this.unwrapQObject(propertyValue);
        }

        for (const signalName of Object.keys(signals)) {
            // Invoke all callbacks, as signalEmitted() does not. This ensures the
            // property cache is updated before the callbacks are invoked.
            invokeSignalCallbacks(signalName, signals[signalName]);
        }
    }

    this.signalEmitted = function(signalName, signalArgs)
    {
        invokeSignalCallbacks(signalName, this.unwrapQObject(signalArgs));
    }

    function addMethod(methodData)
    {
        var methodName = methodData[0];
        var methodIdx = methodData[1];

        // Fully specified methods are invoked by id, others by name for host-side overload resolution
        var invokedMethod = methodName[methodName.length - 1] === ')' ? methodIdx : methodName

        object[methodName] = function() {
            var args = [];
            var callback;
            var errCallback;
            for (var i = 0; i < arguments.length; ++i) {
                var argument = arguments[i];
                if (typeof argument === "function")
                    callback = argument;
                else if (argument instanceof QObject && webChannel.objects[argument.__id__] !== undefined)
                    args.push({
                        "id": argument.__id__
                    });
                else
                    args.push(argument);
            }

            var result;
            // during test, webChannel.exec synchronously calls the callback
            // therefore, the promise must be constucted before calling
            // webChannel.exec to ensure the callback is set up
            if (!callback && (typeof(Promise) === 'function')) {
              result = new Promise(function(resolve, reject) {
                callback = resolve;
                errCallback = reject;
              });
            }

            webChannel.exec({
                "type": QWebChannelMessageTypes.invokeMethod,
                "object": object.__id__,
                "method": invokedMethod,
                "args": args
            }, function(response) {
                if (response !== undefined) {
                    var result = object.unwrapQObject(response);
                    if (callback) {
                        (callback)(result);
                    }
                } else if (errCallback) {
                  (errCallback)();
                }
            });

            return result;
        };
    }

    function bindGetterSetter(propertyInfo)
    {
        var propertyIndex = propertyInfo[0];
        var propertyName = propertyInfo[1];
        var notifySignalData = propertyInfo[2];
        // initialize property cache with current value
        // NOTE: if this is an object, it is not directly unwrapped as it might
        // reference other QObject that we do not know yet
        object.__propertyCache__[propertyIndex] = propertyInfo[3];

        if (notifySignalData) {
            if (notifySignalData[0] === 1) {
                // signal name is optimized away, reconstruct the actual name
                notifySignalData[0] = propertyName + "Changed";
            }
            addSignal(notifySignalData, true);
        }

        Object.defineProperty(object, propertyName, {
            configurable: true,
            get: function () {
                var propertyValue = object.__propertyCache__[propertyIndex];
                if (propertyValue === undefined) {
                    // This shouldn't happen
                    console.warn("Undefined value in property cache for property \"" + propertyName + "\" in object " + object.__id__);
                }

                return propertyValue;
            },
            set: function(value) {
                if (value === undefined) {
                    console.warn("Property setter for " + propertyName + " called with undefined value!");
                    return;
                }
                object.__propertyCache__[propertyIndex] = value;
                var valueToSend = value;
                if (valueToSend instanceof QObject && webChannel.objects[valueToSend.__id__] !== undefined)
                    valueToSend = { "id": valueToSend.__id__ };
                webChannel.exec({
                    "type": QWebChannelMessageTypes.setProperty,
                    "object": object.__id__,
                    "property": propertyIndex,
                    "value": valueToSend
                });
            }
        });

    }

    // ----------------------------------------------------------------------

    data.methods.forEach(addMethod);

    data.properties.forEach(bindGetterSetter);

    data.signals.forEach(function(signal) { addSignal(signal, false); });

    Object.assign(object, data.enums);
}

//required for use with nodejs
if (typeof module === 'object') {
    module.exports = {
        QWebChannel: QWebChannel
    };
}

ggome
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
PyQt5最全68 Web之PyQt5调用JavaScript代码
爱吃肉的牛牛的博客
12-14 1983
PyQt5最全68 PyQt5调用JavaScript代码 from PyQt5.QtWidgets import * from PyQt5.QtCore import * from PyQt5.QtWebEngineWidgets import * import sys import os class WebEngineView(QWidget): """ PyQt5调用JavaScript代码 PyQt5和JavaScrip交互 什么叫交互 PyQt5&lt
PyQt5 JavaScript调用PyQt代码
SongYuLong
11-26 1269
创建QWebChannel对象，注册一个需要桥接的对象，以便Web页面的JavaScript使用。JavaScript调用PyQt代码,是指PyQt可以与加载的Web页面进行双向的数据交互。JavaScript调用PyQt代码演示。'\n从pyqt传来的参数='
PyQt JS调用Py
weixin_33774883的博客
04-26 414
JS 调用 PyQt HTML <!-- js...
PyQt5中的信号与槽，js 与 Qt 对象之间互相调用
weixin_30267785的博客
04-10 258
一、PyQt中的信号与槽 信号（Signal）和槽（Slot）是Qt中的核心机制，用在对象之间互相通信。在Qt中每个QObject对象和PyQt中所有继承自QWidget的控件（这些都是QObject的子对象）都支持信号与槽机制。当信号发射时，连接的槽函数将会执行。在PyQt5中信号与槽通过object.signal.connect()方法连接。 1.1 关于信号和槽的常识 Qt 提供了...
PyQt5使用QtWebEngineWidgets调用js
Happinessคิดถึง的博客
03-24 1022
PyQt5使用QtWebEngineWidgets调用js
PyQt5 runJavaScript的使用
tymatlab的专栏
11-27 4595
PyQt5 runJavaScript的使用示例代码：from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton from PyQt5.QtWebEngineWidgets import QWebEnginePage, QWebEngineView# Create an application app = Q
Python+HTML+PyQT5进行桌面开发应用
04-09
PyQT5是Python的一个图形用户界面工具包，它提供了QWebEngineView组件，允许开发者将网页技术融入到桌面应用中，同时通过QWebChannel实现了Python与JavaScript之间的高效交互。 QWebEngineView是PyQT5中的一个关键...
PyQt5内嵌浏览器注入JavaScript脚本实现自动化操作的代码实例
10-17
在PyQt5中，我们可以利用QWebEngineView组件来创建一个内嵌的浏览器，并通过注入JavaScript脚本来实现自动化操作。这个功能在自动化测试、数据抓取或者特定的用户交互场景中非常有用。以下是一个详细解释如何实现这...
如何让PyQt5中QWebEngineView与JavaScript交互
01-19
pip install PyQt5 pip install PyQtWebEngine Python端 1.使用QWebChannel的registerObject（”JsBridge名”,”JsBridge”）方法注册回调 JsBridge名：在JavaScript中调用时使用的对象名称 JsBridge：被...
PyQt5 PyQt5
05-18
PyQt5是Python编程语言中一个非常重要的图形用户界面（GUI）工具包，它基于Qt5框架，并由Riverbank Computing公司开发和维护。PyQt5允许开发者利用Python的简洁性和Qt的强大功能来创建桌面应用程序。在本文中，我们...
QT和网页中的JavaScript函数进行相互调用的实现
04-06
QT和网页中的JavaScript函数进行相互调用的实现. 有完整的代码举例。 近期刚完成。
pyqt5的QWebEngineView 使用模板的方法
01-20
除了上述内容，开发者在使用PyQT5的QWebEngineView时，还可以探索更多高级功能，例如拦截和处理JavaScript的事件、设置网页内容的加载进度、注入CSS样式、启用或禁用JavaScript执行、与JavaScript代码交互等。...
pyqt5的runJavaScript 使用模板
一心狮的博客
08-27 5112
runJavaScript 的说明 QWebEnginePage 有一个 runJavaScript 方法，支持回调函数。 使用方法1 只运行JavaScript，没有回调 def run_js(self): js_string = ''' alert("hello,world！"); ''' self.webv...
PyQt QtWebChannel：从JavaScript调用Python函数
ieeso的博客
09-03 1696
我正在尝试，使用Qt类QWebEngineView，并QWebChannel在HTML页面和Python脚本之间建立一个简单的连接。目标只是在单击foo()标题时执行&lt;h2&gt;。 import sys from PyQt5.QtCore import pyqtSlot from PyQt5.QtWidgets import QApplication from PyQt5.QtWebCh...
小白白也能学会的 PyQt 教程 —— 关于 runJavaScript 无法加载 JavaScript 脚本的解决方法
繁依Fanyi的博客
05-25 383
可以正确加载页面，并且在浏览器中运行 JavaScript 代码也没有问题，那么可能的原因是在。这样做可以确保 JavaScript 代码在页面加载完成后执行，以提供正确的环境和上下文。为了确保页面加载完成后再执行 JavaScript 代码，您可以使用。这个信号在页面加载完成后触发，可以在信号的槽函数中调用。参数的值，以确保页面成功加载。来执行您的 JavaScript 代码。当页面加载完成时，将调用。调用之前页面还没有完全加载完成。函数，并在函数内部检查。
PyQt调用JavaScript代码时传递参数的类型为列表
hello_world_banni的博客
05-21 663
在PyQt5对象中访问JavaScript的核心代码如下： QWebEnginePage.runJavaScript(str,Callable); 可以看到，传递参数只能是字符串类型。 所以我们可以采用在Pyqt端列表转字符串，在JavaScript端字符串转列表的方式。 如想要传递的列表为： obj=[["hello","world"],["banni"],["hahaha","!"]] PyQt端代码为： for i in range(len(obj)): obj[i]="+".join(obj[
QWebEngineView runJavaScript 的单双引号变量赋值问题完美解决，单换双双换单
viviliving的专栏
01-30 559
def set_sqlfilersadd(self, framelink): options = self.chartlist[framelink] print(options) options = options.replace('\n', '<br/>') options = options.replace('\'', '\u0022') 单换双 options = options.replace('\"', '\u0027...
PyQt5调用JavaScript代码
SongYuLong
11-26 851
通过QWebEnginePage类的runJavaScript(str, Callable)函数可以方便地实现PyQt和HTML/JavaScript的双向通信。
PyQT5 （六十五） PyQt5 调用 Javascript代码 的案例 PyQt5 和 Javascript 交互
Ggome的博客
10-25 1240
PyQt5 调用 Javascript代码 的案例 PyQt5 和 Javascript 交互 什么叫交互 互相调用 PyQt5 <--> Javascript tt.html <!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>测试JS表单页面</title> <script> ...
pyqt5浏览器调用py函数
最新发布
07-27
在PyQt5中，你可以使用JavaScript与Python函数进行交互，从而实现在浏览器中调用PyQt5中的函数。下面是一个简单的示例代码，演示了如何在PyQt5的浏览器组件中调用Python函数： ```python from PyQt5.QtCore import QUrl, pyqtSlot from PyQt5.QtWidgets import QApplication from PyQt5.QtWebEngineWidgets import QWebEngineView app = QApplication([]) class BrowserView(QWebEngineView): def __init__(self): super().__init__() # 加载网页 self.load(QUrl("https://example.com")) # 将Python函数绑定到JavaScript的window对象上 self.page().runJavaScript("window.pyFunction = function() { pyFunction(); };") # 定义一个Python函数，供JavaScript调用 @pyqtSlot() def pyFunction(self): print("Python函数被调用") # 监听浏览器加载完成的信号 def loadFinished(self, ok): if ok: # 在加载完成后，执行JavaScript代码调用Python函数 self.page().runJavaScript("window.pyFunction();") browser_view = BrowserView() browser_view.show() app.exec_() ``` 在上述代码中，我们创建了一个继承自QWebEngineView的自定义类BrowserView，其中定义了一个Python函数pyFunction，并使用@pyqtSlot装饰器将其与JavaScript函数绑定。在构造函数中，我们加载了一个示例网页，并通过runJavaScript方法将pyFunction函数绑定到JavaScript的window对象上。然后，在loadFinished函数中，我们执行JavaScript代码调用Python函数。 当你运行这段代码时，浏览器组件将加载示例网页，并在加载完成后调用Python函数pyFunction，然后在控制台打印"Python函数被调用"。 你可以根据你的具体需求修改这个示例代码，将你想要在浏览器中调用的Python函数添加到BrowserView类中，并在JavaScript中绑定和调用它们。 希望这可以帮助到你！如果还有其他问题，请随时提问。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值