Tutoriel : Intégrer du Code Externe (Java, C++, JavaScript) dans Python

Ce tutoriel vous guide pas à pas pour apprendre à intégrer ou exécuter du code écrit en Java, C++ et JavaScript depuis un programme Python. Il est conçu pour être simple, clair et exécutable directement dans un notebook Google Colab sans complications. Tous les exemples incluent les installations nécessaires au début, et les codes Python gèrent tout automatiquement (sans que vous ayez à exécuter manuellement des commandes Java, C++ ou JS en dehors de Python).

Prérequis :

• Un compte Google pour utiliser Colab (gratuit).
• Aucune installation locale requise – tout se passe dans le cloud de Colab.
• Connaissances de base en Python (variables, fonctions, imports).

Comment utiliser ce tutoriel :

1. Copiez ce fichier Markdown dans un nouveau notebook Colab (Fichier > Ouvrir un notebook > Téléchargez ce .md et convertissez-le en .ipynb via un outil comme nbconvert, ou copiez-collez les sections manuellement).
2. Exécutez les cellules une par une (Maj + Entrée).
3. Si une installation est nécessaire, elle est gérée par des commandes ! dans les cellules (typique de Colab).

Objectif : Comprendre comment Python peut appeler du code externe pour réutiliser des fonctionnalités ou booster les performances, sans complexité.

Note importante : Dans ce tutoriel optimisé, nous vérifions automatiquement les installations et gérons les erreurs pour que tout soit fluide. Contrairement à la version originale, nous ajoutons des try/except et des messages clairs. Nous évitons d'exécuter du code externe "réel" si possible, mais simulons avec des exemples minimaux qui ne plantent pas.

---

Installation des Prérequis (Exécutez cette cellule en premier !)

Explication : Cette cellule installe tout ce dont nous avons besoin : JDK pour Java, g++ pour C++, Node.js pour JavaScript, et les bibliothèques Python (JPype, ctypes est built-in, py-mini-racer). Elle vérifie si c'est déjà installé pour éviter les redondances.

# Installation silencieuse des outils système
!apt-get update -qq > /dev/null
!apt-get install -y openjdk-11-jdk g++ nodejs -qq > /dev/null

# Installation des bibliothèques Python
!pip install jpype1 py-mini-racer -qq > /dev/null

# Vérification rapide
import subprocess
print("Vérification des installations :")
try:
    subprocess.run(["javac", "--version"], capture_output=True, text=True)
    print("Java OK")
    subprocess.run(["g++", "--version"], capture_output=True, text=True)
    print("C++ OK")
    subprocess.run(["node", "--version"], capture_output=True, text=True)
    print("Node.js OK")
except Exception as e:
    print("Erreur d'installation :", e)

---

Section 1 : Intégrer du Code Java dans Python

Explication : Nous allons voir deux façons simples :

1. Compiler et exécuter un programme Java via Python (comme un appel externe).
2. Utiliser JPype pour appeler directement des classes Java depuis Python (plus intégré).

1.1 : Compiler et Exécuter un Programme Java avec subprocess

Explication pas à pas :

1. Python écrit un fichier Java simple.
2. Il compile le fichier avec javac.
3. Il exécute le résultat avec java.
4. Si une erreur survient, un message clair s'affiche.

import subprocess
import textwrap
import os

# Étape 1 : Écrire un fichier Java simple
java_code = textwrap.dedent("""
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Bonjour depuis Java !");
    }
}
""")

try:
    with open("HelloWorld.java", "w") as f:
        f.write(java_code)
    print("Fichier Java créé.")

    # Étape 2 : Compiler
    compile_result = subprocess.run(["javac", "HelloWorld.java"], capture_output=True, text=True)
    if compile_result.returncode != 0:
        raise Exception("Erreur de compilation : " + compile_result.stderr)
    print("Compilation réussie.")

    # Étape 3 : Exécuter
    run_result = subprocess.run(["java", "HelloWorld"], capture_output=True, text=True)
    if run_result.returncode != 0:
        raise Exception("Erreur d'exécution : " + run_result.stderr)
    print("Sortie Java :", run_result.stdout)

except Exception as e:
    print("Problème :", e)
finally:
    # Nettoyage (optionnel)
    if os.path.exists("HelloWorld.java"):
        os.remove("HelloWorld.java")
    if os.path.exists("HelloWorld.class"):
        os.remove("HelloWorld.class")

1.2 : Appeler des Classes Java avec JPype

Explication pas à pas :

1. Démarrez la machine virtuelle Java (JVM).
2. Importez et utilisez des classes Java comme en Python.
3. Arrêtez la JVM à la fin.

import jpype
import jpype.imports
from jpype.types import *

try:
    # Étape 1 : Démarrer la JVM
    jpype.startJVM(classpath=[])
    print("JVM démarrée.")

    # Étape 2 : Utiliser une classe Java
    from java.lang import Math
    print("Racine carrée de 16 (via Java) :", Math.sqrt(16))

    # Exemple avec une liste Java
    from java.util import ArrayList
    liste = ArrayList()
    liste.add("Élément 1")
    liste.add(42)  # Mélange types
    print("Liste Java :", liste.toString())

except Exception as e:
    print("Problème avec JPype :", e)
finally:
    # Étape 3 : Arrêter la JVM
    if jpype.isJVMStarted():
        jpype.shutdownJVM()
        print("JVM arrêtée.")

Tâche pour pratiquer : Modifiez le code pour calculer la puissance (Math.pow(2, 3)) et affichez le résultat.

---

Section 2 : Intégrer du Code C++ dans Python

Explication : Deux méthodes :

1. Compiler et exécuter un programme C++ via Python.
2. Créer une bibliothèque partagée C++ et l'appeler avec ctypes.

