Python-subprocess-Modul
subprocessist ein Modul in der Python-Standardbibliothek, das zum Erstellen und Verwalten von Unterprozessen verwendet wird.
subprocessEs ermöglicht dir, externe Befehle in Python-Programmen auszuführen und mit diesen Befehlen zu interagieren.
Durchsubprocessdem Modul können Sie Systembefehle ausführen, andere Programme aufrufen und deren Ausgabe- oder Fehlermeldungen abrufen.
Warum das subprocess-Modul verwenden?
In Python müssen wir manchmal Systembefehle ausführen oder andere Programme aufrufen, um bestimmte Aufgaben zu erledigen. Zum Beispiel musst du möglicherweise einen Shell-Befehl ausführen, eine externe Anwendung starten oder mit einem Befehlszeilentool interagieren.subprocessDas Modul bietet eine sichere und flexible Möglichkeit, mit diesen Anforderungen umzugehen.
Verglichen mit den früherenos.system()oderos.popen()Ansätzen,subprocessdas Modul bietet leistungsfähigere Funktionalität und bessere Kontrolle. Es ermöglicht dir, die Eingabe-, Ausgabe- und Fehlerströme von Subprozessen feiner zu verwalten und komplexere Szenarien zu bewältigen.
Kernfunktionen des subprocess-Moduls
1. Externe Befehle ausführen
subprocess.run()JasubprocessEine der am häufigsten verwendeten Funktionen im Modul. Sie kann einen externen Befehl ausführen und warten, bis der Befehl abgeschlossen ist. Hier ist ein einfaches Beispiel:
Beispiel
# Führen Sie einen einfachen Shell-Befehl aus
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
# Geben Sie die Ausgabe des Befehls aus
print(result.stdout)
In diesem Beispiel,subprocess.run()führte denls -lBefehl aus und erfasste die Ausgabe inresult.stdoutdas Ergebnis.
2. Eingabe und Ausgabe verarbeiten
subprocessDas Modul ermöglicht es Ihnen, die Eingabe-, Ausgabe- und Fehlerströme von Subprozessen zu steuern. Sie können Daten an die Standardeingabe eines Subprozesses übergeben oder Daten aus der Standardausgabe und dem Standardfehler eines Subprozesses lesen. Hier ist ein Beispiel:
Beispiel
# Führen Sie einen Befehl aus und übergeben Sie dem Subprozess eine Eingabe
result = subprocess.run(['grep', 'python'], input='hello\npython\nworld', capture_output=True, text=True)
# Geben Sie die Ausgabe des Befehls aus
print(result.stdout)
In diesem Beispiel,subprocess.run()führte dengrep pythonBefehl und übergab die Zeichenfolge'hello\npython\nworld'als Eingabe an den Subprozess.
3. Fehler behandeln
subprocessDas Modul ermöglicht es Ihnen außerdem, Fehler von Subprozessen zu behandeln. Wenn ein Subprozess einen Exit-Status-Code ungleich null zurückgibt,subprocess.run()wird eineCalledProcessErrorAusnahme.result.returncodeSie können prüfen
Beispiel
try:
result = subprocess.run(['ls', 'nonexistent_file'], capture_output=True, text=True, check=True)
except subprocess.CalledProcessError as e:
print(f"Command failed with return code {e.returncode}")
print(f"Error output: {e.stderr}")
Beispielsubprocess.run()In diesem Beispiel,ls nonexistent_fileführte denCalledProcessErrorBefehl. Weil die Datei nicht existiert, ist der Befehl fehlgeschlagen und hat eine
Fortgeschrittene Nutzung des subprocess-Moduls
1. Verwendung der Popen-Klasse
subprocess.Popen1. Verwendung der Popen-KlassePopenDie Klasse bietet eine Schnittstelle auf niedrigerer Ebene, mit der Sie Subprozesse flexibler steuern können. Sie können
Beispiel
Beispiel
process = subprocess.Popen(['ping', 'google.com'], stdout=subprocess.PIPE, text=True)
# Starte einen Subprozess
while True:
output = process.stdout.readline()
if output == '' and process.poll() is not None:
break
if output:
print(output.strip())
# Lies die Ausgabe des Subprozesses
return_code = process.poll()
print(f"Prozess beendet mit Rückgabecode {return_code}")
# Exit-Status-Code des Subprozesses abrufensubprocess.PopenIn diesem Beispiel,ping google.comstartete ein
2. Pipes verwenden
subprocess2. Pipes verwenden
Beispiel
Beispiel
p1 = subprocess.Popen(['ls', '-l'], stdout=subprocess.PIPE)
p2 = subprocess.Popen(['grep', 'py'], stdin=p1.stdout, stdout=subprocess.PIPE, text=True)
# Eine Pipe verwenden, um zwei Befehle zu verbinden
output = p2.communicate()[0]
print(output)
# Die endgültige Ausgabe abrufenls -lIn diesem Beispiel,grep pydie Ausgabe des Befehls wird übergeben anpyBefehl, und die endgültige Ausgabe enthält
Übliche Methoden, Klassen und Parameter des subprocess-Moduls
Im Folgenden werden übliche Methoden, Klassen und Parameter des Python-subprocess-Moduls beschrieben, einschließlich Funktionsbeschreibungen und Beispielen:
Kernmethoden des subprocess-Moduls
| Methode | Beschreibung | Beispiel |
|---|---|---|
subprocess.run() | Einen Befehl ausführen und auf den Abschluss warten (empfohlen) | subprocess.run(["ls", "-l"], capture_output=True, text=True) |
subprocess.Popen() | Einen Unterprozess erstellen (Low-Level-Steuerung) | proc = subprocess.Popen(["ping", "google.com"], stdout=subprocess.PIPE) |
subprocess.call() | Einen Befehl ausführen und den Exit-Code zurückgeben (veraltet) | exit_code = subprocess.call(["python", "--version"]) |
subprocess.check_call() | Einen Befehl ausführen und bei Fehlschlag eine Ausnahme auslösen | subprocess.check_call(["git", "commit"]) |
subprocess.check_output() | Einen Befehl ausführen und die Ausgabe zurückgeben (veraltet) | output = subprocess.check_output(["date"], text=True) |
Objektattribute von subprocess.CompletedProcess (Rückgabeobjekt der Methode run())
| Attribute | Beschreibung |
|---|---|
args | Liste der ausgeführten Befehlsargumente |
returncode | Exit-Statuscode des Prozesses (0 zeigt Erfolg an) |
stdout | Inhalt der Standardausgabe (falls gesetztcapture_output） |
stderr | Inhalt der Standardfehlerausgabe (falls gesetztcapture_output） |
Gängige Methoden/Attribute der Klasse subprocess.Popen
| Methode/Attribut | Beschreibung | Beispiel |
|---|---|---|
poll() | Prüfen, ob der Prozess beendet wurde (gibt zurückNoneTrue, um anzuzeigen, dass er läuft) | if proc.poll() is None: print("Running") |
wait() | Blockiert, bis der Prozess endet | proc.wait() |
communicate() | Interaktive Eingabe/Ausgabe | stdout, stderr = proc.communicate(input="data") |
terminate() | Terminierungssignal senden (SIGTERM) | proc.terminate() |
kill() | Prozess zwangsweise beenden (SIGKILL) | proc.kill() |
stdin | Der Standardeingabestream des Prozesses | proc.stdin.write("input") |
stdout | Der Standardausgabestream des Prozesses | print(proc.stdout.read()) |
stderr | Der Standardfehlerstream des Prozesses | errors = proc.stderr.read() |
Allgemeine Parameterbeschreibungen (anwendbar auf run() und Popen())
| Parameter | Beschreibung | Beispielwert |
|---|---|---|
args | Befehl (Liste oder Zeichenfolge) | ["ls", "-l"]oder"ls -l" |
stdin | Konfiguration der Standardeingabe | subprocess.PIPE(pipe),None(inherit) |
stdout | Konfiguration der Standardausgabe | subprocess.PIPE、open('log.txt', 'w') |
stderr | Konfiguration der Standardfehlerausgabe | subprocess.STDOUT(in stdout zusammengeführt) |
shell | Ob über die Shell ausgeführt wird | True(unterstützt Zeichenfolgen-Befehle) |
cwd | Arbeitsverzeichnispfad | "/tmp" |
env | Benutzerdefinierte Umgebungsvariablen | {"PATH": "/usr/bin"} |
timeout | Timeout (Sekunden) | 30 |
text | Ob Eingabe/Ausgabe ein String ist (nicht Bytes) | True |
Beispiel
Befehl ausführen und Ausgabe erfassen:
Beispiel
print(result.stdout) # Ausgabe: "Hello\n"
Komplexe Befehle über Shell ausführen:
subprocess.run("grep 'error' log.txt | wc -l", shell=True, check=True)Ausgabestream in Echtzeit abrufen:Beispiel
while True:
line = proc.stdout.readline()
if not line: break
print(line.decode().strip())
Zeitüberschreitungssteuerung:
Beispiel
subprocess.run(["sleep", "10"], timeout=5)
except subprocess.TimeoutExpired:
print("Befehl hat das Zeitlimit überschritten!")