Python esegue un altro script Python

Per riutilizzare codice nello stesso processo Python, inseriscilo in un modulo e importalo. Per eseguire un altro script in modo indipendente, avvia un processo figlio con subprocess. Scegli il primo approccio se vuoi chiamare funzioni o condividere oggetti; scegli il secondo se lo script deve mantenere il proprio processo e il proprio comportamento da riga di comando.

Usa l’istruzione import per eseguire uno script Python da un altro script Python

Quando Python carica un modulo per la prima volta, esegue una volta le istruzioni al livello principale. Inserisci le operazioni riutilizzabili in funzioni e racchiudi il comportamento previsto per l’esecuzione diretta in if __name__ == "__main__":, così non verrà eseguito solo perché un altro modulo importa il file. Importa il nome del modulo senza il suffisso .py.

Questo esempio autonomo crea un modulo in una directory temporanea, lo importa e ne chiama una funzione:

import importlib
import sys
import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as folder:
    module_path = Path(folder) / "helper_script.py"
    module_path.write_text(
        'def greet():\n'
        '    print("Hello from the helper")\n',
        encoding="utf-8",
    )
    sys.path.insert(0, folder)
    try:
        helper_script = importlib.import_module("helper_script")
        helper_script.greet()
    finally:
        sys.path.remove(folder)
        sys.modules.pop("helper_script", None)

Hello from the helper

In un progetto, tieni il modulo di supporto accanto allo script chiamante oppure in un pacchetto importabile. Durante l’importazione vengono eseguite anche le istruzioni che si trovano fuori dalle funzioni e dal blocco __main__; limita quindi il codice al livello del modulo a definizioni e inizializzazioni sicure da eseguire una sola volta.

Usa la funzione execfile() per eseguire uno script Python da un altro script Python

execfile() è una funzione legacy che esegue il codice di un file nell’interprete corrente. Può comparire nel codice meno recente, ma non è disponibile in tutti gli ambienti Python. Considerala una questione di compatibilità e verifica quale interprete usa il progetto prima di farvi affidamento. La sintassi di base è execfile("other_script.py"). La pagina in italiano non è disponibile; il collegamento apre la pagina in inglese.

exec() in Python può eseguire testo sorgente in uno spazio dei nomi scelto, ma non sostituisce direttamente execfile() per eseguire un file. Leggere un file e passare il suo contenuto a exec() modifica il comportamento dello spazio dei nomi e non isola il processo. L’esecuzione di codice proveniente da fonti non attendibili può avviare codice Python arbitrario; per riutilizzare codice, preferisci importare un modulo, mentre per un processo separato usa subprocess.

Usa il modulo subprocess per eseguire uno script Python da un altro script Python

Usa subprocess.run() quando vuoi eseguire l’altro script come processo figlio. Passa gli argomenti come elenco e usa sys.executable per selezionare lo stesso interprete Python che esegue lo script chiamante. Questo esempio crea e avvia un piccolo script figlio, poi controlla lo stato restituito e stampa l’output acquisito:

import subprocess
import sys
import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as folder:
    script_path = Path(folder) / "child.py"
    script_path.write_text('print("Child process ran")\n', encoding="utf-8")
    result = subprocess.run(
        [sys.executable, str(script_path)],
        check=True,
        capture_output=True,
        text=True,
    )
    print(result.stdout, end="")

Child process ran

Passa il percorso dello script come argomento e usa un percorso assoluto oppure imposta cwd se il processo figlio dipende da una specifica directory di lavoro. Se il processo figlio termina senza successo, check=True solleva CalledProcessError; ometti questa opzione e controlla returncode se lo script chiamante deve gestire direttamente lo stato. Usa capture_output=True per leggere stdout e stderr invece di inviarli al terminale.

Usa la funzione os.system() per eseguire uno script Python da un altro script Python

os.system() invia una stringa di comando alla shell del sistema operativo e restituisce un valore di stato. La shell interpreta la stringa, perciò gestire virgolette e differenze tra piattaforme può essere complicato. Non costruire mai il comando concatenando dati non attendibili: i metacaratteri della shell possono modificare ciò che viene eseguito. Per il nuovo codice, preferisci subprocess.run() con un elenco di argomenti: permette di gestire lo stato con maggiore chiarezza e, se necessario, di acquisire l’output. Usa os.system() soprattutto per mantenere codice legacy semplice che dipende già da un comando shell.

Usa il modulo importlib per eseguire uno script Python da un altro script Python

Usa importlib.import_module() quando il nome del modulo da importare viene scelto durante l’esecuzione. Importa il modulo nel processo corrente; non avvia un file arbitrario in un processo separato. Il modulo deve essere individuabile nel percorso di importazione di Python e, quando viene importato per la prima volta, vengono eseguite le sue istruzioni al livello principale.

Questo esempio crea un modulo importabile, ne seleziona dinamicamente il nome e chiama una sua funzione:

import importlib
import sys
import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as folder:
    module_path = Path(folder) / "task_module.py"
    module_path.write_text(
        'def run_task():\n'
        '    print("Task completed")\n',
        encoding="utf-8",
    )
    sys.path.insert(0, folder)
    try:
        module_name = "task_module"
        task_module = importlib.import_module(module_name)
        task_module.run_task()
    finally:
        sys.path.remove(folder)
        sys.modules.pop("task_module", None)

Task completed

Se il nome del modulo è fisso, un normale import è più semplice. Usa importlib quando il nome dipende davvero dalla configurazione disponibile durante l’esecuzione e verifica che tale configurazione faccia riferimento solo ai moduli che l’applicazione può caricare.

Conclusione

Usa import per riutilizzare funzioni e dati nel processo corrente e subprocess per eseguire un altro script in modo indipendente. importlib consente importazioni dinamiche tramite il nome del modulo. execfile() è una funzione legacy che può essere utile quando si esamina codice meno recente, mentre os.system() richiama una shell e offre un controllo limitato sul processo. Per avviare un processo separato nel nuovo codice, preferisci subprocess.run() con sys.executable e un elenco di argomenti.