Eine Einführung in Python Subprocess: Grundlagen und Beispiele

Wann sollte man Python Subprocess verwenden?

Systemaufgaben automatisieren

Mit dem Subprozessmodul können verschiedene Systemaufgaben automatisiert werden, z. B. Backups, das Starten und Stoppen von Diensten und das Planen von Cron-Jobs. Mit dem Unterprozessmodul kannst du zum Beispiel den Befehl "cp" ausführen, um ein Backup einer Datei zu erstellen, oder den Befehl "service", um Dienste auf Linux-Systemen zu starten und zu beenden.

Du kannst das Unterprozessmodul auch verwenden, um Aufgaben zu planen, die in bestimmten Intervallen mit Cron oder anderen Zeitplanungswerkzeugen ausgeführt werden.

Ausführen von Befehlszeilentools

Das Modul subprocess kann verwendet werden, um Kommandozeilen-Tools wie grep, sed und awk auszuführen und deren Ausgabe in deinem Python-Code zu verarbeiten. Mit dem Modul subprocess kannst du zum Beispiel den Befehl "grep" ausführen, um nach einem bestimmten Muster in einer Datei zu suchen und die Ausgabe dann in deinem Python-Code zu verarbeiten. Das kann für Aufgaben wie die Log-Analyse, Datenverarbeitung und Textmanipulation nützlich sein.

Externe ausführbare Dateien ausführen

Das Subprozessmodul kann andere ausführbare Dateien, wie z.B. .exe-Dateien unter Windows, ausführen und ihr Verhalten steuern. Du kannst zum Beispiel das Unterprozessmodul verwenden, um eine ausführbare Datei auszuführen, die eine bestimmte Aufgabe erfüllt, und dann die Ausgabe dieser ausführbaren Datei in deinem eigenen Code verwenden. Das kann bei der Bildverarbeitung, der Datenanalyse und beim maschinellen Lernen nützlich sein.

Skripte als Hintergrundprozesse ausführen

Du kannst das Unterprozessmodul verwenden, um Skripte als Hintergrundprozesse laufen zu lassen, so dass sie weiterlaufen, nachdem das Hauptprogramm beendet wurde. Mit dem Unterprozessmodul kannst du zum Beispiel ein Skript ausführen, das eine bestimmte Aufgabe erledigt, und das Hauptprogramm beenden, ohne auf die Fertigstellung des Skripts zu warten. Dies kann für die Überwachung, Protokollierung und Datenerfassung nützlich sein.

Skripte mit einem Nicht-Python-Interpreter ausführen

Mit dem Modul subprocess kannst du Skripte ausführen, die in anderen Sprachen wie Perl, Ruby und Bash geschrieben wurden. Du kannst das Subprozessmodul zum Beispiel verwenden, um ein Perl-Skript auszuführen, das eine bestimmte Aufgabe erledigt, und dann die Ausgabe dieses Skripts in deinem eigenen Code verwenden. Das kann bei der Datenverarbeitung, Textmanipulation und Systemverwaltung nützlich sein.

Parallele Verarbeitung

Mit dem Unterprozessmodul kannst du mehrere Prozesse parallel laufen lassen, was für Aufgaben wie Bildverarbeitung, Datenanalyse und maschinelles Lernen nützlich sein kann. Du kannst zum Beispiel das Unterprozessmodul verwenden, um mehrere Instanzen desselben Skripts auszuführen, die jeweils einen anderen Teil der Daten verarbeiten, und dann die Ergebnisse kombinieren.

Beispiele für Python-Unterprozesse 

python subprocess run

Die Methode subprocess.run() ist eine bequeme Methode, um einen Unterprozess zu starten und zu warten, bis er abgeschlossen ist. Hier kannst du den auszuführenden Befehl auswählen und Optionen wie Argumente, Umgebungsvariablen und Ein-/Ausgabeumleitungen hinzufügen. Sobald der Unterprozess gestartet ist, blockiert die Methode run(), bis der Unterprozess abgeschlossen ist und gibt ein CompletedProcess-Objekt zurück, das den Rückgabecode und die Ausgabe des Unterprozesses enthält.

