Electron框架下Python与Node.js双向调用函数的最佳方法

阿华AIGC实验室

2026-5-11

Electron与Python双向函数调用的最佳实现方案

嘿，我来帮你搞定这个Electron和Python双向通信的问题！你已经成功迈出了第一步——从Node启动Python进程，接下来我们要实现双向的特定函数调用。下面是两种最实用的方案，你可以根据场景选择：

方案一：基于stdin/stdout的JSON消息传递（轻量化无依赖）

这是最推荐的轻量方案，不需要额外安装任何库，利用Electron的child_process和Python标准库就能实现核心逻辑。核心思路是通过stdin/stdout传递结构化的JSON消息，两边解析后触发对应的函数调用。

Electron主进程代码（Main.js）

const spawn = require("child_process").spawn;
const pythonProcess = spawn('python3', ["./py/test.py"]);

// 处理Python发来的消息，解析后调用对应Node函数
pythonProcess.stdout.on('data', (data) => {
  try {
    // 按行解析消息（避免缓冲区合并问题）
    const messages = data.toString().trim().split('\n');
    messages.forEach(msgStr => {
      if (!msgStr) return;
      const message = JSON.parse(msgStr);
      if (message.type === 'call_node_func') {
        // 调用预定义的Node函数
        if (typeof global[message.funcName] === 'function') {
          global[message.funcName](...message.args);
        }
      } else if (message.type === 'log') {
        console.log('Python日志:', message.content);
      }
    });
  } catch (err) {
    console.error('解析Python消息出错:', err);
    console.log('原始数据:', data.toString());
  }
});

// 向Python发送调用函数的消息
global.callPythonFunction = function(funcName, ...args) {
  const message = JSON.stringify({
    type: 'call_python_func',
    funcName: funcName,
    args: args
  }) + '\n'; // 加换行符让Python按行读取
  pythonProcess.stdin.write(message);
};

// 定义允许Python调用的Node函数
global.getDataFromPY = function(data) {
  console.log("✅ 收到Python传来的数据:", data);
};

// 测试：启动后调用Python的helloNode函数
callPythonFunction('helloNode');

Python脚本代码（test.py）

import sys
import json
import threading

def testNode():
    """调用Node的getDataFromPY函数"""
    message = json.dumps({
        'type': 'call_node_func',
        'funcName': 'getDataFromPY',
        'args': ['这是来自Python的测试数据']
    }) + '\n'
    sys.stdout.write(message)
    sys.stdout.flush()  # 必须flush，否则消息会留在缓冲区

def helloNode():
    """向Node发送日志消息"""
    print(json.dumps({
        'type': 'log',
        'content': '👋 hello from python'
    }) + '\n', flush=True)

def listen_node_messages():
    """监听Node发来的消息，解析后调用对应Python函数"""
    for line in sys.stdin:
        try:
            message = json.loads(line.strip())
            if message['type'] == 'call_python_func':
                func_name = message['funcName']
                args = message['args']
                # 调用当前模块中的Python函数
                if func_name in globals() and callable(globals()[func_name]):
                    globals()[func_name](*args)
        except Exception as e:
            print(json.dumps({
                'type': 'error',
                'content': f'解析Node消息出错: {str(e)}'
            }) + '\n', flush=True)

# 启动监听线程（避免阻塞主逻辑）
threading.Thread(target=listen_node_messages, daemon=True).start()

# 初始化触发：调用Node函数
testNode()

方案二：基于RPC框架（适合复杂场景）

如果你的项目有大量复杂的函数调用、需要处理返回值或异步逻辑，推荐使用成熟的RPC框架（比如zerorpc），它能自动处理序列化、通信和错误处理，代码更简洁。

步骤1：安装依赖

# Electron端
npm install zerorpc

# Python端
pip install zerorpc

Electron主进程代码（Main.js）

const zerorpc = require("zerorpc");

// 连接Python的RPC服务
const pythonClient = new zerorpc.Client();
pythonClient.connect("tcp://127.0.0.1:4242");

// 调用Python函数
pythonClient.invoke("helloNode", (error, res) => {
  if (error) console.error(error);
  else console.log('Python返回:', res);
});

// 启动Node的RPC服务，让Python可以调用
const nodeServer = new zerorpc.Server({
  getDataFromPY: function(data, callback) {
    console.log("✅ 收到Python的RPC调用数据:", data);
    callback(null, "Node已成功接收数据"); // 向Python返回结果
  }
});
nodeServer.bind("tcp://127.0.0.1:4243");

Python脚本代码（test.py）

import zerorpc

class PythonService:
    def helloNode(self):
        print("👋 hello from python")
        return "Python的返回值"
    
    def callNodeFunction(self):
        """调用Node的getDataFromPY函数"""
        nodeClient = zerorpc.Client()
        nodeClient.connect("tcp://127.0.0.1:4243")
        res = nodeClient.invoke("getDataFromPY", "来自Python的RPC测试数据")
        print("Node返回结果:", res)

# 启动Python的RPC服务
server = zerorpc.Server(PythonService())
server.bind("tcp://127.0.0.1:4242")
server.run()