Du liest:
Python argparse: So erstellst du CLI Kommandos

Python argparse: So erstellst du CLI Kommandos

von Pero
21.12.2020

Die Kommandozeile in Python

Die Kommandozeile, die meistens auch als CLI (Command Line Interface) bezeichnet wird, wird verwendet, um Kommandos in Textform an ein Programm senden zu können. Wahrscheinlich haben wir diese alle bereits mindestens einmal genutzt. Grundsätzlich ist es keine große Sache, da sich die Anwendung wirklich ausgesprochen einfach gestaltet.
In Python existieren zahlreiche Bibliotheken, die wir nutzen können, um unsere eigenen Kommandozeilen zu erzeugen. Allerdings wird in Python in den meisten Fällen die Python argparse Bibliothek verwendet, um Kommandos zu erzeugen. In diesem Artikel werden wir deshalb die argparse-Bibliothek besprechen und wie wir diese richtig zu nutzen haben.

Die Python argparse Bibiliothek

Wie bereits angesprochen ist argparse die Standardbibliothek für das Erstellen von Kommandos. Bevor wir allerdings zur Bibliothek kommen, schauen wir uns zunächst ein paar Beispiele in der Verwendung der IDLE und der Kommandozeile an.

Starten wir dafür mit einem kleinen Beispiel:

def display(nachricht):
	print("Nachricht:", nachricht)	
display("Hallo Welt!")

In dem oben stehenden Code finden wir dir Funktion display(), die ein Argument akzeptiert. Dieses wird ganz einfach mit der print()-Funktion ausgegeben. Führen wir den Code über die IDLE, also Konsole aus:

Display-Methode in Kombination mit einer print-Funktion.

Es wird ein Argument, also unser Text, an die Funktion übergeben. Die Funktion erledigt dann die Ausgabe. Wir können den Code aber auch über die Kommandozeile ausführen.

Ausgabe des vorherigen Codes: "Hallo Welt!"

Auch aus der Kommandozeile ist es einfach ein Programm auszuführen. Dabei müssen wir lediglich in den Ordner der Datei gehen und diesen ausführen. Ändern wir jetzt etwas an unserem Quellcode.

def display(nachricht):
    print("Nachricht:", nachricht)


nachricht = input("Geben Sie eine Nachricht ein\n")
display(nachricht)

Im anderen Beispiel haben wir einen statischen Text über die Funktion ausgeben wollen. Jetzt wollen wir eine Eingabe des Benutzers ausgeben. Führen wir dafür den Code zunächst in der IDLE aus.

CLI-Eingabeaufforderung mit Hilfe der display- und input-Methode.

Bis jetzt stellt das ganze kein Problem dar. Versuchen wir jetzt den Code erneut aus der Kommandozeile auszuführen.

Ausgabe mit Hallo Welt!

Dies funktioniert, da wir die input()-Funktion verwendet haben. Wir können allerdings auch einen anderen Weg nutzen, um das Argument direkt an die Funktion zu übergeben, ohne die input()-Funktion nutzen zu müssen. Dafür nutzen wir die argparse-Bibliothek.

Erzeugen wir jetzt die gleiche Funktionalität, indem wir argparse benutzen. Dafür gehen wir Schritt für Schritt vor.

import argparse
import sys

Zunächst müssen wir zwei Module importieren – das argparse- und sys-Modul. Das argparse-Modul bietet uns die benötigten Funktionen. Als nächstes definieren wir eine Funktion, in der wir den Code des Moduls nutzen.

import argparse
import sys


def demo():
    parser = argparse.ArgumentParser()

In der demo()-Funktion erstellen wir einen Parser mit dem Namen „parser“. Dafür nutzen wir die ArgumentParser()-Funktion aus dem argparse-Modul. Dabei müssen wir uns allerdings merken, dass wir bei Nutzung von „argparse“ in Python immer einen Parser mit der ArgumentParser()-Funktion erstellen müssen.