Die Methode subprocess.run() benötigt mehrere Argumente, von denen einige sind:

• args: Der auszuführende Befehl und seine Argumente, die als Liste von Strings übergeben werden.
• capture_output: Wenn diese Option auf True gesetzt ist, werden die Standardausgabe und der Standardfehler erfasst.
• text: Wenn diese Option auf True gesetzt ist, werden stdout und stderr als String zurückgegeben, ansonsten als Bytes.
• check Ein boolescher Wert, der angibt, ob der Rückgabewert des Subprozesses geprüft werden soll. Wenn check true ist und der Rückgabewert ungleich Null ist, wird der Subprozess `CalledProcessError` ausgelöst.
• timeout: Ein Wert in Sekunden, der angibt, wie lange auf die Beendigung des Unterprozesses gewartet werden soll, bevor die Zeit abgelaufen ist.
• shell: Ein boolescher Wert, der angibt, ob der Befehl in einer Shell ausgeführt werden soll. Das bedeutet, dass der Befehl als Zeichenkette übergeben wird und shellspezifische Funktionen wie Platzhalterexpansion und Variablensubstitution verwendet werden können.

Die Methode subprocess.run() gibt außerdem ein CompletedProcess-Objekt zurück, das die folgenden Attribute enthält:

• args: Der Befehl und die Argumente, die ausgeführt wurden.
• returncode: Der Rückgabecode des Unterprozesses.
• stdout: Die Standardausgabe des Unterprozesses, als Byte-Objekt.
• stderr: Der Standardfehler des Unterprozesses, als Byte-Objekt.

Beispiel 1: Shell-Befehle ausführen:

import subprocess

result = subprocess.run(["dir"], shell=True, capture_output=True, text=True)

print(result.stdout)

Output: 

Volume in drive C has no label.

Volume Serial Number is E414-A41C

 Directory of C:\Users\owner

01/25/2023  10:56 AM    <DIR>          .

01/25/2023  10:56 AM    <DIR>          ..

07/19/2021  01:19 PM    <DIR>          .anaconda

07/19/2021  01:19 PM    <DIR>          .astropy

07/19/2021  01:19 PM    <DIR>          .aws

09/12/2022  08:48 AM               496 .bash_history

03/27/2022  03:08 PM    <DIR>          .cache

09/26/2021  06:58 AM    <DIR>          .conda

09/26/2021  06:59 AM                25 .condarc

…

Linux- oder Mac-Benutzer ersetzen "dir" durch "ls" und lassen das Argument "Shell" weg.

Beispiel 2: Python-Skripte ausführen:

Du kannst ein Python-Skript auch mit der Methode subprocess.run() ausführen. Beginnen wir mit der Erstellung eines einfachen Python-Skripts in der Datei .py

print(“This is the output from subprocess module”)

Speichere diese Datei unter `my_python_file.py`.

Jetzt kannst du das Unterprozessmodul verwenden, um diese Datei auszuführen:

import subprocess

result = subprocess.run(["python", "my_python_file.py"], capture_output=True, text=True)

print(result.stdout)

Output:

This is the output from subprocess module

Beispiel 3: Python-Code direkt aus einer Funktion heraus ausführen:

Für einfache Anwendungsfälle kannst du einen Python-Befehl direkt in der Funktion subprocess.run() übergeben. So geht's:

result = subprocess.run(["C:/Users/owner/anaconda3/python", "-c", "print('This is directly from a subprocess.run() function')"], capture_output = True, text = True)

print(result.stdout)

Output:

This is directly from a subprocess.run() function

In der Liste args ist das erste Element `C:/Users/owner/anaconda3/python` ein Pfad zum ausführbaren Python (dein Pfad kann anders sein). Das zweite Element, `-c`, ist ein Python-Tag, das es dem Benutzer ermöglicht, Python-Code als Text in die Kommandozeile zu schreiben. Das dritte Element, "print(...)", ist der Python-Befehl selbst.

Beispiel 4: Mit dem Argument prüfen

