Python Language
Biblioteca de subproceso

Sintaxis

• subprocess.call (args, *, stdin = None, stdout = None, stderr = None, shell = False, timeout = None)
• subprocess.Popen (args, bufsize = -1, executable = None, stdin = None, stdout = None, stderr = None, preexec_fn = None, close_fds = True, shell = False, cwd = None, env = None, universal_newlines = False , startupinfo = Ninguna, creationflags = 0, restore_signals = True, start_new_session = False, pass_fds = ())

Parámetros

Llamando Comandos Externos

El caso de uso más simple es usar la función subprocess.call . Acepta una lista como primer argumento. El primer elemento de la lista debe ser la aplicación externa a la que desea llamar. Los otros elementos de la lista son argumentos que se pasarán a esa aplicación.

subprocess.call([r'C:\path\to\app.exe', 'arg1', '--flag', 'arg'])

Para los comandos de shell, establezca shell=True y proporcione el comando como una cadena en lugar de una lista.

subprocess.call('echo "Hello, world"', shell=True)

Tenga en cuenta que los dos comandos anteriores solo devuelven el exit status de exit status del subproceso. Además, preste atención cuando use shell=True ya que proporciona problemas de seguridad (consulte aquí ).

Si desea poder obtener la salida estándar del subproceso, sustituya el subprocess.call con subprocess.check_output . Para un uso más avanzado, refiérase a esto .

Más flexibilidad con Popen

El uso de subprocess.Popen proporciona un control más preciso sobre los procesos iniciados que subprocess.call .

Lanzar un subproceso

process = subprocess.Popen([r'C:\path\to\app.exe', 'arg1', '--flag', 'arg'])

La firma para Popen es muy similar a la función de call ; sin embargo, Popen regresará de inmediato en lugar de esperar a que se complete el subproceso como lo hace la call .

Esperando en un subproceso para completar

process = subprocess.Popen([r'C:\path\to\app.exe', 'arg1', '--flag', 'arg'])
process.wait()

Salida de lectura de un subproceso

process = subprocess.Popen([r'C:\path\to\app.exe'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)

# This will block until process completes
stdout, stderr = process.communicate()
print stdout
print stderr

Acceso interactivo a subprocesos en ejecución.

Puede leer y escribir en stdin y stdout incluso cuando el subproceso no se haya completado. Esto podría ser útil al automatizar la funcionalidad en otro programa.

Escribiendo a un subproceso

process = subprocess.Popen([r'C:\path\to\app.exe'], stdout = subprocess.PIPE, stdin = subprocess.PIPE)


process.stdin.write('line of input\n') # Write input

line  = process.stdout.readline() # Read a line from stdout

# Do logic on line read.

Sin embargo, si solo necesita un conjunto de entrada y salida, en lugar de una interacción dinámica, debe usar communicate() lugar de acceder directamente a stdin y stdout .

Leyendo un stream desde un subproceso

En caso de que quiera ver la salida de un subproceso línea por línea, puede usar el siguiente fragmento de código:

process = subprocess.Popen(<your_command>, stdout=subprocess.PIPE)
while process.poll() is None:
    output_line = process.stdout.readline()

en el caso de que la salida del subcomando no tenga un carácter EOL, el fragmento de código anterior no funciona. A continuación, puede leer el carácter de salida por carácter de la siguiente manera:

process = subprocess.Popen(<your_command>, stdout=subprocess.PIPE)
while process.poll() is None:
    output_line = process.stdout.read(1)

El 1 especificado como argumento a la read método se indica a leer a leer 1 carácter cada vez. Puede especificar leer tantos caracteres como desee utilizando un número diferente. El número negativo o 0 indica que se read para leer como una sola cadena hasta que se encuentre el EOF ( consulte aquí ).

En los dos fragmentos de código anteriores, process.poll() es None hasta que finalice el subproceso. Esto se usa para salir del bucle una vez que no hay más salida para leer.

El mismo procedimiento podría aplicarse al stderr del subproceso.

Cómo crear el argumento de la lista de comandos

El método de subproceso que permite ejecutar comandos necesita el comando en forma de una lista (al menos usando shell_mode=True ).

Las reglas para crear la lista no siempre son sencillas de seguir, especialmente con comandos complejos. Afortunadamente, hay una herramienta muy útil que permite hacer eso: shlex . La forma más fácil de crear la lista que se utilizará como comando es la siguiente:

import shlex
cmd_to_subprocess = shlex.split(command_used_in_the_shell)

Un ejemplo simple:

import shlex
shlex.split('ls --color -l -t -r')

out: ['ls', '--color', '-l', '-t', '-r']