Python ejecutar otro script de Python

Para reutilizar código en el mismo proceso de Python, colóquelo en un módulo e impórtelo. Para ejecutar otro script de forma independiente, inicie un proceso hijo con subprocess. Elija la primera opción si necesita llamar funciones o compartir objetos; elija la segunda si el script debe conservar su propio proceso y comportamiento de línea de comandos.

Use la instrucción import para ejecutar un script de Python desde otro script de Python

Al importar un módulo, Python ejecuta sus instrucciones de nivel superior una vez, cuando lo carga por primera vez. Coloque el código reutilizable en funciones y ponga el comportamiento para la ejecución directa bajo if __name__ == "__main__":, para que no se ejecute solo porque otro módulo importe el archivo. Importe el nombre del módulo sin el sufijo .py.

Este ejemplo autónomo crea un módulo en un directorio temporal, lo importa y llama a su función:

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

En un proyecto, mantenga el módulo auxiliar junto al módulo que lo llama o dentro de un paquete importable. Las instrucciones que estén fuera de las funciones y de la condición __main__ también se ejecutan durante la importación; por eso, limite el código de nivel de módulo a definiciones y tareas de configuración que sea seguro ejecutar una sola vez.

Use la función execfile() para ejecutar un script de Python desde otro script de Python

execfile() es una función heredada que ejecuta el código de un archivo en el intérprete actual. Puede aparecer en código antiguo, pero no está disponible en todos los entornos de Python. Considérela una cuestión de compatibilidad y compruebe qué intérprete usa el proyecto antes de depender de ella. Su forma básica es execfile("other_script.py").

exec() de Python puede ejecutar texto fuente en un espacio de nombres elegido, pero no sustituye directamente a execfile() para ejecutar archivos. Leer un archivo y pasar su contenido a exec() cambia el comportamiento del espacio de nombres y no proporciona aislamiento de procesos. Ejecutar código de fuentes no confiables puede ejecutar código Python arbitrario; para reutilizar código, prefiera importar un módulo, y para usar un proceso separado, prefiera subprocess.

Use el módulo subprocess para ejecutar un script de Python desde otro script de Python

Use subprocess.run() cuando el otro script deba ejecutarse como proceso hijo. Pase los argumentos como una lista y use sys.executable para seleccionar el mismo intérprete de Python que ejecuta el programa llamador. Este ejemplo crea e inicia un pequeño script hijo, comprueba su estado de retorno e imprime la salida capturada:

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

Pase la ruta del script como argumento y use una ruta absoluta o establezca cwd cuando el proceso hijo dependa de un directorio de trabajo concreto. check=True genera CalledProcessError si el proceso hijo termina sin éxito; omítalo e inspeccione returncode si el programa llamador debe gestionar ese estado por su cuenta. Use capture_output=True para leer stdout y stderr en lugar de enviarlos al terminal.

Use la función os.system() para ejecutar un script de Python desde otro script de Python

os.system() envía una cadena de comandos al shell del sistema operativo y devuelve un valor de estado. El shell analiza esa cadena, lo que dificulta gestionar las comillas y las diferencias entre plataformas. Nunca construya el comando concatenando datos no confiables: los metacaracteres del shell pueden cambiar lo que se ejecuta. Para código nuevo, prefiera subprocess.run() con una lista de argumentos, que permite gestionar el estado con más claridad y capturar la salida de forma opcional. Use os.system() principalmente al mantener código heredado sencillo que ya depende de un comando del shell.

Use el módulo importlib para ejecutar un script de Python desde otro script de Python

Use importlib.import_module() cuando el nombre del módulo importable se determine durante la ejecución. Esta función importa un módulo en el proceso actual; no inicia un archivo arbitrario como proceso separado. Python debe poder encontrar el módulo en su ruta de importación, y sus instrucciones de nivel superior se ejecutan cuando se importa por primera vez.

Este ejemplo crea un módulo importable, selecciona su nombre de forma dinámica y llama a su función:

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

Si el nombre del módulo es fijo, una instrucción import normal es más sencilla. Use importlib cuando el nombre dependa realmente de la configuración en tiempo de ejecución, y valide esa configuración para limitarla a los módulos que la aplicación tiene permitido cargar.

Conclusión

Use import para reutilizar funciones y datos en el proceso actual, y subprocess para ejecutar otro script de forma independiente. importlib permite importar módulos dinámicamente por nombre. execfile() es una función heredada que puede ser relevante al leer código antiguo, mientras que os.system() invoca un shell y ofrece un control limitado del proceso. Para código nuevo que necesite un proceso separado, prefiera subprocess.run() con sys.executable y una lista de argumentos.