Das Argument check ist ein optionales Argument der Funktion subprocess.run() im Python-Subprocess-Modul. Es ist ein boolescher Wert, der bestimmt, ob die Funktion den Rückgabewert des ausgeführten Befehls überprüfen soll.

Wenn check auf True gesetzt ist, überprüft die Funktion den Rückgabewert des Befehls und löst eine CalledProcessError-Ausnahme aus, wenn der Rückgabewert ungleich Null ist. Die Ausnahme hat den Rückgabewert, stdout, stderr und command als Attribute.

Wenn check auf False (Standard) gesetzt ist, prüft die Funktion den Rückgabewert nicht und löst keine Ausnahme aus, selbst wenn der Befehl fehlschlägt.

import subprocess

result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

print(result.stdout)

print(result.stderr)

Output:

---------------------------------------------------------------------------

CalledProcessError                        Traceback (most recent call last)

<ipython-input-81-503b60184db8> in <module>

      1 import subprocess

----> 2 result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

      3 print(result.stdout)

      4 print(result.stderr)

~\anaconda3\lib\subprocess.py in run(input, capture_output, timeout, check, *popenargs, **kwargs)

    514         retcode = process.poll()

    515         if check and retcode:

--> 516             raise CalledProcessError(retcode, process.args,

    517                                      output=stdout, stderr=stderr)

    518     return CompletedProcess(process.args, retcode, stdout, stderr)

CalledProcessError: Command '['python', 'file_donot_exist.py']' returned non-zero exit status 2.

Beachte, dass der Befehl fehlgeschlagen ist, weil `file_donot_exist.py` nicht existiert. Im Gegensatz zu `check=True` schlägt dein Prozess nicht fehl; stattdessen erhältst du die Fehlermeldung in `stdout`. 

import subprocess

result = subprocess.run(["python", "my_python_file2.py"], capture_output=True, text=True, check=False)

print(result.stdout)

print(result.stderr)

Output:

python: can't open file 'my_python_file2.py': [Errno 2] No such file or directory

python subprocess Popen

subprocess.Popen" ist eine untergeordnete Schnittstelle zum Ausführen von Subprozessen, während "subprocess.run" ein übergeordneter Wrapper um Popen ist, der bequemer zu benutzen ist.

Mit Popen kannst du einen neuen Prozess starten und mit seinen Standard-Eingabe-, Ausgabe- und Fehlerströmen interagieren. Er gibt ein Handle zu dem laufenden Prozess zurück, mit dem du auf die Beendigung des Prozesses warten, seinen Rückgabewert überprüfen oder ihn beenden kannst.

run ist eine bequemere Funktion, mit der du einen Befehl ausführen und seine Ausgabe in einem einzigen Aufruf aufzeichnen kannst, ohne ein Popen-Objekt erstellen und die Streams selbst verwalten zu müssen. Außerdem kannst du verschiedene Optionen für die Ausführung des Befehls angeben, z. B. ob eine Ausnahme ausgelöst werden soll, wenn der Befehl fehlschlägt.

Im Allgemeinen solltest du run verwenden, wenn du nur einen Befehl ausführen und seine Ausgabe aufzeichnen willst, und Popen, wenn du mehr Kontrolle über den Prozess brauchst, z.B. um mit seinen Ein- und Ausgabeströmen zu interagieren.

Die Klasse Popen nimmt die gleichen Argumente wie run() entgegen, einschließlich der args, die den auszuführenden Befehl angeben, und anderer optionaler Argumente wie stdin, stdout, stderr, shell, cwd und env.

Die Klasse Popen hat mehrere Methoden, mit denen du mit dem Prozess interagieren kannst, z. B. communicate(), poll(), wait(), terminate() und kill().

import subprocess

