17.5 Kommandozeilenparameter – optparse 

Im vorletzten Abschnitt wurde gesagt, dass man über sys.argv auf die Kommandozeilenparameter zugreifen kann, die beim Aufruf des Programms übergeben wurden. Das ist richtig und funktioniert. Das Modul optparse erlaubt Ihnen jedoch einen wesentlich komfortableren Umgang mit Kommandozeilenparametern.

Doch zunächst möchten wir uns allgemein mit der Thematik der Kommandozeilenparameter befassen. Bislang wurden hier ausschließlich Konsolenprogramme behandelt, das heißt 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.

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 jetzt zum einen sogenannte Optionen und zum anderen sogenannte Argumente übergeben werden:

• Ein Argument wird einfach 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 könnte beispielsweise folgendermaßen aussehen:

programm.py karl 1337 heinz

• Neben den Argumenten können Optionen übergeben werden. Optionen sind, wie der Name sagt, optional und deshalb keyword arguments. 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 könnte 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 wurden 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 soll die Verwendung des Moduls optparse anhand zweier Beispiele besprochen werden.

17.5.1 Taschenrechner – ein einfaches Beispiel 

Das erste Beispiel soll ein einfacher Taschenrechner sein, 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

Das bedeutet, dass über die Option -o eine Rechenoperation festgelegt werden kann, die auf die beiden folgenden Argumente angewendet wird. Wenn die Option nicht angegeben wurde, sollen die Argumente addiert werden.

Zu Beginn des Programms muss die Klasse OptionParser des Moduls optparse eingebunden und instanziiert werden:

from optparse import OptionParser 
parser = OptionParser()

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

parser.add_option("-o", "--operation", dest="operation")

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 wären die Optionen -o und --operation gleichbedeutend. Der letzte Parameter, ein keyword argument wohlgemerkt, gibt an, unter welchem Namen der Wert der Option später im Programm verfügbar gemacht werden soll.

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

(optionen, args) = parser.parse_args()

Die Methode gibt ein Tupel mit zwei Werten zurück: zum einen eine Instanz, die alle übergebenen Optionen enthält (optionen), und zum anderen eine Liste mit allen weiteren Argumenten (args).

Um korrekt arbeiten zu können, müssen dem Taschenrechner-Programm exakt zwei Argumente übergeben worden sein, was wir an dieser Stelle im Quelltext überprüfen. Wenn die Anzahl der Argumente ungleich zwei ist, kann keine Berechnung durchgeführt werden und das Programm beendet sich:

if len(args) != 2: 
    parser.error("Es werden exakt zwei Argumente erwartet")

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

Als Nächstes legen wir ein Dictionary an, das alle möglichen Rechenoperationen als Schlüssel und die dazugehörigen Berechnungsfunktionen als jeweiligen Wert enthalten. 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, 
       None : lambda a, b: a + b 
       }

Prinzipiell braucht 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 optionen relativ 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.

op = optionen.operation 
if op in calc: 
    print "Ergebnis:", calc[op](float(args[0]), float(args[1])) 
else: 
    parser.error("%s ist keine Operation" % op)

Beachten Sie, dass im Falle einer nicht angegebenen Option das entsprechende Attribut nicht etwa nicht vorhanden ist, sondern lediglich None referenziert. Da None im Dictionary calc als Schlüssel geführt wird und auf die Berechnungsfunktion der Addition verweist, werden die beiden Argumente in einem solchen Fall schlicht zusammengezählt.

17.5.2 Weitere Verwendungsmöglichkeiten 

In diesem Abschnitt soll das Beispielprogramm des letzten Abschnitts dahingehend erweitert werden, dass weitere Verwendungsmöglichkeiten des Moduls optparse hervorgehoben werden. Hier sehen Sie zunächst den Quellcode des veränderten Beispielprogramms:

from optparse import OptionParser

parser = OptionParser("calc2.py [Optionen] Operand1 Operand2") 
parser.add_option("-o", "--operation", dest="operation", 
                  help="Rechenoperation") 
parser.add_option("-v", "--verbose", action="store_true", 
                  dest="verbose", default=False, 
                  help="Schwafelmodus")

(optionen, args) = parser.parse_args() 
if len(args) != 2: 
    parser.error("Es werden exakt zwei Argumente erwartet")

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, 
       None : lambda a, b: a + b 
       }

if optionen.verbose: 
    print "Das Ergebnis wird berechnet" 
op = optionen.operation 
if op in calc: 
    print "Ergebnis:", calc[op](float(args[0]), float(args[1])) 
else: 
    parser.error("%s ist keine Operation" % op)

Zunächst einmal werden Sie feststellen, dass bei der Instanziierung von Option Parser ein String übergeben wurde. Zusätzlich haben auch die Aufrufe der Methode add_option ein weiteres keyword argument namens help spendiert bekommen. Diese Angaben sind zwar nicht notwendig, sollten jedoch getätigt werden, da die OptionParser-Instanz aus den dort übergebenen Strings automatisch eine Hilfeseite generiert, wenn das Programm mit den Optionen -h oder --help gestartet wird. In dieser Hilfeseite wird die Verwendung des Programms kurz umrissen. Dazu gehört eine Auflistung aller möglichen Optionen, jeweils mit einem kurzen erläuternden Satz. Für das obige Beispiel sieht der Hilfetext folgendermaßen aus:

Usage: calc2.py [Optionen] Operand1 Operand2 
 
Options: 
  -h, --help            show this help message and exit 
  -o OPERATION, --operation=OPERATION 
                        Rechenoperation 
  -v, --verbose         Schwafelmodus

Zusätzlich zu der bereits im ursprünglichen Beispielprogramm vorhandenen Option -o wurde eine weitere Option namens -v bzw. --verbose angelegt. Viele bekannte Programme verwenden die Option -v als Schalter, um das Programm in eine Art geschwätzigen Zustand zu versetzen. Das bedeutet, dass auch nicht essenzielle Statusmeldungen auf dem Bildschirm ausgegeben werden. Diese Funktionalität soll auch unser Beispielprogramm bekommen. Der geschwätzige Modus soll aktiviert werden, wenn -v oder --verbose angegeben wurden, und sonst deaktiviert bleiben. Programmintern sollte die Option daher als boolescher Wert ankommen.

Dazu werden der Methode add_option zwei weitere keyword arguments übergeben. Zum einen wird der Parameter action auf "store_true" gesetzt, was bedeutet, dass das dazugehörige Attribut verbose auf True gesetzt wird, wenn die Option -v vorhanden ist. Analog dazu wäre auch "store_false" für den umgekehrten Fall möglich gewesen.

Der zweite neue Parameter ist die Angabe eines Default-Wertes. Das ist der Wert, den das dazugehörige Attribut vebose annimmt, wenn die Option -v nicht vorhanden ist.

Der resultierende boolesche Wert optionen.verbose wird im Programm abgefragt, und dann wird eventuell eine zugegebenermaßen sinnlose Statusmeldung ausgegeben. Die Ausgabe des Programms sieht bei Angabe der Option -v folgendermaßen aus:

Das Ergebnis wird berechnet 
Ergebnis: 19.0

Damit wäre der grundlegende Funktionsumfang von optparse erläutert.

Ihr Kommentar