Wie Sie externe Programme direkt aus Ihrem Skript in Python starten können – eine Anleitung

Python ist eine unglaublich vielseitige Sprache, die sich hervorragend für eine Vielzahl von Aufgaben eignet. Eines der mächtigsten Features ist die Möglichkeit, externe Programme direkt aus Ihren Skripten heraus zu starten. Dies eröffnet Ihnen eine Welt voller Möglichkeiten, von der Automatisierung von Systemverwaltungsaufgaben bis hin zur Integration mit anderen Anwendungen und Tools. In diesem Artikel werden wir die verschiedenen Methoden untersuchen, mit denen Sie externe Programme in Python starten können, und Ihnen praktische Beispiele geben, die Ihnen den Einstieg erleichtern.

Warum externe Programme aus Python starten?

Bevor wir uns mit den technischen Details befassen, werfen wir einen Blick darauf, warum Sie überhaupt externe Programme aus Ihren Python-Skripten heraus starten möchten:

• Automatisierung: Automatisieren Sie sich wiederholende Aufgaben, wie das Konvertieren von Dateiformaten, das Ausführen von Batch-Prozessen oder das Erstellen von Backups.
• Integration: Integrieren Sie Python-Skripte nahtlos mit anderen Anwendungen und Tools, selbst wenn diese nicht in Python geschrieben sind.
• Systemverwaltung: Führen Sie Systemverwaltungsaufgaben aus, wie das Starten und Stoppen von Diensten, das Überwachen der Systemressourcen oder das Verwalten von Benutzerkonten.
• Erweiterung der Funktionalität: Nutzen Sie die Funktionalität von Befehlszeilenprogrammen, um Python-Skripte um Fähigkeiten zu erweitern, die in Python selbst nicht nativ vorhanden sind.

Die subprocess Bibliothek: Der Goldstandard

Die empfohlene Methode zum Starten externer Programme in Python ist die Verwendung der subprocess Bibliothek. Sie bietet eine leistungsstarke und flexible Schnittstelle zur Interaktion mit Kindprozessen. Die subprocess Bibliothek ist in der Python-Standardbibliothek enthalten, sodass Sie keine zusätzlichen Pakete installieren müssen.

Einfaches Ausführen eines Befehls

Die einfachste Möglichkeit, ein externes Programm mit subprocess auszuführen, ist die Verwendung der subprocess.run() Funktion:

import subprocess

# Führe den Befehl 'ls -l' aus (Linux/macOS) oder 'dir' (Windows)
befehl = ['ls', '-l']  # Linux/macOS
#befehl = ['dir'] # Windows

ergebnis = subprocess.run(befehl, capture_output=True, text=True)

# Gib die Ausgabe aus
print(ergebnis.stdout)

In diesem Beispiel führen wir den Befehl ls -l (oder dir unter Windows) aus. capture_output=True fängt die Standardausgabe und den Standardfehler des Programms ein. text=True decodiert die Ausgabe als Text (anstatt als Bytes). Das Ergebnis ist ein CompletedProcess Objekt, das Informationen über die Ausführung des Befehls enthält.

Überprüfen des Rückgabecodes

Es ist wichtig, den Rückgabecode des ausgeführten Programms zu überprüfen, um festzustellen, ob es erfolgreich war. Ein Rückgabecode von 0 deutet normalerweise auf Erfolg hin, während ein anderer Wert auf einen Fehler hindeutet. Sie können den Rückgabecode mit dem Attribut returncode des CompletedProcess Objekts abrufen:

import subprocess

befehl = ['ls', '-l']
ergebnis = subprocess.run(befehl, capture_output=True, text=True)

if ergebnis.returncode == 0:
    print("Befehl erfolgreich ausgeführt")
    print(ergebnis.stdout)
else:
    print("Fehler beim Ausführen des Befehls")
    print(ergebnis.stderr)

Interaktion mit der Standardeingabe, -ausgabe und -fehler

Die subprocess Bibliothek ermöglicht Ihnen die Interaktion mit der Standardeingabe (stdin), -ausgabe (stdout) und -fehler (stderr) des externen Programms. Dies ist besonders nützlich, wenn Sie Daten an das Programm senden oder die Ausgabe des Programms verarbeiten möchten.

import subprocess

