Python Language
Subproces bibliotheek

Syntaxis

• 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 = Geen, creationflags = 0, restore_signals = True, start_new_session = False, pass_fds = ())

parameters

Externe opdrachten oproepen

Het eenvoudigste gebruik is het gebruik van de functie subprocess.call . Het accepteert een lijst als het eerste argument. Het eerste item in de lijst moet de externe toepassing zijn die u wilt bellen. De andere items in de lijst zijn argumenten die aan die toepassing worden doorgegeven.

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

Stel voor shell-opdrachten shell=True en geef de opdracht op als een string in plaats van een lijst.

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

Merk op dat de twee bovenstaande opdracht alleen de exit status van het subproces teruggeeft. Let bovendien op bij het gebruik van shell=True omdat dit beveiligingsproblemen oplevert (zie hier ).

Als u de standaarduitvoer van het subproces wilt kunnen verkrijgen, vervangt u het subprocess.call door subprocess.check_output . Voor meer geavanceerd gebruik, verwijzen naar deze .

Meer flexibiliteit met Popen

Het gebruik van subprocess.Popen geeft meer verfijnde controle over gestarte processen dan subprocess.call .

Een subproces starten

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

De handtekening voor Popen lijkt erg op de call ; Popen keert echter onmiddellijk terug in plaats van te wachten tot het subproces is voltooid zoals de call doet.

Wachten op een subproces om te voltooien

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

Uitvoer van een subproces lezen

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

Interactieve toegang tot actieve subprocessen

U kunt lezen en schrijven op stdin en stdout zelfs als het subproces niet is voltooid. Dit kan handig zijn bij het automatiseren van functionaliteit in een ander programma.

Schrijven naar een subproces

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.

Als u echter slechts één set invoer en uitvoer nodig hebt, in plaats van dynamische interactie, moet u communicate() plaats van rechtstreeks toegang te krijgen tot stdin en stdout .

Een stream uit een subproces lezen

Als u de uitvoer van een subproces regel voor regel wilt zien, kunt u het volgende fragment gebruiken:

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

in het geval dat de subopdrachtuitvoer geen EOL-teken heeft, werkt het bovenstaande fragment niet. U kunt de uitvoer vervolgens teken voor teken als volgt lezen:

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

De 1 opgegeven als argument voor de read , vertelt lezen om 1 teken per keer te lezen. U kunt opgeven dat u zoveel tekens wilt lezen als u een ander nummer gebruikt. Negatief getal of 0 geeft aan dat read moet worden als een enkele tekenreeks totdat de EOF wordt aangetroffen ( zie hier ).

In beide bovenstaande fragmenten is process.poll() None totdat het subproces is voltooid. Dit wordt gebruikt om de lus te verlaten zodra er geen uitvoer meer is om te lezen.

Dezelfde procedure kan worden toegepast op de stderr van het subproces.

Hoe het commandolijstargument te maken

De subprocesmethode die het uitvoeren van opdrachten mogelijk maakt, heeft de opdracht nodig in de vorm van een lijst (tenminste met shell_mode=True ).

De regels om de lijst te maken zijn niet altijd eenvoudig te volgen, vooral bij complexe opdrachten. Gelukkig is er een zeer handige tool die dat mogelijk maakt: shlex . De eenvoudigste manier om de lijst te maken die als opdracht moet worden gebruikt, is de volgende:

import shlex
cmd_to_subprocess = shlex.split(command_used_in_the_shell)

Een eenvoudig voorbeeld:

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

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