30    Kommandozeilenparameter 

Im Abschnitt über das Modul sys der Standardbibliothek haben wir die globale Liste sys.argv besprochen, mithilfe derer Sie auf die Kommandozeilenparameter zugreifen können, die beim Aufruf eines Programms übergeben wurden. Dieser rudimentäre Zugang zu den Kommandozeilenparametern ist jedoch oft nicht ausreichend. Das Modul argparse, das in diesem Abschnitt besprochen wird, erlaubt Ihnen einen komfortableren Umgang mit Kommandozeilenparametern.

Bislang wurden in diesem Buch ausschließlich Konsolenprogramme behandelt, also Programme, die eine rein textbasierte Schnittstelle zum Benutzer haben. Solche Programme werden üblicherweise aus einer Konsole, auch Shell genannt, gestartet. Eine Konsole ist beispielsweise die Eingabeaufforderung unter Windows.[ 125 ](In neueren Windows-Versionen ersetzt die PowerShell die Eingabeaufforderung.)

Unter Windows wird ein Python-Programm aus der Eingabeaufforderung heraus gestartet, indem in das Programmverzeichnis gewechselt und dann der Name der Programmdatei eingegeben wird. Hinter dem Namen können Optionen und Argumente übergeben werden:

• Ein Argument wird hinter den Namen der Programmdatei geschrieben. Um einen Vergleich zu Funktionsparametern zu ziehen, könnte man von Positional Arguments sprechen. Das bedeutet vor allem, dass die Argumente anhand ihrer Reihenfolge zugeordnet werden. Ein Programmaufruf mit drei Argumenten kann beispielsweise folgendermaßen aussehen:

  programm.py karl 1337 heinz

• Neben den Argumenten können Sie Optionen übergeben, die mit Keyword Arguments vergleichbar sind. Das bedeutet, dass jede Option einen Namen hat und über diesen angesprochen wird. Beim Programmaufruf müssen Optionen vor den Argumenten geschrieben und jeweils durch einen Bindestrich eingeleitet werden. Dann folgen der Optionsname, ein Leerzeichen und der gewünschte Wert. Ein Programmaufruf mit Optionen und Argumenten kann also folgendermaßen aussehen:

  programm.py -a karl -b heinz -c 1337 hallo welt

  In diesem Fall existieren drei Optionen namens a, b und c mit den Werten "karl", "heinz" und 1337. Zudem sind zwei Argumente angegeben: die Strings "hallo" und "welt".
  Neben diesen parameterbehafteten Optionen gibt es parameterlose Optionen, die mit einem Flag vergleichbar sind. Das bedeutet, dass sie entweder vorhanden (aktiviert) oder nicht vorhanden (deaktiviert) sind:
  programm.py -a -b 1 hallo welt
  In diesem Fall handelt es sich bei a um eine parameterlose Option.

Im weiteren Verlauf dieses Kapitels besprechen wir die Verwendung des Moduls argparse anhand zweier Beispiele.

 

30.1    Taschenrechner – ein einfaches Beispiel 

Das erste Beispiel ist ein einfaches Taschenrechnerprogramm, bei dem sowohl die Rechenoperation als auch die Operanden über Kommandozeilenparameter angegeben werden.

Das Programm soll folgendermaßen aufgerufen werden können:

calc.py -o plus 7 5
calc.py -o minus 13 29
calc.py -o mal 4 11
calc.py -o geteilt 3 2

Über die Option -o wird eine Rechenoperation festgelegt, die auf die beiden folgenden Argumente angewendet wird. Wenn die Option -o fehlt, sollen die Argumente addiert werden.

Zu Beginn des Programms muss die Klasse ArgumentParser des Moduls argparse eingebunden und instanziiert werden:

from argparse import ArgumentParser
parser = ArgumentParser()

Jetzt können durch die Methode add_argument der ArgumentParser-Instanz erlaubte Optionen hinzugefügt werden. In unserem Fall ist es nur eine:

parser.add_argument("-o", "--operation", dest="operation", default="plus")

Der erste Parameter der Methode gibt den Kurznamen der Option an. Jede Option ist auch mit einer ausgeschriebenen Version des Namens verwendbar, sofern diese Alternative durch Angabe des zweiten Parameters gegeben ist. In diesem Fall sind die Optionen -o und --operation gleichbedeutend. Der dritte Parameter, wohlgemerkt ein Keyword-Argument, gibt an, unter welchem Namen der Wert der Option später im Programm verfügbar gemacht werden soll. Über den letzten Parameter wird ein Standardwert für diese Option festgelegt, der verwendet wird, wenn die Option nicht angegeben ist.

Neben der Option -o müssen noch die Argumente für die beiden Operanden hinzugefügt werden. Dabei werden der Name und der zulässige Datentyp der Argumente angegeben.

parser.add_argument("op1", type=float)
parser.add_argument("op2", type=float)

Nachdem alle Optionen und Argumente hinzugefügt worden sind, wird die Methode parse_args aufgerufen, die die Kommandozeilenparameter ausliest und in der gewünschten Form aufbereitet.

args = parser.parse_args()

Als Nächstes legen wir ein Dictionary an, das alle möglichen Rechenoperationen als Schlüssel und die dazugehörige Berechnungsfunktion als jeweiligen Wert enthält. Die Schlüssel sind dieselben, die über die Option -o angegeben werden können, sodass wir anhand des bei der Option übergebenen Strings direkt auf die zu verwendende Berechnungsfunktion schließen können:

calc = {
       "plus" : lambda a, b: a + b, 
       "minus" : lambda a, b: a - b, 
       "mal" : lambda a, b: a * b, 
       "geteilt" : lambda a, b: a / b
       }

Prinzipiell muss jetzt nur noch der Wert ausgelesen werden, der mit der Option -o übergeben wurde. Der Zugriff auf eine Option ist anhand der von parse_args zurückgegebenen Instanz args einfach, da jede Option unter ihrem gewählten Namen als Attribut dieser Instanz verfügbar ist. Der von uns gewählte Name für die Option -o war operation. Analog kann auf Argumente zugegriffen werden.

op = args.operation
if op in calc: 
    print("Ergebnis:", calc[op](args.op1, args.op2))
else: 
    parser.error("{} ist keine Operation".format(op))

Für Fehler, die aufgrund falscher oder fehlender Kommandozeilenparameter auftreten, eignet sich die Methode error der ArgumentParser-Instanz, die eine entsprechende Fehlermeldung ausgibt und das Programm beendet.

Bevor wir zu einem komplexeren Beispielprogramm übergehen, besprechen wir den Konstruktor der Klasse ArgumentParser sowie deren Methode add_argument im Detail.

ArgumentParser([description, epilog, prog, usage, add_help, argument_default])

Dem Konstruktor der Klasse ArgumentParser kann eine Reihe von Schlüsselwortparametern übergeben werden, von denen die wichtigsten hier kurz erläutert werden. Viele der Parameter beziehen sich auf die dynamisch generierte Hilfeseite, die das Modul argparse zur Verfügung stellt. Ein Beispiel zur Verwendung dieser Hilfeseite finden Sie im nächsten Abschnitt.

Tabelle 30.1    Schlüsselwortparameter des Konstruktors ArgumentParser

add_argument([*name_or_flags, action, nargs, const, default, type, choices, required, help, metavar, dest, version])

Die Methode add_argument fügt ein Argument bzw. eine Option zur Programmschnittstelle hinzu. Dabei kann eine Reihe von Parametern angegeben werden, von denen die wichtigsten hier besprochen werden.

Tabelle 30.2    Parameter der Methode add_argument