Anschließend gilt es nur noch Argumente des Parsers hinzufügen.

import argparse
import sys


def demo():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--nachricht",
        type=str,
        default="Keine Nachricht",
        help="Schreib eine Nachricht...",
    )

Wir nutzen die add_argument()-Funktion für den Parser. Diese Zeile verwenden wir, um Argumente hinzuzufügen.

parser.add_argument('--nachricht, type=str, default="Keine Nachricht", help='Was ist die erste Nummer?')

Die add_argument()-Funktion erfordert vier Argumente.

  1. ‚–nachricht‘ – Dies ist der Name des Arguments, das wir in der Kommandozeile zur Eingabe nutzen. Wir können den Befehl dabei nennen wie wir wollen.
  2. type – Dies beschreibt den Datentyp der Eingabe. Da wir in unserem Fall einen String benötigen, definieren wir „str“.
  3. default – Wenn kein Argument von uns eingegeben wird, wird dieses als Standardwert angenommen.
  4. help – Dieses Argument ist als Hilfestellung gedacht.

Jetzt haben wir die Argumente des Parsers, den wir im vorigen Schritt erzeugt haben, definiert. Allerdings müssen wir die Argumente auch aus der Kommandozeile in den Parser überführen.

import argparse
import sys


def demo():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--nachricht",
        type=str,
        default="Keine Nachricht",
        help="Schreib eine Nachricht...",
    )
    arguments = parser.parse_args()

Um die Argumente aus der Kommandozeile bekommen zu können, nutzen wir unseren Parser „parser“, um über diesen die parse_args()-Funktion aufzurufen. Jetzt werden die eingegeben Argumente in der Variable “arguments“ gespeichert.

Nun können wir eine Funktion erstellen, in der wir unser Argument eingeben und dieses im Anschluss anzeigen lassen können.

import argparse
import sys


def demo():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--nachricht",
        type=str,
        default="Keine Nachricht",
        help="Schreib eine Nachricht...",
    )
    arguments = parser.parse_args()


def display(nachricht):
    print("Nachricht:", nachricht)

Jetzt haben wir die demo()-Funktion mit der wir Argumente aus der Kommandozeile extrahieren können. Außerdem haben wir die display()-Funktion, die ein Argument akzeptiert und dieses ausgibt. Das sys-Modul können wir wiederum nutzen, um Nachrichten in der Kommandozeile auszugeben.

Jetzt können wir die display()-Funktion in der demo()-Funktion aufrufen, um unsere Eingabe wieder auszugeben.

import argparse
import sys


def demo():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--nachricht",
        type=str,
        default="Keine Nachricht",
        help="Schreib eine Nachricht...",
    )
    arguments = parser.parse_args()
    display(arguments)


def display(arguments):
    sys.stdout.write(str(arguments.message))

Implementieren wir den Code jetzt so, dass die demo()-Funktion zuerst aufgerufen wird:

import argparse
import sys


def demo():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--nachricht",
        type=str,
        default="Keine Nachricht",
        help="Schreib eine Nachricht...",
    )
    arguments = parser.parse_args()
    display(arguments)


def display(arguments):
    sys.stdout.write(str(arguments.nachricht))


if __name__ == "__main__":
    demo()

Jetzt haben wir unseren finalen Code. Bevor wir diesen allerdings ausführen, besprechen wir doch kurz die wichtigsten Schritte:

  1. Um die argparse-Bibliothek zu nutzen, haben wir diese zunächst importiert.
  2. In der demo()-Funktion haben wir mittels der ArgumentParser()-Funktion aus dem argparse-Modul einen Parser erstellt.
  3. Den Parser haben wir anschließend genutzt, um Argumente mittels der add_argument()-Funktion hinzuzufügen.
  4. Die add_argument()-Funktion erfordert vier Argumente – Name des Arguments, Datentyp des Arguments, Standardwert, Hilfsnachricht.
  5. Nach dem Erstellen des Arguments haben wir die parse_args()-Funktion benutzt, um die Argumente aus der Kommandozeile zu extrahieren. Diese haben wir dann in der Variable „arguments“ gespeichert und schließlich als Argument an die display()-Funktion übergeben.

