python的pywebview库结合Flask和waitress开发桌面应用程序完整代码_Python

pywebview的用途与特点

用途
pywebview是一个轻量级python库，用于创建桌面应用程序（gui）。它通过嵌入web浏览器组件（如windows的edge/ie、macos的webkit、linux的gtk webkit），允许开发者使用html/css/javascript构建界面，并用python处理后端逻辑。这种方式结合了web技术的灵活性和python的强大功能，适合快速开发跨平台桌面应用。

特点

跨平台支持：原生支持windows、macos、linux，无需额外配置。
轻量级：无需完整的浏览器，仅依赖系统内置web组件。
双向通信：html前端与python后端可互相调用函数。
简单易用：api简洁，学习成本低。
资源占用少：相比electron等框架，内存占用更小。

基本使用方法

1. 安装

pip install pywebview

2. 简单示例（python与html交互）

import webview
def print_message(message):
    print(f"收到前端消息: {message}")
# 创建一个html字符串作为界面
html = """
<!doctype html>
<html>
<head>
    <title>pywebview示例</title>
</head>
<body>
    <button onclick="python.print_message('你好，python！')">发送消息到python</button>
    <script>
        // 调用python函数
        window.python = pywebview.api;
    </script>
</body>
</html>
"""
# 创建窗口并加载html
window = webview.create_window("pywebview应用", html=html)
webview.start(gui=none, debug=true)  # gui=none自动选择系统默认浏览器引擎

结合flask与waitress开发应用

架构设计

flask：提供web api，处理业务逻辑。
pywebview：作为桌面应用的外壳，加载flask的web界面。
waitress：在生产环境中替代flask内置服务器，提供更好的性能。

开发环境代码示例

# app.py - flask后端
from flask import flask, jsonify
app = flask(__name__)
@app.route('/')
def index():
    return """
    <!doctype html>
    <html>
    <head>
        <title>flask + pywebview应用</title>
    </head>
    <body>
        <h1>hello from flask!</h1>
        <button onclick="fetchdata()">获取数据</button>
        <div id="result"></div>
        <script>
            async function fetchdata() {
                const response = await fetch('/api/data');
                const data = await response.json();
                document.getelementbyid('result').textcontent = data.message;
            }
        </script>
    </body>
    </html>
    """
@app.route('/api/data')
def get_data():
    return jsonify({"message": "这是来自flask后端的数据！"})
if __name__ == '__main__':
    # 开发环境：使用flask内置服务器
    app.run(debug=true, port=5000)

# desktop.py - pywebview桌面应用包装
import webview
import threading
import subprocess
def run_flask():
    # 启动flask应用（开发环境）
    subprocess.run(['python', 'app.py'])
if __name__ == '__main__':
    # 在后台线程中启动flask
    flask_thread = threading.thread(target=run_flask, daemon=true)
    flask_thread.start()
    # 创建pywebview窗口，加载flask应用
    window = webview.create_window("桌面应用", "http://localhost:5000")
    webview.start(gui=none, debug=true)

生产环境配置（使用waitress）

1. 修改flask应用（app.py）

# app.py - flask后端（生产环境）
from flask import flask, jsonify
app = flask(__name__)
@app.route('/')
def index():
    return """
    <!-- 同上，html内容 -->
    """
@app.route('/api/data')
def get_data():
    return jsonify({"message": "这是来自flask后端的数据！"})
# 移除开发环境的app.run()，改为导出app实例

2. 使用waitress启动flask

# server.py - 使用waitress启动flask（生产环境）
from waitress import serve
from app import app
if __name__ == '__main__':
    serve(app, host='127.0.0.1', port=5000, threads=8)  # 生产环境使用waitress

3. 修改pywebview应用（desktop.py）

# desktop.py - pywebview桌面应用（生产环境）
import webview
import threading
import subprocess
def run_flask():
    # 启动flask应用（生产环境使用waitress）
    subprocess.run(['python', 'server.py'])
if __name__ == '__main__':
    # 在后台线程中启动flask
    flask_thread = threading.thread(target=run_flask, daemon=true)
    flask_thread.start()
    # 创建pywebview窗口，加载flask应用
    window = webview.create_window("桌面应用", "http://localhost:5000")
    webview.start(gui=none, debug=false)  # 生产环境关闭调试模式

打包应用的建议

为了将应用分发给最终用户，可以使用pyinstaller或cx_freeze将python代码打包成单个可执行文件：

