在Java代码中使用Python

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量2.5k 收藏 15
点赞数 5
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53057371/article/details/130363623
版权
本文介绍了如何在Java代码中使用ProcessBuilder类调用Python脚本，包括如何传递参数调用Python函数，获取函数执行结果，以及处理多个参数的情况。通过Python的sys.argv或argparse模块，可以方便地在Java中传递参数并获取Python函数的返回值。
摘要由CSDN通过智能技术生成

使用技术

要在Java代码中调用python代码方法，我们可以使用Java的ProcessBuilder类来创建一个新进程，将Python解释器作为该进程的命令并传递要执行的Python脚本作为参数。
以下是一些基本的代码示例：

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

public class PythonCaller {
    public static void main(String[] args) {
        try {
            // 创建ProcessBuilder对象
            ProcessBuilder pb = new ProcessBuilder("python", "hello.py");
            // 启动进程
            Process process = pb.start();
            // 获取进程的输出流
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            // 等待进程完成
            int exitCode = process.waitFor();
            System.out.println("Exited with error code " + exitCode);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们将ProcessBuilder对象的参数设置为python和hello.py，其中hello.py是我们要执行的Python脚本文件。该进程将启动Python解释器并执行该脚本。我们使用缓冲读取器来获取该进程的输出流，并在控制台上打印该进程的输出。最后，我们等待进程完成并检查它的退出代码。

那么我们应该怎么调用Python中的函数呢?

调用Python中的函数

要在Java代码中调用Python脚本中的特定函数，您需要使用ProcessBuilder对象的参数来传递要执行的Python脚本以及要执行的函数，并将这些信息传递给Python脚本作为参数。

  1. 在Python脚本hello.py中定义一个简单的hello()函数：
def hello():
    print("Hello from Python!")
  1. 在Java代码中使用ProcessBuilder对象的参数来执行hello.py脚本并传递函数名称作为参数
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class PythonCaller {
    public static void main(String[] args) {
        try {
            // 创建ProcessBuilder对象
            ProcessBuilder pb = new ProcessBuilder("python", "hello.py", "hello");
            // 启动进程
            Process process = pb.start();
            // 获取进程的输出流
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            // 等待进程完成
            int exitCode = process.waitFor();
            System.out.println("Exited with error code " + exitCode);
        } catch (Exception  e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们将ProcessBuilder对象的参数设置为python，hello.py和hello字符串。此命令将启动Python解释器并执行hello.py脚本。Python脚本将检查传递的函数名称参数是否匹配脚本中定义的函数名称，并执行hello()函数。在该进程的输出流中，我们可以打印由该函数打印的任何内容。

请注意：您需要确保将Python脚本文件的路径正确地指定为ProcessBuilder对象所在的目录。您还需要使用与Python解释器版本相同的Java版本编译Java代码，否则可能会遇到问题。

获取函数执行的结果

要将Python脚本的函数返回值返回给Java代码，您需要使用Java的Process对象中的getInputStream()方法获取进程的输出流。在Python脚本中，您可以使用Python的print()函数将函数的返回值打印到标准输出。然后，您可以在Java代码中使用BufferedReader对象读取输出流，并将其输出到控制台或将其存储到变量中。
Python代码:

def hello():
    return "Hello from Python!"
    
print(hello())

Java代码

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

public class PythonCaller {
    public static void main(String[] args) {
        try {
            // 创建ProcessBuilder对象
            ProcessBuilder pb = new ProcessBuilder("python", "hello.py", "hello");
            // 启动进程
            Process process = pb.start();
            // 获取进程的输出流
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            StringBuilder result = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                result.append(line);
            }
            // 等待进程完成
            int exitCode = process.waitFor();
            System.out.println("Exited with error code " + exitCode);
            // 打印结果
            System.out.println("Python函数的结果是：" + result);
        } catch (Exception  e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们在hello()函数中添加了一个返回语句，以便您可以返回Python函数的返回值。然后，我们使用print()函数将Python函数的返回值打印到标准输出。在Java代码中，我们使用BufferedReader对象读取输出流，将它们存储到一个StringBuilder对象中，然后将其打印到控制台。请注意，由于Python脚本的输出以换行符结尾，我们在读取输出流时需要添加一个循环来读取所有行，并将它们附加到StringBuilder对象中。最后，我们在控制台上打印Python函数的结果。

那么如果要在Java代码中输入Python函数中的参数呢?

Java代码中输入Python函数中的参数

如果Python函数带有参数，您可以在Java代码中将这些参数作为命令的一部分传递给Python脚本。Python脚本可以读取这些参数，并将它们传递给Python函数。

Python代码:

import sys

def hello(name):
    print("Hello, " + name + "!")

我们使用Python模块sys来获取由Java代码传递的参数，将其传递给Python函数，然后使用print()函数将结果打印到标准输出。

在Java代码中使用ProcessBuilder对象的参数来执行hello.py脚本并传递参数到函数中。
Java代码:

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

public class PythonCaller {
    public static void main(String[] args) {
        try {
            // 创建ProcessBuilder对象
            ProcessBuilder pb = new ProcessBuilder("python", "hello.py", "World");
            // 启动进程
            Process process = pb.start();
            // 获取进程的输出流
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            // 等待进程完成
            int exitCode = process.waitFor();
            System.out.println("Exited with error code " + exitCode);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们将ProcessBuilder对象的命令参数设置为python，hello.py和World字符串，可以将任何其他字符串传递作为参数，它将被传递到Python函数中作为函数的参数，Python脚本将读取这些参数，并将它们传递给hello()函数。

Python函数输入多个参数

以下用Python函数计算两个数的和
Python文件

import sys

def add(num1, num2):
    return num1 + num2

传递两个参数和和上面传递一个参数一样, 在Java代码中使用ProcessBuilder对象的参数来执行hello.py脚本并向函数中传递两个参数

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

public class PythonCaller {
    public static void main(String[] args) {
        try {
            // 创建ProcessBuilder对象
            ProcessBuilder pb = new ProcessBuilder("python", "hello.py", "2", "3");
            // 启动进程
            Process process = pb.start();
            // 获取进程的输出流
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            // 等待进程完成
            int exitCode = process.waitFor();
            System.out.println("Exited with error code " + exitCode);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们将ProcessBuilder对象的命令参数设置为python，hello.py，2和3字符串，其中2和3是要传递给add()函数的参数。Python脚本将读取这些参数，并使用add()函数来计算它们的和。结果将使用print()函数在标准输出中打印。

如果我们想在Java代码中获取函数执行的结果呢?

在Java代码中获取函数执行结果

要将Python函数add()计算的结果返回给Java代码，可以使用Java的Process对象中的 getInputStream() 方法获取进程的输出流，Python脚本可以使用 print() 函数将函数的返回值打印到标准输出中。在Java代码中，您可以使用 BufferedReader 对象读取输出流，将值存储到变量中，最后将它打印到控制台或者将其存储到对应的变量中。

Python代码:

import sys

def add(num1, num2):
    return num1 + num2
    
print(add(int(sys.argv[1]), int(sys.argv[2])))

在上述代码中，我们定义了一个 add() 函数，该函数接收两个参数 num1 和 num2，将它们相加并返回结果。我们使用 sys.argv[] 从 Python 脚本中读取传递给函数的参数，并使用 print() 函数将结果打印到标准输出中。

Java 代码：

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

public class PythonCallerExample {

    public static void main(String[] args) {
        try {
            ProcessBuilder processBuilder = new ProcessBuilder("python", "hello.py", "2", "3");
            Process process = processBuilder.start();
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            StringBuilder stringBuilder = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line);
            }
            int exitCode = process.waitFor();
            System.out.println("Exited with error code " + exitCode);
            System.out.println("Result: " + stringBuilder.toString());
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们使用 ProcessBuilder 启动 Python 进程，将要执行的 Python 脚本以及参数传递给进程。我们使用 BufferedReader 读取进程的输出流，并使用 StringBuilder 存储传递给 Python 函数后计算出的和。最后，我们打印结果和状态码。

请注意：您需要确保将 Python 脚本文件的路径正确指定为 ProcessBuilder 对象所在的目录，而且传递的参数数量和顺序需要正确。

当然除了使用sys.argv[]方法外,我们还可以使用以下是两个常用的方法：

  1. 使用 argparse 模块
    argparse 是 Python 内置的一个命令行解析模块，可以用来解析命令行参数。您可以使用 argparse 模块来定义需要传递的参数，然后在 Python 脚本中使用这些命令行参数。

Python 代码示例：

import argparse

def add(num1, num2):
    return num1 + num2

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('num1', type=int)
    parser.add_argument('num2', type=int)
    args = parser.parse_args()
    print(add(args.num1, args.num2))

在上述代码示例中，我们使用 argparse 模块来定义了需要传递的两个参数 num1 和 num2。通过 parser.add_argument() 方法，我们可以定义传递的参数名称、类型和参数描述等属性。在脚本的主函数中，我们使用 parser.parse_args() 方法解析命令行参数，并将其传递给 add() 函数。在最后一行，使用 print() 将计算结果打印到标准输出。

Java代码示例:

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

public class PythonCallerExample {
    public static void main(String[] args) {
        try {
            ProcessBuilder processBuilder = new ProcessBuilder("python", "hello.py", "2", "3");
            Process process = processBuilder.start();
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            StringBuilder stringBuilder = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line);
            }
            int exitCode = process.waitFor();
            System.out.println("Exited with error code " + exitCode);
            System.out.println("Result: " + stringBuilder.toString());
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在 Java 代码中，我们使用与之前示例相同的 ProcessBuilder， 并使用 argparse 的方式定义两个参数。因为该示例使用相同的命令行参数来调用 Python 脚本，所以不需要对 Java 代码进行任何修改，但如果参数有所不同，则需要相应地更改 ProcessBuilder 中的参数。
2. 使用 subprocess 模块
subprocess 模块是 Python 内置的一个子进程管理模块。您可以使用这个模块来启动一个 Python 子进程，在子进程中执行 Python 脚本，并传递参数到 Python 子进程中。

Python 代码示例：

import sys

def add(num1, num2):
    return num1 + num2

if __name__ == '__main__':
    num1 = int(sys.stdin.readline().strip())
    num2 = int(sys.stdin.readline().strip())
    print(add(num1, num2))

在上述代码示例中，我们使用 sys.stdin.readline() 来读取从父进程传递的两个参数，并将其传递给 add() 函数。在最后一行，使用 print() 将计算结果打印到标准输出。

Java代码示例:

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

public class PythonCallerExample {

    public static void main(String[] args) {
        try {
            ProcessBuilder processBuilder = new ProcessBuilder("python");
            Process process = processBuilder.start();
            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            process.getOutputStream().write(in.readLine().getBytes("UTF-8"));
            process.getOutputStream().write('\n');
            process.getOutputStream().write(in.readLine().getBytes("UTF-8"));
            process.getOutputStream().write('\n');
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            int exitCode = process.waitFor();
            System.out.println("Exited with error code " + exitCode);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

以上代码创建 BufferedReader 对象并将其连接到 Python 进程的输入流和输出流：in 和reader
一个用于读取用户输入，另一个用于读取 Python 进程的输出。
以下代码用于发送用户输入到 Python 进程并读取其输出：

process.getOutputStream().write(in.readLine().getBytes("UTF-8"));
process.getOutputStream().write('\n');
process.getOutputStream().write(in.readLine().getBytes("UTF-8"));
process.getOutputStream().write('\n');
while ((line = reader.readLine()) != null) {
    System.out.println(line);
}

在这里，我们使用 process.getOutputStream() 将用户输入发送到 Python 进程，并使用 reader 读取 Python 进程的输出。该程序将循环运行直到 Python 进程输出的内容返回 null。在每次循环迭代中，我们将 Python 进程输出的行打印到控制台上。

好了, 在Java代码中操作Python就介绍到这儿, 其他内容欢迎大家评论讨论

qq_53057371
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在Java中调用Python
weixin_30807779的博客
02-09 1133
写在前面 在微服务架构大行其道的今天，对于将程序进行嵌套调用的做法其实并不可取，甚至显得有些愚蠢。当然，之所以要面对这个问题，或许是因为一些历史原因，或者仅仅是为了简单。恰好我在项目中就遇到了这个问题，需要在Java程序中调用Python程序。关于在Java中调用Python程序的实现，根据不同的用途可以使用多种不同的方法，在这里就将在Java中调用Python程序的方式做一个总结。 直接通过Ru...
Java中调用Python代码
06-01
NULL 博文链接：https://zhangzhenting.iteye.com/blog/2298810
java和python能联合开发吗,java和python混合架构
m0_73979992的博客
05-12 750
大家好，小编来为大家解答以下问题，java和python能联合开发吗，java和python混合架构，今天让我们一起来看看吧！
Java项目里面如何运行python代码
m0_46093203的博客
08-15 632
Java和Python是两种不同的编程语言，各有优缺点。为了充分发挥它们的长处，有时需要在Java代码中嵌入Python脚本。比如，Python在数据科学、机器学习等领域有广泛应用，而Java则在企业级应用和网络编程方面有着强大的优势。通过Java嵌入Python脚本，可以让我们的程序更加灵活。第一步：获取python解析器的绝对路径，运行的代码程序。
Java调用python代码的五种方式
热门推荐
wynn的博客
09-09 1万+
Java调用python代码的五种方式
Java整合Python方法总结
ruiguang21的博客
10-22 1889
1.在pom中引用 <dependency> <groupId>org.python</groupId> <artifactId>jython-standalone</artifactId> <version>2.7.0</version> </dependency> 2.直接在java类中写python语...
java2python--java代码转python工具
07-19
Java到Python的转换工具，如"java2python"，是一个重要的软件开发辅助工具，它能够帮助程序员将已有的Java代码转换成Python代码，以便在Python环境中执行或进行进一步的开发工作。这种转换过程涉及到多种语言特性和...
Java/Python实现的爱心代码
02-04
5. **面向对象编程**：Java代码可能涉及到类和方法的使用，展示面向对象编程的概念。 6. **代码可读性和可维护性**：对比不同实现，可以学习如何提高代码的可读性和可维护性。 总的来说，这些源代码为我们提供了一...
Java迭代器实现Python中的range代码实例
08-19
Java迭代器实现Python中的range代码实例 本文主要介绍了Java迭代器实现Python中的range代码实例，通过示例代码对大家的学习或者工作具有一定的参考学习价值。下面是相关知识点的详细解释： 一、Java迭代器 Java...
如何在Java中调用Python
neweastsun的专栏
04-30 5955
本文介绍了如何从Java调用Python脚本，使用jython脚本引擎比ProcessBuilder类更简单。另外Python可以便捷搭建http应用，Java也可以通过HTTP协议直接调用HTTP服务实现交互。参考内容：https://www.baeldung.com/java-working-with-python。
Java调用Python协同开发的方式
qq_43170312的博客
01-12 1557
Java与Python结合开发是指将Python语言与Java语言结合起来，利用它们的优势，共同开发一个应用程序。Python解释器：安装Python解释器，并且可以在命令行中执行python命令。Python语言拥有许多强大的特性，如易于学习、快速开发、可扩展性等，而Java语言则拥有跨平台、可靠性、安全性等优势，因此将它们结合起来，可以发挥出更大的作用。
Java执行Python代码的两种方法（Jython与ProcessBuilder）
高性价比服务器就选：蓝易云
07-22 894
通过使用ProcessBuilder，可以启动一个Python解释器，并执行Python代码。请根据实际情况选择适合您的项目的方法。使用ProcessBuilder可以执行任意Python代码，并且不受限于特定的Python版本。使用Jython可以实现Java与Python之间的无缝集成，但需要将Jython作为项目的依赖，并且受限于Jython所支持的Python版本。在Java中执行Python代码有多种方法，其中两种常用的方法是使用Jython和使用ProcessBuilder。
java调用python汇总
huawangxin
07-10 273
java调用python汇总
python与java对接工具Jython介绍
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
10-12 587
Java编程精选点击右侧关注，免费入门到精通！作者丨python人工智能找电子书https://www.jianshu.com/p/51d64bb620cc快速入门下面我...
在java中调用python脚本
自己在学习过程中的总结
12-15 8154
在java中调用python脚本，推荐使用第三种方法，因为只有第三种方法使用Runtime.getRuntime()才能执行含有第三方库（numpy，matlab，pandas等库）的python脚本。
java集成python_将Python与Java集成
07-08 1264
java集成python 一般而言，将系统编程和脚本语言结合起来并不是什么奇怪的新概念，只是很少实现。 可以将共享公共应用程序二进制接口的编程语言合并到单个库或可执行文件中，尽管很难使两种语言的签名相互融合，但确实存在可以提供帮助的工具。 可以在多语言代码中找到一起工作的编程语言的一个示例。 例如，Stack Overflow上的404页可以在Python，Ruby，Perl，C和其他一些语...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1260
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
如何在Java中调用Python代码 Jython实现
05-09
在Java代码中使用Jython的PythonInterpreter类加载并调用Python模块和函数，例如： ``` import org.python.util.PythonInterpreter; public class Main { public static void main(String[] args) { Python...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值