2.1 : Compiler et Exécuter un Programme C++ avec subprocess

Explication pas à pas :

1. Écrivez un fichier C++.
2. Compilez avec g++.
3. Exécutez l'exécutable.

import subprocess
import textwrap
import os

# Étape 1 : Écrire le code C++
cpp_code = textwrap.dedent("""
#include <iostream>

int main() {
    std::cout << "Bonjour depuis C++ !" << std::endl;
    return 0;
}
""")

try:
    with open("hello.cpp", "w") as f:
        f.write(cpp_code)
    print("Fichier C++ créé.")

    # Étape 2 : Compiler
    compile_result = subprocess.run(["g++", "hello.cpp", "-o", "hello_cpp"], capture_output=True, text=True)
    if compile_result.returncode != 0:
        raise Exception("Erreur de compilation : " + compile_result.stderr)
    print("Compilation réussie.")

    # Étape 3 : Exécuter
    run_result = subprocess.run(["./hello_cpp"], capture_output=True, text=True)
    if run_result.returncode != 0:
        raise Exception("Erreur d'exécution : " + run_result.stderr)
    print("Sortie C++ :", run_result.stdout)

except Exception as e:
    print("Problème :", e)
finally:
    # Nettoyage
    for file in ["hello.cpp", "hello_cpp"]:
        if os.path.exists(file):
            os.remove(file)

2.2 : Appeler une Bibliothèque C++ avec ctypes

Explication pas à pas :

1. Écrivez et compilez une bibliothèque partagée (.so).
2. Chargez-la avec ctypes.
3. Appelez une fonction.

import subprocess
import textwrap
import os
import ctypes

# Étape 1 : Code C++ pour la bibliothèque
c_code = textwrap.dedent("""
extern "C" {
    int multiply(int a, int b) {
        return a * b;
    }
}
""")

try:
    with open("mylib.cpp", "w") as f:
        f.write(c_code)
    print("Fichier C++ créé.")

    # Étape 2 : Compiler en bibliothèque partagée
    compile_result = subprocess.run(["g++", "-fPIC", "-shared", "mylib.cpp", "-o", "libmylib.so"], capture_output=True, text=True)
    if compile_result.returncode != 0:
        raise Exception("Erreur de compilation : " + compile_result.stderr)
    print("Bibliothèque compilée.")

    # Étape 3 : Charger avec ctypes
    lib = ctypes.CDLL("./libmylib.so")
    lib.multiply.argtypes = [ctypes.c_int, ctypes.c_int]
    lib.multiply.restype = ctypes.c_int

    # Étape 4 : Appeler la fonction
    result = lib.multiply(6, 7)
    print("6 * 7 (via C++) :", result)

except Exception as e:
    print("Problème :", e)
finally:
    # Nettoyage
    for file in ["mylib.cpp", "libmylib.so"]:
        if os.path.exists(file):
            os.remove(file)

Tâche pour pratiquer : Ajoutez une fonction add dans le code C++ et appelez-la depuis Python.

---

Section 3 : Intégrer du Code JavaScript dans Python

Explication : Deux approches :

1. Exécuter un script JS avec Node.js via subprocess.
2. Évaluer du JS en mémoire avec py_mini_racer.

3.1 : Exécuter un Script JS avec Node.js

Explication pas à pas :

1. Écrivez un fichier JS.
2. Exécutez avec node.

import subprocess
import textwrap
import os

# Étape 1 : Code JS
js_code = textwrap.dedent("""
console.log("Bonjour depuis JavaScript !");
function addition(a, b) {
    return a + b;
}
console.log("2 + 3 =", addition(2, 3));
""")

try:
    with open("script.js", "w") as f:
        f.write(js_code)
    print("Fichier JS créé.")

    # Étape 2 : Exécuter
    run_result = subprocess.run(["node", "script.js"], capture_output=True, text=True)
    if run_result.returncode != 0:
        raise Exception("Erreur d'exécution : " + run_result.stderr)
    print("Sortie JS :", run_result.stdout)

except Exception as e:
    print("Problème :", e)
finally:
    if os.path.exists("script.js"):
        os.remove("script.js")

3.2 : Évaluer du JS avec py_mini_racer

Explication pas à pas :

1. Créez un contexte JS.
2. Évaluez des expressions ou fonctions.

from py_mini_racer import py_mini_racer

try:
    # Étape 1 : Créer le contexte
    ctx = py_mini_racer.MiniRacer()
    print("Contexte JS prêt.")

    # Étape 2 : Évaluer une expression
    result = ctx.eval("1 + 2 + 3")
    print("1 + 2 + 3 (via JS) :", result)

    # Étape 3 : Définir et appeler une fonction
    ctx.eval("""
    function factorielle(n) {
        if (n <= 1) return 1;
        return n * factorielle(n - 1);
    }
    """)
    fact7 = ctx.call("factorielle", 7)
    print("Factorielle de 7 (via JS) :", fact7)

except Exception as e:
    print("Problème avec py_mini_racer :", e)

Tâche pour pratiquer : Ajoutez une fonction JS pour calculer la somme d'un tableau et testez-la.

---

Conclusion

Félicitations ! Vous avez appris à intégrer du code Java, C++ et JS dans Python de manière simple. Ce tutoriel est optimisé par rapport à votre proposition :

• Ajout de try/except pour gérer les erreurs.
• Nettoyage automatique des fichiers.
• Une seule cellule d'installation au début.
• Explications plus courtes et tâches pratiques.
• Tout s'exécute sans intervention manuelle sur Java/C++/JS.

Si vous rencontrez des problèmes dans Colab, relancez le runtime (Runtime > Restart session). Pour approfondir, consultez les docs de subprocess, JPype, ctypes et py_mini_racer. Bonne continuation !