# Sende Daten an das Programm 'wc' (word count) über stdin
eingabe_daten = "Hallo Welt!nDies ist ein Test."
ergebnis = subprocess.run(['wc', '-w'], capture_output=True, text=True, input=eingabe_daten)

print(ergebnis.stdout) # Gibt die Wortanzahl aus

In diesem Beispiel senden wir einen String an das Programm wc -w (Word Count) über die Standardeingabe. Das Programm zählt die Wörter im String und gibt das Ergebnis über die Standardausgabe zurück.

Asynchrone Ausführung

Für langlaufende Prozesse können Sie die asynchrone Ausführung mit subprocess.Popen() verwenden. Dies ermöglicht es Ihrem Python-Skript, weiterzuarbeiten, während das externe Programm im Hintergrund ausgeführt wird.

import subprocess
import time

# Starte einen langlaufenden Prozess im Hintergrund
prozess = subprocess.Popen(['sleep', '5'])  # Sleep für 5 Sekunden

# Mache andere Dinge, während der Prozess läuft
print("Prozess gestartet...")
time.sleep(2)
print("Mache andere Dinge...")

# Warte, bis der Prozess abgeschlossen ist
prozess.wait()
print("Prozess abgeschlossen")

Alternative Methoden (mit Vorsicht)

Obwohl die subprocess Bibliothek die empfohlene Methode ist, gibt es einige ältere Alternativen, die Sie möglicherweise in älterem Code finden:

• os.system(): Führt einen Befehl in einer Unter-Shell aus. Es ist jedoch weniger flexibel und sicherer als subprocess, da es anfälliger für Shell-Injection-Angriffe ist. Vermeiden Sie die Verwendung von os.system(), wenn möglich.
• os.popen(): Führt einen Befehl in einer Subshell aus und stellt ein Dateiobjekt zum Lesen oder Schreiben bereit. Auch hier ist subprocess vorzuziehen.

Sicherheitsüberlegungen

Beim Starten externer Programme ist es wichtig, Sicherheitsüberlegungen zu berücksichtigen. Vermeiden Sie die Ausführung von Befehlen, die von Benutzereingaben abhängig sind, ohne diese zu validieren und zu bereinigen. Dies kann zu Shell-Injection-Angriffen führen, bei denen bösartiger Code über die Benutzereingabe ausgeführt wird.

Verwenden Sie niemals shell=True in subprocess.run() oder subprocess.Popen(), es sei denn, Sie haben einen sehr guten Grund dafür. Wenn shell=True verwendet wird, wird der Befehl über eine Shell (wie Bash oder CMD.exe) ausgeführt, was ihn anfälliger für Shell-Injection-Angriffe macht. Wenn Sie Benutzereingaben in den Befehl einbeziehen müssen, verwenden Sie immer eine Liste von Argumenten anstelle eines einzelnen Strings und vermeiden Sie die Verwendung von shell=True.

Best Practices

Hier sind einige Best Practices für das Starten externer Programme in Python:

• Verwenden Sie die subprocess Bibliothek. Sie ist die empfohlene und sicherste Methode.
• Überprüfen Sie den Rückgabecode. Stellen Sie sicher, dass das Programm erfolgreich ausgeführt wurde.
• Verarbeiten Sie die Standardausgabe und den Standardfehler. Erfassen Sie die Ausgabe und den Fehler des Programms, um Fehler zu beheben oder die Ausgabe zu verarbeiten.
• Vermeiden Sie shell=True, wenn möglich. Verwenden Sie eine Liste von Argumenten, um Shell-Injection-Angriffe zu vermeiden.
• Validieren und bereinigen Sie Benutzereingaben. Stellen Sie sicher, dass Benutzereingaben sicher sind, bevor Sie sie in Befehle einfügen.

Fazit

Das Starten externer Programme aus Python-Skripten ist eine leistungsstarke Möglichkeit, die Funktionalität Ihrer Skripte zu erweitern und Aufgaben zu automatisieren. Durch die Verwendung der subprocess Bibliothek und die Berücksichtigung von Sicherheitsüberlegungen können Sie sicher und effizient mit anderen Programmen und Tools interagieren. Experimentieren Sie mit den verschiedenen Methoden, die wir in diesem Artikel behandelt haben, und entdecken Sie die unendlichen Möglichkeiten, die sich Ihnen bieten.