如何在Java中逐行连续执行Python代码并查看每步执行结果

我完全懂你的需求——从Java语义解析器拿到单行Python代码字符串，要逐行执行还得能看到每一步的结果。用Runtime.exec或者直接跑完整脚本确实满足不了这种交互式的逐行执行需求，不过别担心，有两个靠谱的方案能解决这个问题，咱们一步步说。

方案一：用Jython实现（推荐，适合Python 2.7代码） #

Jython本身就是Java实现的Python解释器，它提供了PythonInterpreter类，可以维护一个持续的Python运行环境，完美支持逐行执行代码、保留上下文（比如之前导入的模块、定义的变量），还能捕获执行结果和输出。

1. 先添加Jython依赖 #

如果用Maven，在pom.xml里加：

<dependency>
    <groupId>org.python</groupId>
    <artifactId>jython-standalone</artifactId>
    <version>2.7.3</version> <!-- 可以用最新稳定版 -->
</dependency>

Gradle的话：

implementation 'org.python:jython-standalone:2.7.3'

2. 实现逐行执行的核心代码 #

下面是一个可直接用的工具类，能处理语句（比如import pandas）和表达式（比如df.head()），还能捕获输出和错误：

import org.python.core.PyObject;
import org.python.util.PythonInterpreter;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;

public class PythonLineExecutor {
    private PythonInterpreter interpreter;
    private ByteArrayOutputStream outputStream;

    public PythonLineExecutor() {
        // 初始化解释器并设置输出捕获
        outputStream = new ByteArrayOutputStream();
        interpreter = new PythonInterpreter();
        interpreter.setOut(new PrintStream(outputStream));
    }

    // 执行单行Python代码，返回执行结果/输出/错误信息
    public String executeLine(String pythonCode) {
        outputStream.reset(); // 清空上一次的输出
        try {
            // 简单区分是表达式还是语句：表达式用eval拿返回值，语句用exec执行
            if (isExpression(pythonCode)) {
                PyObject result = interpreter.eval(pythonCode);
                return result != null ? result.toString() : "";
            } else {
                interpreter.exec(pythonCode);
                return outputStream.toString().trim();
            }
        } catch (Exception e) {
            return "执行错误: " + e.getMessage();
        }
    }

    // 辅助方法：判断是否为表达式（可根据实际需求优化逻辑）
    private boolean isExpression(String code) {
        String trimmedCode = code.trim();
        return !trimmedCode.startsWith("import") 
               && !trimmedCode.startsWith("from") 
               && !trimmedCode.contains("=") 
               && !trimmedCode.startsWith("def") 
               && !trimmedCode.startsWith("class");
    }

    // 测试示例
    public static void main(String[] args) {
        PythonLineExecutor executor = new PythonLineExecutor();
        
        // 执行第一行：导入pandas
        String importResult = executor.executeLine("import pandas");
        System.out.println("导入模块后的结果: " + importResult); // import无输出，返回空字符串
        
        // 执行第二行：读取CSV文件
        String readCsvResult = executor.executeLine("df = pandas.read_csv('somefile.csv')");
        System.out.println("读取CSV后的结果: " + readCsvResult);
        
        // 执行第三行：打印数据前5行
        String previewResult = executor.executeLine("print(df.head())");
        System.out.println("数据预览结果:\n" + previewResult);
    }
}

关键提示 #

• 上下文持续性：PythonInterpreter实例会保留所有之前执行的状态，比如你导入的pandas、定义的df变量，后续代码可以直接使用。
• 输出捕获：通过重定向sys.stdout，能拿到print()语句的输出；表达式的返回值则用eval()直接获取。
• 错误处理：捕获Jython抛出的异常，避免解释器崩溃，同时返回清晰的错误信息。

方案二：启动Python交互式进程（适合Python 3代码） #

如果你的语义解析器输出的是Python 3代码，Jython就不太适用了（它目前只支持Python 2.7）。这时候可以用ProcessBuilder启动一个Python交互式进程（python3 -i），通过标准输入输出和它交互。

核心代码示例 #

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class PythonInteractiveExecutor {
    private Process pythonProcess;
    private OutputStreamWriter writer;
    private BufferedReader reader;

    public PythonInteractiveExecutor() throws IOException {
        // 启动Python 3交互式进程
        ProcessBuilder pb = new ProcessBuilder("python3", "-i");
        pb.redirectErrorStream(true); // 合并错误输出和标准输出，方便统一读取
        pythonProcess = pb.start();
        
        writer = new OutputStreamWriter(pythonProcess.getOutputStream());
        reader = new BufferedReader(new InputStreamReader(pythonProcess.getInputStream()));
        
        // 读取初始的交互式提示符（>>>），避免干扰后续结果读取
        readUntilPrompt();
    }

    // 执行单行代码，返回结果
    public String executeLine(String pythonCode) throws IOException {
        writer.write(pythonCode + "\n");
        writer.flush();
        return readUntilPrompt();
    }

    // 读取输出直到下一个提示符
    private String readUntilPrompt() throws IOException {
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            if (line.startsWith(">>>") || line.startsWith("...")) {
                break;
            }
            sb.append(line).append("\n");
        }
        return sb.toString().trim();
    }

    // 关闭进程
    public void close() throws IOException {
        writer.write("exit()\n");
        writer.flush();
        pythonProcess.destroy();
    }

    // 测试示例
    public static void main(String[] args) throws IOException {
        PythonInteractiveExecutor executor = new PythonInteractiveExecutor();
        try {
            String importResult = executor.executeLine("import pandas");
            System.out.println("导入模块后的结果: " + importResult);
            
            String readCsvResult = executor.executeLine("df = pandas.read_csv('somefile.csv')");
            System.out.println("读取CSV后的结果: " + readCsvResult);
            
            String previewResult = executor.executeLine("print(df.head())");
            System.out.println("数据预览结果:\n" + previewResult);
        } finally {
            executor.close();
        }
    }
}

注意事项 #

• 这个方案完全支持Python 3，但交互逻辑更复杂，需要处理多行代码（比如缩进的函数定义）、提示符识别等问题。
• 要确保系统环境里有Python 3的可执行文件，并且路径正确。

内容的提问来源于stack exchange，提问作者anton-sturluson