La bilioteca estándar proporciona diversos modos de ejecutar un subproceso, ofreciendo diferentes posibilidades y diferentes niveles de complejidad. os.system(command) es fácil de usar, pero es lenta (ejecuta un nuevo proceso del intérprete de órdenes, que ejecuta la orden) y potencialmente peligrosa (hay que tener cuidado de neutralizar todos los metacaracteres del intérprete). El módulo popen2 contiene clases para capturar la salida estándar y el flujo de errores estándar del subproceso, pero la nomenclatura resulta confusa. El módulo subprocess aclara todo esto, proporcionando una interfaz que ofrece todas las posibilidades que se puedan necesitar.
En lugar de la colección de clases de popen2, subprocess contiene una sola clase denominada Popen, cuyo constructor permite diversos parámetros por nombre.
class Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0):
args suele ser una secuencia de cadenas que supondrán los argumentos del programa ejecutado como subproceso (si el argumento shell es verdadero, args puede ser una cadena que se le pasará al intérprete de órdenes para que lo interprete, igual que hace os.system()).
stdin, stdout y stderr especifican cuáles serán
los flujos de entrada, salida y errores del subproceso. Se puede
proporcionar un objeto fichero o un descriptor de fichero, o se puede
usar la constante subprocess.PIPE
para crear una tubería entre
el subproceso y el padre.
El constructor dispone de útiles opciones:
Una vez creada la instancia de Popen, se puede llamar a su método
wait() para detenerlo hasta que el subproceso haya terminado,
poll() para verificar si ha terminado sin parar, o
communicate(data) para enviar la cadena data a la
entrada estándar del subproceso. communicate(data)
lee a su vez cualquier dato que el subproceso haya enviado a su salida
estándar de flujo de errores, devolviendo una tupla (stdout_data,
stderr_data)
.
call() es un atajo que traspasa sus argumentos al constructor de Popen, espera a que termine la orden y devuelve el código de estado resultante del subproceso. Puede servir como análogo más seguro de os.system():
sts = subprocess.call(['dpkg', '-i', '/tmp/new-package.deb']) if sts == 0: # Éxito ... else: # dpkg ha devuelto un error ...
Se invoca la orden sin uso del intérprete de órdenes. Si realmente sí que se
desea usar el intérprete, se puede añadir shell=True
como argumento
con nombre y proporcionar una cadena en lugar de una secuencia:
sts = subprocess.call('dpkg -i /tmp/new-package.deb', shell=True)
La PEP toma varios ejemplos de código del intérprete de línea de órdenes y de Python y muestra cómo se traduciría a código de Python que utilice subprocess. Se recomienda encarecidamente leer esta sección de la PEP.
See Also:
Consultar en Acerca de este documento... información para sugerir cambios.