p = subprocess.Popen(["python", "--help"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

output, errors = p.communicate()

print(output)

Output:

usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...

Options and arguments (and corresponding environment variables):

-b     : issue warnings about str(bytes_instance), str(bytearray_instance)

         and comparing bytes/bytearray with str. (-bb: issue errors)

-B     : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x

-c cmd : program passed in as string (terminates option list)

-d     : debug output from parser; also PYTHONDEBUG=x

-E     : ignore PYTHON* environment variables (such as PYTHONPATH)

…

Dadurch wird der Befehl `python -help` ausgeführt und ein neues Popen-Objekt erstellt, das in der Variablen p gespeichert wird. Die Standardausgabe und der Fehler des Befehls werden mit der Methode communicate() erfasst und in den Variablen output bzw. errors gespeichert.

`subprocess.Popen` ist nützlich, wenn du mehr Kontrolle über den Prozess haben willst, z.B. um Eingaben an ihn zu senden, Ausgaben von ihm zu empfangen oder auf seine Beendigung zu warten.

python subprocess call

subprocess.call()` ist eine Funktion im Python-Subprozessmodul, mit der ein Befehl in einem separaten Prozess ausgeführt und auf seine Fertigstellung gewartet wird. Sie gibt den Rückgabewert des Befehls zurück, der null ist, wenn der Befehl erfolgreich war, und ungleich null, wenn er fehlgeschlagen ist.

Die Funktion call() nimmt die gleichen Argumente wie run() entgegen, einschließlich der args, die den auszuführenden Befehl angeben, sowie weitere optionale Argumente wie stdin, stdout, stderr, shell, cwd und env.

Die Standardausgabe und der Fehler des Befehls werden an denselben stdout und stderr wie der Elternprozess gesendet, es sei denn, du leitest sie mit den Argumenten stdout und stderr um.

import subprocess

return_code = subprocess.call(["python", "--version"])

if return_code == 0:

    print("Command executed successfully.")

else:

    print("Command failed with return code", return_code)

Output:

Command executed successfully.

Dadurch wird der Befehl `python -version` in einem separaten Prozess ausgeführt und gewartet, bis er abgeschlossen ist. Der Rückgabewert des Befehls wird in der Variablen return_code gespeichert. Er ist Null, wenn der Befehl erfolgreich war, und ungleich Null, wenn er fehlgeschlagen ist.

subprocess.call() ist nützlich, wenn du einen Befehl ausführen und den Rückgabewert überprüfen willst, aber die Ausgabe nicht aufzeichnen musst.

python subprocess check_output

check_output ist eine Funktion im Subprozessmodul, die ähnlich wie run() funktioniert, aber nur die Standardausgabe des Befehls zurückgibt und eine CalledProcessError-Ausnahme auslöst, wenn der Rückgabewert ungleich Null ist.

Die Funktion check_output hat die gleichen Argumente wie run(), einschließlich der args, die den auszuführenden Befehl angeben, und anderer optionaler Argumente, wie stdin, stderr, shell, cwd und env.

Die Funktion check_output gibt die Standardausgabe des Befehls als Byte-Objekt oder String zurück, wenn text=True übergeben wird.

import subprocess

try:

    output = subprocess.check_output(["python", "--version"], text=True)

    print(output)

except subprocess.CalledProcessError as e:

    print(f"Command failed with return code {e.returncode}")

Output:

Python 3.8.8

Python Subprocess Pipe

Das Python-Subprozessmodul bietet eine Möglichkeit, Kindprozesse zu erstellen und mit ihnen zu interagieren, um andere Programme oder Befehle auszuführen. Eine der Funktionen des Subprozessmoduls ist die Möglichkeit, Pipes zu erstellen, die die Kommunikation zwischen dem Eltern- und dem Kindprozess ermöglichen.

Eine Pipe ist ein unidirektionaler Kommunikationskanal, der die Standardausgabe eines Prozesses mit der Standardeingabe eines anderen Prozesses verbindet. Eine Pipe kann die Ausgabe eines Befehls mit der Eingabe eines anderen Befehls verbinden, so dass die Ausgabe des ersten Befehls als Eingabe für den zweiten Befehl verwendet werden kann.

Pipes können mit dem Modul subprocess mit der Klasse Popen erstellt werden, indem das Argument stdout oder stdin als subprocess.PIPE angegeben wird.

Der folgende Code erstellt zum Beispiel eine Pipe, die die Ausgabe des ls-Befehls mit der Eingabe des grep-Befehls verbindet, der die Ausgabe so filtert, dass nur die Zeilen angezeigt werden, die das Wort "file" enthalten:

import subprocess

ls_process = subprocess.Popen(["ls"], stdout=subprocess.PIPE, text=True)

grep_process = subprocess.Popen(["grep", "sample"], stdin=ls_process.stdout, stdout=subprocess.PIPE, text=True)

output, error = grep_process.communicate()

print(output)

print(error)

Output:

sample_data

In diesem Beispiel wird die Klasse Popen verwendet, um zwei Kindprozesse zu erstellen, einen für den Befehl ls und einen für den Befehl grep. Der stdout des ls-Befehls wird mit dem stdin des grep-Befehls über subprocess.PIPE verbunden, wodurch eine Pipe zwischen den beiden Prozessen entsteht. Die Methode communicate() wird verwendet, um die Ausgabe des ls-Befehls an den grep-Befehl zu senden und die gefilterte Ausgabe abzurufen.

Fazit

Das Python-Modul `subprocess` bietet eine leistungsstarke und flexible Möglichkeit, Kindprozesse zu erstellen und mit ihnen zu interagieren. So kannst du andere Programme ausführen oder Befehle aus deinem Python-Skript heraus erteilen. Von einfachen Befehlen wie subprocess.call() bis hin zu fortgeschrittenen Funktionen wie Pipes, dem Umleiten von Ein- und Ausgaben und der Übergabe von Umgebungsvariablen hat das Modul subprocess für fast jeden Anwendungsfall etwas zu bieten. Es ist eine großartige Möglichkeit, sich wiederholende Aufgaben zu automatisieren, Systembefehle auszuführen und sogar mit anderen Programmiersprachen und Plattformen zu interagieren.

Bei der Arbeit mit dem Subprozessmodul ist es wichtig, daran zu denken, dass das Ausführen von externen Befehlen ein Sicherheitsrisiko darstellt, vor allem wenn du den Parameter shell=True verwendest oder unsanitized input übergibst. Es ist immer eine gute Praxis, die Funktion subprocess.run() zu verwenden, mit der du verschiedene Optionen für die Ausführung des Befehls festlegen kannst, z. B. ob eine Ausnahme ausgelöst werden soll, wenn der Befehl fehlschlägt. 

Wenn du tief in die unendlichen Möglichkeiten der Kommandozeilen-Automatisierung mit Python eintauchen möchtest, schau dir unseren Kurs Command Line Automation in Python an. In diesem Kurs lernst du, einen Automatisierungscode zu schreiben, der ein Dateisystem durchsucht, nach Dateien sucht, die einem Muster folgen, und dann feststellt, ob es sich in einem der zahlreichen Fälle um Duplikate handelt. Nach Abschluss des Kurses bist du in der Lage, Unix-Prozesse zu verwalten und mit ihnen zu interagieren sowie eine Vielzahl von Routineaktivitäten im Dateisystem zu automatisieren. 

Verbessere die Python-Kenntnisse deines Teams mit DataCamp for Business

Wenn du oder dein Team deine Kenntnisse in Python und Kommandozeilen-Automatisierung verbessern möchtest, solltest du das DataCamp for Business in Betracht ziehen. DataCamp bietet maßgeschneiderte Lernlösungen für Teams jeder Größe und hilft Unternehmen, in der sich schnell entwickelnden Tech-Landschaft die Nase vorn zu haben. Mit dem DataCamp for Business kannst du dein Team mit Kursen und individuellen Lerneinheiten weiterbilden, die darauf ausgerichtet sind, Fachwissen in Python, Automatisierung und anderen wichtigen Data Science-Tools aufzubauen. Egal, ob du ein Startup oder ein Unternehmen bist, DataCamp for Business bietet die Ressourcen und die Flexibilität, um die Lernziele deines Teams zu erreichen. Fordere noch heute eine Demo an, um mehr zu erfahren.