# 使用pyinstaller打包
pyinstaller --onefile --windowed desktop.py

注意事项：

打包时需确保包含所有依赖项（如flask、waitress、pywebview）。
在macos/linux上可能需要额外配置以确保webview组件正确加载。

总结

通过结合pywebview、flask和waitress，可以开发出兼具美观界面和强大功能的跨平台桌面应用：

开发阶段：使用flask内置服务器和调试模式，提高开发效率。
生产阶段：使用waitress替代flask服务器，提升性能和稳定性。
部署阶段：使用pyinstaller打包为独立可执行文件，方便分发。

完整代码

以下是在windows平台上结合pywebview、flask和waitress的完整代码实现。代码分为三个主要文件，分别负责flask后端、桌面应用包装和生产环境启动。

1. flask后端代码（app.py）

# app.py - flask后端应用
from flask import flask, jsonify, render_template_string
import os
app = flask(__name__)
# 确保中文正常显示
app.config['json_as_ascii'] = false
# 首页路由
@app.route('/')
def index():
    return render_template_string("""
    <!doctype html>
    <html lang="zh-cn">
    <head>
        <meta charset="utf-8">
        <title>pywebview + flask应用</title>
        <style>
            body { font-family: 'microsoft yahei', sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
            .container { background-color: #f9f9f9; border-radius: 8px; padding: 20px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
            h1 { color: #333; }
            button { background-color: #4caf50; color: white; border: none; padding: 10px 20px; 
                    text-align: center; text-decoration: none; display: inline-block; 
                    font-size: 16px; margin: 4px 2px; cursor: pointer; border-radius: 4px; }
            #result { margin-top: 20px; padding: 10px; background-color: #e8f5e9; border-radius: 4px; }
        </style>
    </head>
    <body>
        <div class="container">
            <h1>pywebview + flask桌面应用</h1>
            <p>这是一个基于web技术的跨平台桌面应用示例。</p>
            <button onclick="fetchdata()">获取数据</button>
            <button onclick="callpythonfunction()">调用python函数</button>
            <div id="result">点击按钮查看结果...</div>
            <script>
                // 从python后端获取数据
                async function fetchdata() {
                    try {
                        const response = await fetch('/api/data');
                        if (!response.ok) throw new error('网络响应失败');
                        const data = await response.json();
                        document.getelementbyid('result').textcontent = data.message;
                    } catch (error) {
                        document.getelementbyid('result').textcontent = '错误: ' + error.message;
                    }
                }
                // 调用python函数（通过pywebview的api）
                async function callpythonfunction() {
                    try {
                        // 确保pywebview api已加载
                        if (window.pywebview && window.pywebview.api) {
                            const result = await window.pywebview.api.multiply_numbers(5, 3);
                            document.getelementbyid('result').textcontent = `python计算结果: 5 × 3 = ${result}`;
                        } else {
                            document.getelementbyid('result').textcontent = 'pywebview api未加载';
                        }
                    } catch (error) {
                        document.getelementbyid('result').textcontent = '调用python函数时出错: ' + error.message;
                    }
                }
            </script>
        </div>
    </body>
    </html>
    """)
# api路由 - 返回json数据
@app.route('/api/data')
def get_data():
    return jsonify({
        "message": "这是来自flask后端的数据！",
        "timestamp": str(os.times()),
        "platform": "windows桌面应用"
    })
# 导出flask应用实例供其他模块使用
if __name__ == '__main__':
    # 仅在直接运行此文件时使用flask内置服务器（开发环境）
    app.run(debug=true, port=5000)

2. 开发环境启动脚本（desktop_dev.py）

# desktop_dev.py - 开发环境下的桌面应用启动脚本
import webview
import threading
import subprocess
import time
import sys
from flask import flask
def run_flask():
    """在子进程中启动flask开发服务器"""
    # 确定python可执行文件路径
    python_exe = sys.executable
    # 启动flask应用
    server = subprocess.popen(
        [python_exe, 'app.py'],
        stdout=subprocess.pipe,
        stderr=subprocess.stdout,
        universal_newlines=true
    )
    # 等待服务器启动
    for line in server.stdout:
        print(line.strip())
        if 'running on' in line:
            break
    return server
class api:
    """供前端javascript调用的python api"""
    def multiply_numbers(self, a, b):
        """示例函数：计算两个数的乘积"""
        return a * b
