`getopt` — C-Style-Parser für Kommandozeilenoptionen¶

Hinweis

Dieses Modul gilt als funktionsvollständig. Eine deklarativere und erweiterbarere Alternative zu dieser API wird im Modul optparse bereitgestellt. Weitere funktionale Verbesserungen für die Verarbeitung von Kommandozeilenparametern werden entweder als Drittanbieter-Module auf PyPI oder als Funktionen im Modul argparse bereitgestellt.

Dieses Modul hilft Skripten, die Kommandozeilenargumente in sys.argv zu parsen. Es unterstützt die gleichen Konventionen wie die Unix-Funktion getopt() (einschließlich der Sonderbedeutungen von Argumenten der Form '-' und '--'). Lange Optionen, ähnlich denen, die von GNU-Software unterstützt werden, können ebenfalls über ein optionales drittes Argument verwendet werden.

Benutzer, die mit der Unix-Funktion getopt() nicht vertraut sind, sollten stattdessen das Modul argparse verwenden. Benutzer, die mit der Unix-Funktion getopt() vertraut sind, aber ein äquivalentes Verhalten bei weniger Code und besseren Hilfe- und Fehlermeldungen wünschen, sollten das Modul optparse verwenden. Weitere Einzelheiten finden Sie unter Auswahl einer Argumentanalysebibliothek.

Dieses Modul stellt zwei Funktionen und eine Ausnahme bereit

getopt.getopt(args, shortopts, longopts=[])¶

Analysiert eine Liste von Kommandozeilenoptionen und Parametern. args ist die zu analysierende Argumentliste, ohne den führenden Verweis auf das laufende Programm. Typischerweise ist dies sys.argv[1:]. shortopts ist die Zeichenkette der Optionsbuchstaben, die das Skript erkennen soll, wobei Optionen, die ein Argument benötigen, gefolgt von einem Doppelpunkt (':') und Optionen, die ein optionales Argument akzeptieren, gefolgt von zwei Doppelpunkten ('::') sind; d.h., im gleichen Format wie die Unix-Funktion getopt().

Hinweis

Im Gegensatz zu GNU getopt() werden nach einem Nicht-Options-Argument alle weiteren Argumente ebenfalls als Nicht-Options-Argumente betrachtet. Dies ähnelt der Funktionsweise von Nicht-GNU-Unix-Systemen.

longopts, falls angegeben, muss eine Liste von Zeichenketten mit den Namen der langen Optionen sein, die unterstützt werden sollen. Die führenden '--'-Zeichen sollten nicht in den Optionsnamen enthalten sein. Lange Optionen, die ein Argument benötigen, sollten von einem Gleichheitszeichen ('=') gefolgt werden. Lange Optionen, die ein optionales Argument akzeptieren, sollten von einem Gleichheitszeichen und einem Fragezeichen ('=?') gefolgt werden. Um nur lange Optionen zu akzeptieren, sollte shortopts eine leere Zeichenkette sein. Lange Optionen in der Kommandozeile können erkannt werden, solange sie ein Präfix des Optionsnamens bereitstellen, das genau einer der akzeptierten Optionen entspricht. Wenn longopts beispielsweise ['foo', 'frob'] ist, passt die Option --fo zu --foo, aber --f passt nicht eindeutig, sodass GetoptError ausgelöst wird.

Der Rückgabewert besteht aus zwei Elementen: Das erste ist eine Liste von (option, wert)-Paaren; das zweite ist die Liste der Programmargumente, die nach dem Entfernen der Optionsliste verbleiben (dies ist ein nachfolgender Slice von args). Jedes zurückgegebene Options- und Wert-Paar hat die Option als erstes Element, mit einem Bindestrich für kurze Optionen (z. B. '-x') oder zwei Bindestrichen für lange Optionen (z. B. '--long-option') davor und das Optionsargument als zweites Element oder eine leere Zeichenkette, wenn die Option kein Argument hat. Die Optionen erscheinen in der Liste in der Reihenfolge, in der sie gefunden wurden, was Mehrfachvorkommen erlaubt. Lange und kurze Optionen können gemischt werden.

Geändert in Version 3.14: Optionale Argumente werden unterstützt.

getopt.gnu_getopt(args, shortopts, longopts=[])¶

Diese Funktion funktioniert wie getopt(), außer dass standardmäßig der GNU-Stil-Scanning-Modus verwendet wird. Das bedeutet, dass Options- und Nicht-Options-Argumente gemischt werden können. Die Funktion getopt() stoppt die Optionsverarbeitung, sobald ein Nicht-Options-Argument angetroffen wird.

Wenn das erste Zeichen der Optionszeichenkette ''+' ist oder wenn die Umgebungsvariable POSIXLY_CORRECT gesetzt ist, stoppt die Optionsverarbeitung, sobald ein Nicht-Options-Argument angetroffen wird.

Wenn das erste Zeichen der Optionszeichenkette ''-' ist, werden Nicht-Options-Argumente, denen Optionen folgen, als Paar zur Liste der Options- und Wert-Paare hinzugefügt, wobei None als erstes Element und die Liste der Nicht-Options-Argumente als zweites Element dient. Das zweite Element des Ergebnisses von gnu_getopt() ist eine Liste von Programmargumenten nach der letzten Option.