Führen wir den Code jetzt über die Kommandozeile aus.

Die Ausgabe unserer Python argparse-Funktion.

Wie wir sehen funktioniert unser Code.

Das Kommando, das wir eigegeben haben, lautet wie folgt: python demo.py –nachricht=“Hallo Welt!“

„demo.py“ ist der Name unserer Datei. „–nachricht“ ist das Argument, welches wir mittels der add_argument()-Funktion hinzugefügt haben. Wir können auch ein anderes Kommando aufrufen.

Eine weitere Ausgabe der Python argparse-Funktion.

Erinnern wir uns daran, dass ein Argument eine Hilfsnachricht darstellen sollte. Wenn wir die Ausgabe genau betrachten, können wir die Hilfsnachricht wiederfinden.

Schauen wir uns ein weiteres Beispiel an. Diesmal definieren wir gleich mehrere Argumente.

import argparse
import sys


def demo():
	parser = argparse.ArgumentParser()
	parser.add_argument('--value1', type = int, default = 0, help = 'Type the first value..')
	parser.add_argument('--value2', type = int, default = 0, help = 'Type the second value..')
	parser.add_argument('--operation', type = str, default = "add", help = 'Type the operation..')
	arguments = parser.parse_args()
	sys.stdout.write(str(calculator(arguments)))
	
	
def calculator(arguments):
	if arguments.operation == "add":
		return arguments.value1 + arguments.value2
	if arguments.operation == "sub":
		return arguments.value1 - arguments.value2
	if arguments.operation == "mul":
		return arguments.value1 * arguments.value2
	if arguments.operation == "div":
		return arguments.value1 / arguments.value2
	
if __name__ == '__main__':
	demo()

Der obige Code stellt einen Rechner dar. Die calculator()-Funktion übernimmt die vier Rechenoptionen – Addition, Subtraktion, Multiplikation, Division. Betrachten wir noch einmal die demo()-Funktion.

def demo():
    parser = argparse.ArgumentParser()
    parser.add_argument("--value1", type=int, default=0, help="Type the first value..")
    parser.add_argument("--value2", type=int, default=0, help="Type the second value..")
    parser.add_argument(
        "--operation", type=str, default="add", help="Type the operation.."
    )
    arguments = parser.parse_args()
    sys.stdout.write(str(calculator(arguments)))

In diesem Fall haben wir drei Argumente – value1, value2, operation. Während value1 und value2 integer, also Zahlenwerte, sind, wird die operation, also der Rechenoperator, als String angegeben. Jetzt können wir den Code über die Kommandozeile ausführen und das Ergebnis betrachten.

CLI-Kommandos mit mehreren Python argparse Anwendungen.

Zusammenfassung

Die argparse-Bibliothek nutzen wir für die Eingabe von Kommandos in der Kommandozeile. Wie wir bereits am Anfang des Artikels gesehen haben, können wir auch die input()-Funktion nutzen, um Eingaben über die Kommandozeile zu tätigen. Allerdings bietet die Python argparse()-Funktion einen deutlich besseren Funktionsumfang. Dabei ist jedoch die Voraussetzung, dass wir die Verwendung der ArgumentParser()-, add_argument()- und parse_args()-Funktion aus der Bibliothek verstehen. Zunächst sehen Teile des Codes sehr schwierig aus. Dies wird sich bei Nutzung jedoch schnell verflüchtigen. Deshalb haben wir zunächst mit einem einfachen Beispiel begonnen und uns hinterher einem komplexeren gewidmet.



Bislang gibt es keine Kommentare. Markier dein Revier und sei der Erste!

Schreibe einen Kommentar

Das könnte dich auch interessieren