if __name__ == '__main__':
    # 启动flask服务器
    flask_server = run_flask()
    try:
        # 创建api实例
        api = api()
        # 创建pywebview窗口
        window = webview.create_window(
            title="pywebview桌面应用",
            url="http://localhost:5000",
            width=800,
            height=600,
            resizable=true,
            fullscreen=false,
            js_api=api  # 暴露python api给javascript
        )
        # 启动pywebview主循环
        webview.start(debug=true)
    finally:
        # 关闭flask服务器
        if flask_server:
            flask_server.terminate()
            flask_server.wait()
            print("flask服务器已关闭")

3. 生产环境启动脚本（desktop_prod.py）

# desktop_prod.py - 生产环境下的桌面应用启动脚本
import webview
import threading
import subprocess
import time
import sys
from waitress import serve
from app import app
class api:
    """供前端javascript调用的python api"""
    def multiply_numbers(self, a, b):
        """示例函数：计算两个数的乘积"""
        return a * b
def run_waitress():
    """使用waitress启动flask应用（生产环境）"""
    print("正在启动waitress服务器...")
    serve(app, host='127.0.0.1', port=5000, threads=8)
if __name__ == '__main__':
    # 在后台线程中启动waitress服务器
    server_thread = threading.thread(target=run_waitress, daemon=true)
    server_thread.start()
    # 等待服务器启动（给服务器一些时间初始化）
    print("等待服务器启动...")
    time.sleep(2)
    try:
        # 创建api实例
        api = api()
        # 创建pywebview窗口
        window = webview.create_window(
            title="pywebview桌面应用",
            url="http://localhost:5000",
            width=800,
            height=600,
            resizable=true,
            fullscreen=false,
            js_api=api  # 暴露python api给javascript
        )
        # 启动pywebview主循环（关闭调试模式）
        webview.start(debug=false)
    except exception as e:
        print(f"应用启动失败: {e}")
    finally:
        print("应用已关闭")

4. 运行说明

开发环境

安装依赖：
```
pip install flask pywebview waitress
```
运行开发环境脚本：
```
python desktop_dev.py
```
- 会自动启动flask开发服务器和pywebview窗口。
- 修改代码后刷新页面即可看到变化。

生产环境

打包应用（可选）：

pyinstaller --onefile --windowed desktop_prod.py

直接运行生产环境脚本：
```
python desktop_prod.py
```
- 使用waitress服务器替代flask内置服务器，性能更好。
- 关闭了调试模式，更安全稳定。

功能说明

前后端交互：
- 前端通过fetch调用flask api（如/api/data）。
- 前端通过window.pywebview.api调用python函数（如multiply_numbers）。
界面特点：
- 使用tailwind css风格的界面（内联样式确保打包时不丢失）。
- 支持中文显示（使用microsoft yahei字体）。
- 响应式设计，适配不同屏幕尺寸。

这个实现可以作为windows桌面应用的基础框架，你可以根据需要扩展flask api或修改前端界面。

另一个应用示例代码

# create desktop app by  pywebview
"""
replace the flask module with waitress module.
to avoid the warning: warning: this is a development server. do not use it in a production deployment. 
use a production wsgi server instead.
"""
import webview
from flask import flask, render_template_string
import threading
from waitress import serve
# create a flask application
app = flask(__name__)
# define the route
@app.route('/')
def index():
    return render_template_string("""
    <!doctype html>
    <html lang="zh">
    <head>
        <meta charset="utf-8">
        <title>pywebview + flask 示例</title>
    </head>
    <body>
        <h1>欢迎使用 pywebview 和 flask 构建的桌面应用！</h1>
        <a href="http://cnliutz.ipyingshe.net" rel="external nofollow" >blog site</a>                        
    </body>
    </html>
    """)
def create_webview():
    # define the url of the flask application to load
    url = "http://127.0.0.1:5000"
    # create a window and load the specified url
    window = webview.create_window('pywebview + flask 应用', url)
    # run the application
    webview.start()
if __name__ == '__main__':
    # start the waitress server in a separate thread
    def run_waitress():
        try:
            # start waitress to run the flask application
            serve(app, host='127.0.0.1', port=5000)
        except exception as e:
            print(f"error starting waitress: {e}")
    waitress_thread = threading.thread(target=run_waitress)
    waitress_thread.daemon = true
    waitress_thread.start()
    # start pywebview
    create_webview()

到此这篇关于python的pywebview库结合flask和waitress开发桌面应用程序完整代码的文章就介绍到这了,更多相关python pywebview桌面应用程序内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！