Chiama e ricevi output dallo script Python in Java?

Question

Qual è il modo più semplice per eseguire uno script Python da Java e ricevere l'output di tale script? Ho cercato librerie diverse come Jepp o Jython, ma la maggior parte sembra obsoleta. Un altro problema con le librerie è che devo essere in grado di includere facilmente una libreria con il codice sorgente (anche se non ho bisogno di procurarmi la libreria stessa) se uso una libreria.

Per questo motivo, il modo più semplice/più efficace consiste semplicemente nel fare qualcosa come chiamare lo script con runtime.exec e in qualche modo acquisire l'output stampato? Oppure, anche se sarebbe molto doloroso per me, potrei anche avere l'output dello script Python in un file di testo temporaneo, quindi leggere il file in Java.

Nota: la comunicazione effettiva tra Java e Python non è un requisito del problema che sto cercando di risolvere. Questo, tuttavia, è l'unico modo in cui posso pensare per eseguire facilmente ciò che deve essere fatto.

Answer 1

Non sono sicuro di aver compreso correttamente la domanda, ma se è possibile chiamare l'eseguibile Python dalla console e si desidera catturare l'output in Java, è possibile utilizzare il metodo exec() nella classe Java Runtime.

Process p = Runtime.getRuntime().exec("python yourapp.py"); 

si può leggere su come leggere in realtà l'uscita qui:

http://www.devdaily.com/java/edu/pj/pj010016

C'è anche una libreria di Apache (il progetto exec Apache) che può aiutare con questo. Si può leggere di più su di esso qui:

http://www.devdaily.com/java/java-exec-processbuilder-process-1

http://commons.apache.org/exec/

Answer 2

Puoi provare a utilizzare Groovy. Si corre sulla JVM e viene fornito con grande supporto per l'esecuzione di processi esterni ed estraendo l'output:

http://groovy.codehaus.org/Executing+External+Processes+From+Groovy

si può vedere in questo codice preso dalla stesso link come Groovy rende facile per ottenere lo status di il processo:

println "return code: ${ proc.exitValue()}" 
println "stderr: ${proc.err.text}" 
println "stdout: ${proc.in.text}" // *out* from the external program is *in* for groovy 

Answer 3

ho guardato per le librerie diverse, come Jepp o Jython, ma la maggior parte sembrano essere molto aggiornata.

Jython non è "una libreria"; è un'implementazione del linguaggio Python su Java Virtual Machine. Non è sicuramente obsoleto; la versione più recente è stata il 24 febbraio di quest'anno. Implementa Python 2.5, il che significa che mancheranno un paio di funzionalità più recenti, ma onestamente non è molto diverso dal 2.7.

Nota: la comunicazione effettiva tra Java e Python non è un requisito del suddetto compito, quindi questo non sta facendo i miei compiti per me. Questo, tuttavia, è l'unico modo in cui posso pensare per eseguire facilmente ciò che deve essere fatto.

Questo sembra estremamente improbabile per un compito scolastico. Per favore dicci di più su cosa stai cercando di fare davvero.Di solito, i compiti scolastici specificano esattamente quali lingue userete per cosa, e non ne ho mai sentito uno che abbia coinvolto più di una lingua. Se lo facesse, ti direbbero se avevi bisogno di impostare questo tipo di comunicazione, e in che modo hanno voluto che tu lo facessi.

Answer 4

È possibile includere la libreria nel progetto Java. È possibile download the source code dal progetto Jython stesso.

Jython offre il supporto per JSR-223 che fondamentalmente consente di eseguire uno script Python da Java.

È possibile utilizzare un ScriptContext per configurare dove si desidera inviare l'output dell'esecuzione.

Per esempio, supponiamo di avere il seguente script Python in un file denominato numbers.py:

for i in range(1,10): 
    print(i) 

Quindi, è possibile eseguirlo da Java come segue:

public static void main(String[] args) throws ScriptException, IOException { 

    StringWriter writer = new StringWriter(); //ouput will be stored here 

    ScriptEngineManager manager = new ScriptEngineManager(); 
    ScriptContext context = new SimpleScriptContext(); 

    context.setWriter(writer); //configures output redirection 
    ScriptEngine engine = manager.getEngineByName("python"); 
    engine.eval(new FileReader("numbers.py"), context); 
    System.out.println(writer.toString()); 
} 

