Python Language
Delprocessbibliotek

Syntax

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

parametrar

Ringa externa kommandon

Det enklaste användningsfallet är att använda subprocess.call funktionen. Den accepterar en lista som det första argumentet. Det första objektet i listan ska vara den externa applikationen du vill ringa. De andra artiklarna i listan är argument som kommer att skickas till den applikationen.

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

För skalkommandon anger du shell=True och anger kommandot som en sträng istället för en lista.

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

Observera att de två kommandona ovan returnerar endast exit status för delprocessen. Var också uppmärksam när du använder shell=True eftersom det ger säkerhetsproblem (se här ).

Om du vill kunna få standardproduktionen för delprocessen, ersätt sedan subprocess.call med subprocess.check_output . För mer avancerad användning, se detta .

Mer flexibilitet med Popen

Använda subprocess.Popen ger mer finkornig kontroll över lanserade processer än subprocess.call .

Lansering av en delprocess

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

Signaturen för Popen liknar call ; emellertid kommer Popen tillbaka omedelbart istället för att vänta på att delprocessen ska slutföras som call gör.

Väntar på en delprocess att slutföra

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

Läser output från en delprocess

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

Interaktiv åtkomst till köra delprocesser

Du kan läsa och skriva på stdin och stdout även om delprocessen inte har slutförts. Detta kan vara användbart när du automatiserar funktionalitet i ett annat program.

Skriva till en delprocess

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.

Men om du bara behöver en uppsättning input och output, snarare än dynamisk interaktion, bör du använda communicate() snarare än att direkt komma åt stdin och stdout .

Läser en ström från en delprocess

Om du vill se utgången från en delprocess rad för rad kan du använda följande utdrag:

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

om underkommandoutgången inte har EOL-tecken fungerar ovannämnda utdrag inte. Du kan sedan läsa utgångstecken efter tecken på följande sätt:

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

Den 1 anges som argument till read metoden berättar läsa att läsa ett tecken i taget. Du kan ange att läsa så många tecken du vill använda med ett annat nummer. Negativt nummer eller 0 berättar att read att läsa som en enda sträng tills EOF stöter på ( se här ).

I båda ovanstående kodavsnitt är process.poll() None tills delprocessen är klar. Detta används för att lämna slingan när det inte finns mer utmatning att läsa.

Samma förfarande kan tillämpas på stderr av delprocess.

Hur man skapar argumentet för kommandolistan

Underprocessmetoden som tillåter körning av kommandon behöver kommandot i form av en lista (åtminstone med shell_mode=True ).

Reglerna för att skapa listan är inte alltid enkla att följa, särskilt med komplexa kommandon. Lyckligtvis finns det ett mycket användbart verktyg som gör det möjligt: shlex . Det enklaste sättet att skapa listan som ska användas som kommando är följande:

import shlex
cmd_to_subprocess = shlex.split(command_used_in_the_shell)

Ett enkelt exempel:

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

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