Geändert in Version 3.14: Unterstützung für die Rückgabe von gemischten Optionen und Nicht-Options-Argumenten in der Reihenfolge.

exception getopt.GetoptError¶: Diese Ausnahme wird ausgelöst, wenn eine nicht erkannte Option in der Argumentliste gefunden wird oder wenn einer Option, die ein Argument benötigt, keines gegeben wird. Das Argument der Ausnahme ist eine Zeichenkette, die die Ursache des Fehlers angibt. Für lange Optionen wird auch ein Argument, das einer Option gegeben wird, die keines benötigt, diese Ausnahme auslösen. Die Attribute msg und opt geben die Fehlermeldung und die zugehörige Option an; wenn keine bestimmte Option mit der Ausnahme verbunden ist, ist opt eine leere Zeichenkette.

exception getopt.error¶: Alias für GetoptError; aus Gründen der Abwärtskompatibilität.

Ein Beispiel nur mit Unix-Style-Optionen

>>> import getopt
>>> args = '-a -b -cfoo -d bar a1 a2'.split()
>>> args
['-a', '-b', '-cfoo', '-d', 'bar', 'a1', 'a2']
>>> optlist, args = getopt.getopt(args, 'abc:d:')
>>> optlist
[('-a', ''), ('-b', ''), ('-c', 'foo'), ('-d', 'bar')]
>>> args
['a1', 'a2']

Die Verwendung langer Optionsnamen ist ebenso einfach

>>> s = '--condition=foo --testing --output-file abc.def -x a1 a2'
>>> args = s.split()
>>> args
['--condition=foo', '--testing', '--output-file', 'abc.def', '-x', 'a1', 'a2']
>>> optlist, args = getopt.getopt(args, 'x', [
...     'condition=', 'output-file=', 'testing'])
>>> optlist
[('--condition', 'foo'), ('--testing', ''), ('--output-file', 'abc.def'), ('-x', '')]
>>> args
['a1', 'a2']

Optionale Argumente sollten explizit angegeben werden

>>> s = '-Con -C --color=off --color a1 a2'
>>> args = s.split()
>>> args
['-Con', '-C', '--color=off', '--color', 'a1', 'a2']
>>> optlist, args = getopt.getopt(args, 'C::', ['color=?'])
>>> optlist
[('-C', 'on'), ('-C', ''), ('--color', 'off'), ('--color', '')]
>>> args
['a1', 'a2']

Die Reihenfolge von Optionen und Nicht-Options-Argumenten kann beibehalten werden

>>> s = 'a1 -x a2 a3 a4 --long a5 a6'
>>> args = s.split()
>>> args
['a1', '-x', 'a2', 'a3', 'a4', '--long', 'a5', 'a6']
>>> optlist, args = getopt.gnu_getopt(args, '-x:', ['long='])
>>> optlist
[(None, ['a1']), ('-x', 'a2'), (None, ['a3', 'a4']), ('--long', 'a5')]
>>> args
['a6']

In einem Skript sieht die typische Verwendung etwa so aus

import getopt, sys

def main():
    try:
        opts, args = getopt.getopt(sys.argv[1:], "ho:v", ["help", "output="])
    except getopt.GetoptError as err:
        # print help information and exit:
        print(err)  # will print something like "option -a not recognized"
        usage()
        sys.exit(2)
    output = None
    verbose = False
    for o, a in opts:
        if o == "-v":
            verbose = True
        elif o in ("-h", "--help"):
            usage()
            sys.exit()
        elif o in ("-o", "--output"):
            output = a
        else:
            assert False, "unhandled option"
    process(args, output=output, verbose=verbose)

if __name__ == "__main__":
    main()

Beachten Sie, dass eine äquivalente Kommandozeilenschnittstelle mit weniger Code und informativeren Hilfe- und Fehlermeldungen durch die Verwendung des Moduls optparse erstellt werden könnte

import optparse

if __name__ == '__main__':
    parser = optparse.OptionParser()
    parser.add_option('-o', '--output')
    parser.add_option('-v', dest='verbose', action='store_true')
    opts, args = parser.parse_args()
    process(args, output=opts.output, verbose=opts.verbose)

Eine ungefähr äquivalente Kommandozeilenschnittstelle für diesen Fall kann auch durch die Verwendung des Moduls argparse erstellt werden

import argparse

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('-o', '--output')
    parser.add_argument('-v', dest='verbose', action='store_true')
    parser.add_argument('rest', nargs='*')
    args = parser.parse_args()
    process(args.rest, output=args.output, verbose=args.verbose)

Siehe Auswahl einer Argumentanalysebibliothek für Details, wie sich die argparse-Version dieses Codes im Verhalten von der optparse- (und getopt-) Version unterscheidet.

Siehe auch

Modul optparse: Deklarative Analyse von Kommandozeilenoptionen.
Modul argparse: Eine meinungsfreudigere Bibliothek für die Analyse von Kommandozeilenoptionen und -argumenten.

`getopt` — C-Style-Parser für Kommandozeilenoptionen¶

Vorheriges Thema

Nächstes Thema

Diese Seite

getopt — C-Style-Parser für Kommandozeilenoptionen¶

`getopt` — C-Style-Parser für Kommandozeilenoptionen¶