E l'uscita sarà be:

1 
2 
3 
4 
5 
6 
7 
8 
9 

Finché il tuo script Python è compatibile con Pyth su 2.5 non avrete problemi con questo con Jython.

Answer 5

Prima mi sento di raccomandare di utilizzare ProcessBuilder (dal 1,5)
utilizzo semplice è descritto qui
https://stackoverflow.com/a/14483787
Ad esempio più complesso fare riferimento al problema
http://www.javaworld.com/article/2071275/core-java/when-runtime-exec---won-t.html

che ho incontrato in occasione del lancio script Python da Java, lo script stava producendo troppo output in uscita standard e tutto è andato male.

Answer 6

Ho già incontrato lo stesso problema, leggere anche le risposte qui, ma non ho trovato alcuna soluzione di soddisfazione in grado di bilanciare l'output di compatibilità, prestazioni e ben formato, Jython non può funzionare con estensioni pacchetti C e più lento di CPython . Così alla fine ho deciso di inventare la ruota da solo, ci sono volute 5 notti, spero che possa aiutarti anche tu: jpserve (https://github.com/johnhuang-cn/jpserve).

JPserve fornisce un modo semplice per chiamare Python e scambiare il risultato con un buon formato JSON, poche perdite di prestazioni. Quello che segue è il codice di esempio.

In un primo momento, iniziare jpserve sul lato Python

>>> from jpserve.jpserve import JPServe 
>>> serve = JPServe(("localhost", 8888)) 
>>> serve.start() 

INFO:JPServe:JPServe starting... 
INFO:JPServe:JPServe listening in localhost 8888 

Quindi chiamare Python da Java lato:

approccio

PyServeContext.init("localhost", 8888); 
PyExecutor executor = PyServeContext.getExecutor(); 
script = "a = 2\n" 
    + "b = 3\n" 
    + "_result_ = a * b"; 

PyResult rs = executor.exec(script); 
System.out.println("Result: " + rs.getResult()); 

--- 
Result: 6 

Answer 7

Jython

Java dovrebbe essere indipendente dalla piattaforma, e chiamare un'applicazione nativa (come python) non è molto indipendente dalla piattaforma.

Esiste una versione di Python (Jython) scritta in Java, che ci consente di incorporare Python nei nostri programmi Java.Come al solito, quando si usano librerie esterne, un ostacolo è compilare ed eseguirlo correttamente, quindi passiamo attraverso il processo di creazione ed esecuzione di un semplice programma Java con Jython.

Iniziamo entrare in possesso di file jar Jython:

http://www.jython.org/downloads.html

ho copiato Jython-2.5.3.jar alla directory in cui il mio programma Java sarebbe stato. Poi ho digitato il seguente programma, che fa lo stesso dei due precedenti; prendere due numeri, li invia a python, che poi pitone torna di nuovo al nostro programma Java, dove il numero viene emesso alla schermata aggiunge:

import org.python.util.PythonInterpreter; 
import org.python.core.*; 

class test3{ 
    public static void main(String a[]){ 

     PythonInterpreter python = new PythonInterpreter(); 

     int number1 = 10; 
     int number2 = 32; 
     python.set("number1", new PyInteger(number1)); 
     python.set("number2", new PyInteger(number2)); 
     python.exec("number3 = number1+number2"); 
     PyObject number3 = python.get("number3"); 
     System.out.println("val : "+number3.toString()); 
    } 
} 

Io chiamo questo file "test3.java", salva , e procedere come segue compilarlo:

javac -classpath jython-2.5.3.jar test3.java

il passo successivo è quello di provare a farlo funzionare, cosa che faccio nel seguente modo:

java -classpath jython-2.5.3.jar :. test3

Ora, questo ci consente di utilizzare Python da Java, in modo indipendente dalla piattaforma. È un po 'lento. Eppure, è abbastanza interessante, che si tratti di un interprete Python scritto in Java ...

Answer 8

Jep è un'opzione anther. Incorpora CPython in Java tramite JNI.

import jep.Jep; 
//... 
    try(Jep jep = new Jep(false)) { 
     jep.eval("s = 'hello world'"); 
     jep.eval("print(s)"); 
     jep.eval("a = 1 + 2"); 
     Long a = (Long) jep.getValue("a"); 
    }