El mundo de la programación en Python

Cómo ejecutar comandos en Python: Guía completa con ejemplos prácticos

Bibliotecas externas, API y comunicación
目次

1. ¿Qué significa ejecutar comandos en Python?

Python es un lenguaje de programación utilizado para automatizar diversas tareas, y una de sus grandes ventajas es la posibilidad de ejecutar operaciones de la línea de comandos directamente desde un programa. Con Python, es posible invocar funciones del sistema operativo para automatizar la gestión de archivos y la administración del sistema. En este artículo se presentan los métodos básicos y avanzados para ejecutar comandos en Python.

2. Métodos básicos para ejecutar comandos en Python

La forma más sencilla de ejecutar comandos en Python es mediante os.system() o el módulo subprocess. Cada método tiene ventajas y desventajas, por lo que es importante elegir el adecuado según la situación.

2.1 Ejecución de comandos con os.system()

os.system() es un método simple para ejecutar comandos del sistema desde un programa Python. Se usa de la siguiente manera:
import os
os.system('ls')
Este método es fácil de utilizar, pero no permite obtener el resultado del comando y plantea preocupaciones de seguridad, por lo que no se recomienda generalmente. Hoy en día, se prefiere usar el módulo subprocess por ser más seguro y controlable.

2.2 Ejecución básica de comandos con subprocess.run()

subprocess.run() es el método recomendado para ejecutar comandos en Python. Permite capturar resultados y manejar errores de forma flexible y segura.
import subprocess
subprocess.run(['ls', '-l'])
Este código ejecuta el comando ls -l y muestra el resultado en la salida estándar. subprocess.run() funciona de manera sincrónica, lo que significa que espera a que finalice el comando antes de continuar. Es especialmente útil para operaciones de archivos y administración del sistema.
侍エンジニア塾

3. Ejecución avanzada de comandos: procesos asíncronos y tuberías

Cuando se requieren ejecuciones más complejas, el módulo subprocess permite manejar procesos asíncronos y comunicación entre comandos mediante tuberías.

3.1 Ejecución asíncrona con subprocess.Popen()

La ejecución asíncrona permite continuar con el programa sin esperar a que el comando termine. Es útil para ejecutar múltiples tareas al mismo tiempo. Ejemplo:
import subprocess
proc = subprocess.Popen(['sleep', '5'])
print("El comando se está ejecutando")
Este código ejecuta el comando sleep 5 de manera asíncrona y muestra el mensaje sin esperar. Es ideal para comandos de larga duración o tareas concurrentes.

3.2 Procesamiento en tuberías con múltiples comandos

Cuando se necesita encadenar comandos, se pueden usar tuberías. Por ejemplo, leer el contenido de un archivo y escribirlo en otro:
import subprocess
with open('input.txt') as input_file, open('output.txt', 'w') as output_file:
    subprocess.run(['cat'], stdin=input_file, stdout=output_file)
Este código lee input.txt con cat y escribe el contenido en output.txt. Una de las ventajas de subprocess.run() es la posibilidad de conectar entradas y salidas estándar.

4. Manejo de errores y captura de resultados

Un aspecto esencial al ejecutar comandos es manejar errores y capturar la salida. subprocess está diseñado para soportar ambos casos.

4.1 Captura de salida estándar y de errores

Con subprocess.run() es posible capturar la salida estándar y la salida de errores:
import subprocess
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(result.stdout)
Al especificar capture_output=True, se guarda la salida en result.stdout. Los errores pueden consultarse con result.stderr.

4.2 Manejo de excepciones

Si ocurre un error durante la ejecución, Python genera una excepción. Esto puede manejarse con un bloque try-except:
import subprocess
try:
    subprocess.run(['invalid_command'], check=True)
except subprocess.CalledProcessError as e:
    print(f"Ocurrió un error: {e}")
Al usar check=True, se genera una excepción en caso de fallo y se puede registrar el error o ejecutar acciones alternativas.
年収訴求

5. Diferencias entre Windows, Mac y Linux

La ejecución de comandos en Python puede variar según el sistema operativo. En particular, existen diferencias entre Windows y los sistemas Unix (Linux y macOS).

5.1 Ejecución en Windows

En Windows, se usan el Símbolo del sistema o PowerShell. Por ejemplo, para listar directorios:
import subprocess
subprocess.run(['dir'], shell=True)
En este caso es necesario shell=True para ejecutar comandos internos de la shell.

5.2 Ejecución en sistemas Unix

En Linux y macOS, los comandos se ejecutan directamente. Por ejemplo:
import subprocess
subprocess.run(['ls', '-l'])
La sintaxis en sistemas Unix suele ser más simple que en Windows.

6. Conclusión

Ejecutar comandos en Python permite automatizar la gestión de archivos y tareas del sistema de manera eficiente. Con el módulo subprocess, se pueden realizar desde ejecuciones básicas hasta procesos asíncronos y tuberías. Además, el manejo de errores y la compatibilidad con diferentes sistemas operativos permiten crear soluciones más robustas. Comprender estas técnicas te ayudará a optimizar tu flujo de trabajo y a mejorar tus habilidades de programación. ¡Ponlo en práctica y lleva tu código al siguiente nivel!