¿Qué es import subprocess y cómo usarlo en Python?

Si, como yo, te has preguntado cómo puedes ejecutar comandos del sistema desde un script en Python, te quiero contar que la solución es el módulo de import subprocess. El import subprocess es la manera en la que se importa subprocess, un módulo que sirve como un puente que conecta tu código con las funciones que tiene el sistema operativo, l que nos permite lanzar comandos, capturar su salidas y manejar errores de formas más simples. En el artículo de hoy te compartiré algunos trucos para usar este módulo en Python.

¿Qué es el módulo de import subprocess?

El módulo de import subprocess es una herramienta en Python diseñada para reemplazar funciones más antiguas, como os.system. Nos permite interactuar fácilmente con el sistema operativo y de una forma mucho más controlada, ejecutando comandos y manejando procesos con mayor seguridad y precisión. Lo más impresionante es que tienes la posibilidad de evitar los riesgos de seguridad que se asocian con funciones obsoletas y también p uedes obener un p oco más de control sobre la entrada, salida y errores de los diferentes procesos.

Algunos de los beneficios que trae el uso de import subprocess son:

1. Control detallado: Puedes decidir cómo manejar la entrada y salida estándar de un comando, o incluso redirigirlos.
2. Mayor seguridad: Evita vulnerabilidades como la inyección de comandos cuando no usas la shell del sistema directamente.
3. Portabilidad: Funciona en múltiples sistemas operativos, haciendo tu código más adaptable.

¿Cómo empezar a usar import subprocess?

Uno de los métodos más usados para empezar a trabajar con import subprocess es el módulo subprocess.run. Este es un método que ejecuta un comando, espera a que termine y devuelve un objeto que contiene el resultado de la ejecución. Veamos un ejemplo en el que se muestra cómo listar los archivos de un directorio utilizando subprocess.run:

import subprocess

resultado = subprocess.run(["ls", "-l"], capture_output=True, text=True)
print(resultado.stdout)

En este caso:

• El argumento capture_output indica que queremos capturar la salida del comando.
• La opción text asegura que la salida esté en formato de texto legible, en lugar de bytes.

Manejo de errores con subprocess.run

Puedes manejar errores utilizando el parámetro check. Este lanzará una excepción si el comando falla:

import subprocess

try:
    subprocess.run(["exit", "1"], check=True)
except subprocess.CalledProcessError as e:
    print(f"El comando falló con el código: {e.returncode}")

Esto permite gestionar los errores que puedan ocurrir durante la ejecución.

Función de la clase Popen en el import subprocess

Si quieres o necesitas un control más avanzado en el import subprocess, puedes hacer uso de la clase Popen. Esta es una herramienta perfecta en aquellos casos en los que quieres interactuar con el proceso mientras está en ejecución, como por ejemplo si quieres enviar datos a su entrada estándar o procesar su salida de manera personalizada.

Veamos un fragmento de código que ejemplifica cómo capturar y procesar la salida de un comando:

import subprocess

proceso = subprocess.Popen(["echo", "Hola, mundo"], stdout=subprocess.PIPE)
salida, _ = proceso.communicate()
print(salida.decode())

En este código:

• Popen permite ejecutar el comando y conectarlo a un pipe.
• El método communicate captura la salida del comando y asegura que se procese adecuadamente.

Al usar Popen, hay algunos argumentos que es necesario reconocer:

• stdin, stdout y stderr: Estos controlan la entrada y salida estándar del proceso.
• shell: Si es True, el comando se ejecutará en la shell del sistema, lo cual puede ser útil, pero también introduce riesgos de seguridad.
• env: Permite configurar variables de entorno personalizadas para el proceso.

Seguridad al usar subprocess

Cuando sueles usar import subprocess, en especial si lo usas con el parámetro Shell configurado en True, debes tener mucho cuidado con las entradas que pasan al comando para así evitar vulnerabilidades de inyección de comandos. Una de las formas de proteger tu código es usar la función shlex.quote para escapar caracteres especiales:

import subprocess
import shlex

comando = "echo 'Texto seguro'"
seguro = shlex.quote(comando)
subprocess.run(seguro, shell=True)

Este enfoque asegura que los caracteres especiales no sean interpretados de manera inesperada por la shell.

¿Quieres especializarte en programación y empezar a labrar tu carrera en un sector lleno de oportunidades? El Bootcamp de programación desde cero que tiene KeepCoding te ayudará a conseguirlo en cuestión de meses. ¡No dejes pasar la ocasión y súmate ya a la revolución tecnológica!