Usando le librerie Python in Java

Ecco alcuni esempi pratici per combinare Python e Java:

• Analisi dei dati e apprendimento automatico: Biblioteche come Numpy, Panda, Tensorflow o Scikit-Be taught sono in testa a Python.
• Prototipazione rapida: Python consente uno sviluppo più rapido di prototipi, che possono successivamente essere integrati in Java.
• Riutilizzo delle basi di codice esistenti: Le aziende spesso utilizzano moduli Python esistenti integrati in nuove applicazioni Java.

Approcci per integrare Python in Java

Jython

Jython è un’implementazione di Python che funziona sulla Java Digital Machine (JVM). Ciò consente di utilizzare i moduli Python direttamente in Java.

Vantaggi di Jython:

• Integrazione senza soluzione di continuità con JVM
• Accesso diretto alle classi Java da Python e viceversa

Svantaggi di Jython:

• Supporta solo Python 2.x (nessun supporto per Python 3.x)
• Molte biblioteche moderne non funzionano perché richiedono Python 3.x

ProcessBuilder (Exterior Script Execution)

Un modo semplice ma efficace per utilizzare le librerie Python in Java è eseguendo script di Python come processi esterni.

Vantaggi di ProcessBuilder:

• Supporto completo per tutte le versioni e le biblioteche Python
• Non ci sono dipendenze da ponti o API speciali

Svantaggi di ProcessBuilder:

• Sovraccarico di prestazioni a causa dell’inizio del processo
• La gestione degli errori è più complessa

Py4J

Py4j è un altro ponte tra Python e Java. Originariamente sviluppato per Apache Spark, consente a Python di manipolare gli oggetti Java ed eseguire i metodi Java.

Vantaggi di PY4J:

• Leggero e facile da integrare
• Supporta la comunicazione bidirezionale

Svantaggi di Py4J:

• C’è più sovraccarico durante la configurazione
• Più adatto agli scenari in cui Python è il conducente

Various: Biblioteche Java come sostituzione per Python

Se l’integrazione è troppo complicata, molte potenti librerie Java offrono funzionalità simili alle biblioteche Python:

Esempi di Jython per un progetto Maven

Devi includere la dipendenza da jython nel tuo pom.xml Per usare Jython in un progetto Maven. L’ultima versione di Jython può essere scaricata da https://www.jython.org/obtain e incluso come file jar. In alternativa, la libreria può essere integrata tramite la gestione delle dipendenze. Per fare ciò, il file POM del progetto deve essere esteso come segue, utilizzando la versione 2.7.2:

    org.python
    jython-standalone
    2.7.2

Creeremo un semplice esempio in cui uno script Python esegue un calcolo e il risultato viene elaborato ulteriormente in Java.

Codice Python (in linea all’interno del codice Java):

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

public class JythonExample {
    public static void foremost(String() args) {
        PythonInterpreter interpreter = new PythonInterpreter();
		interpreter.exec(
            "def add_numbers(a, b):n" +
            "    return a + bn" +
            "n" +
            "outcome = add_numbers(10, 20)"
        );

        PyObject outcome = interpreter.get("outcome");
		int sum = outcome.asInt();
        System.out.println("Consequence: " + sum);
    }
}

In questo esempio, l’interprete di Python viene inizializzato per la prima volta:

PythonInterpreter interpreter = new PythonInterpreter();

E quindi il codice Python viene eseguito direttamente all’interno della classe Java:

interpreter.exec(
            "def add_numbers(a, b):n" +
            "    return a + bn" +
            "n" +
            "outcome = add_numbers(10, 20)"
        );

Qui, una semplice funzione Python add_numbers è definito, che aggiunge due numeri. La funzione viene chiamata con i valori 10 e 20 e il risultato è memorizzato nella variabile outcome.

Il risultato viene recuperato con il seguente comando:

PyObject outcome = interpreter.get("outcome");
int sum = outcome.asInt();

Con interpreter.get("outcome")il risultato dello script Python viene recuperato e convertito in una variabile Java (INT).

Il risultato può, advert esempio, essere emesso come segue:

System.out.println("Consequence: " + sum);

Le variabili Java possono anche essere passate alla sceneggiatura di Python. Ecco un esempio esteso:

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

public class JythonExampleWithInput {
    public static void foremost(String() args) {
        PythonInterpreter interpreter = new PythonInterpreter();

       
        int a = 15;
        int b = 25;

        interpreter.set("a", new PyInteger(a));
        interpreter.set("b", new PyInteger(b));

        interpreter.exec(
            "def multiply_numbers(x, y):n" +
            "    return x * yn" +
            "n" +
            "outcome = multiply_numbers(a, b)"
        );

        int outcome = interpreter.get("outcome").asInt();
        System.out.println("Consequence: " + outcome);
    }
}

Nel prossimo esempio, un file python esterno chiamato script.py è inserito nel file src/foremost/assets Listing del progetto Maven.

my-maven-project/
│
├── pom.xml
│
├── src
│   ├── foremost
│   │   ├── java
│   │   │   └── your/package deal/foremost.java
│   │   └── assets
│       └── script.py  
│
└── goal/

Perché src/foremost/assets?

• Tutto nel src/foremost/assets La listing viene copiata a goal/lessons cartella quando il progetto è costruito
• È possibile caricare questi file in fase di esecuzione utilizzando il ClassLoader

Questa è una conference Maven comunemente utilizzata nei progetti Java per archiviare risorse non java come file di configurazione, proprietà, XML, JSON o altri dati statici necessari in fase di esecuzione.

Lo script è definito come segue:

def add_numbers(a, b):
    return a + b
outcome = add_numbers(5, 15)
print("Consequence: {}".format(outcome))

La classe Java corrispondente è definita come segue:

import org.python.util.PythonInterpreter;
import java.io.FileReader;
import java.io.IOException;

public class JythonExternalScriptExample {
    public static void foremost(String() args) {
        
        PythonInterpreter interpreter = new PythonInterpreter();
        strive {
            FileReader pythonScript = new FileReader("script.py");
            interpreter.execfile(pythonScript);
            pythonScript.shut();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Inizializzazione dell’interprete:

PythonInterpreter interpreter = new PythonInterpreter();

Caricamento dello script esterno:

FileReader pythonScript = new FileReader("script.py");

Esecuzione dello script:

interpreter.execfile(pythonScript);

Chiusura del fileReader:

Conclusione

Con Jython, puoi facilmente eseguire script di Python esterni da Java. L’integrazione funziona bene per script semplici, soprattutto quando si passano i parametri da Java a Python. Tuttavia, per le biblioteche Python 3 più complesse, è necessario considerare different come PY4J o eseguire direttamente i processi Python utilizzando ProcessBuilder.

Jython offre una soluzione semplice ma obsoleta, mentre Py4J e JPype creano ponti più flessibili tra le due lingue. Tuttavia, l’esecuzione di script di Python esterni è il metodo più semplice in molti casi.

Per i progetti a lungo termine o quando le prestazioni sono una grande preoccupazione, potrebbe valere la pena cercare different Java che offrano supporto nativo e possano essere più facilmente integrati nei progetti Java esistenti.