Python Language
Libreria di sottoprocesso

Sintassi

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

Parametri

Chiamare i comandi esterni

Il caso d'uso più semplice sta usando la funzione subprocess.call . Accetta un elenco come primo argomento. Il primo elemento nell'elenco dovrebbe essere l'applicazione esterna che si desidera chiamare. Gli altri elementi nell'elenco sono argomenti che verranno passati a tale applicazione.

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

Per i comandi della shell, imposta shell=True e fornisci il comando come una stringa invece di una lista.

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

Si noti che i due comandi precedenti restituiscono solo lo exit status di exit status del sottoprocesso. Inoltre, fai attenzione quando usi shell=True dato che fornisce problemi di sicurezza (vedi qui ).

Se si desidera essere in grado di ottenere l'output standard del sottoprocesso, quindi sostituire il subprocess.call con subprocess.check_output . Per un uso più avanzato, fare riferimento a questo .

Maggiore flessibilità con Popen

Utilizzo di subprocess.Popen offre un controllo più dettagliato sui processi avviati rispetto a subprocess.call .

Avvio di un sottoprocesso

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

La firma per Popen è molto simile alla funzione di call ; tuttavia, Popen ritornerà immediatamente invece di attendere che il sottoprocesso completi come fa la call .

In attesa di un sottoprocesso da completare

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

Lettura dell'output da un sottoprocesso

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

Accesso interattivo ai sottoprocessi in esecuzione

È possibile leggere e scrivere su stdin e stdout anche se il sottoprocesso non è stato completato. Questo potrebbe essere utile quando si automatizzano le funzionalità in un altro programma.

Scrivere su un sottoprocesso

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.

Tuttavia, se hai solo bisogno di un set di input e output, piuttosto che di interazione dinamica, dovresti usare communicate() piuttosto che accedere direttamente a stdin e stdout .

Leggere un flusso da un sottoprocesso

Nel caso in cui si desideri visualizzare l'output di un sottoprocesso riga per riga, è possibile utilizzare il seguente frammento:

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

nel caso in cui l'output del sottocomando non abbia carattere EOL, lo snippet sopra riportato non funziona. È quindi possibile leggere l'output carattere per carattere come segue:

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

Il 1 specificata come argomento al read metodo indica Leggi per leggere 1 carattere alla volta. Puoi specificare di leggere tutti i caratteri che vuoi usando un numero diverso. Il numero negativo o 0 indica di read come una singola stringa finché non viene rilevato EOF ( vedere qui ).

In entrambi i frammenti di cui sopra, il file process.poll() è None fino al termine del sottoprocesso. Questo è usato per uscire dal ciclo una volta che non c'è più uscita da leggere.

La stessa procedura potrebbe essere applicata allo stderr del sottoprocesso.

Come creare l'argomento della lista comandi

Il metodo di sottoprocesso che consente di eseguire i comandi richiede il comando sotto forma di elenco (almeno utilizzando shell_mode=True ).

Le regole per creare l'elenco non sono sempre semplici da seguire, specialmente con comandi complessi. Fortunatamente, c'è uno strumento molto utile che consente di farlo: shlex . Il modo più semplice per creare l'elenco da utilizzare come comando è il seguente:

import shlex
cmd_to_subprocess = shlex.split(command_used_in_the_shell)

Un semplice esempio:

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

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