[PYTHON] Argparse

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                   help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                   const=sum, default=max,
                   help='sum the integers (default: find the max)')
args = parser.parse_args()
print(args.accumulate(args.integers))

Argparse verwenden

Machen Sie einen Parser

Um argparse zu verwenden, erstellen Sie zunächst ein ArgumentParser-Objekt.

parser = argparse.ArgumentParser(description='Process some integers.')

Fügen Sie ein Argument hinzu

Rufen Sie die Methode add_argument () für das ArgumentParser-Objekt auf Sie lernen, wie Sie eine Befehlszeilenzeichenfolge in ein Objekt verwandeln.

parser.add_argument('intgers', metavar='N', type=int, nargs='+',
  help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
  const=sum, default=max,
  help='sum the intgers (default: find the max)')

Wenn Sie parse_args () aufrufen, erhalten Sie zwei Attribute, Indikatoren und akkumulieren. Gibt das Objekt zurück, das es hat.

Das Attribut "Ganzzahlen" ist eine Liste von einer oder mehreren Ganzzahlen, und das Attribut "Akkumulieren" ist Wenn in der Befehlszeile --sum angegeben wird, lautet die Funktion sum () Ansonsten ist es eine max () Funktion.

Analysieren Sie das Argument

ArgmumentParser analysiert seine Argumente mit der Methode parse_args (). Diese Methode untersucht die Befehlszeile, konvertiert jedes Argument in den richtigen Typ. Ergreifen Sie die entsprechenden Maßnahmen.

In den meisten Fällen stammt dies aus der Befehlszeilenanalyse Mittel zum Erstellen eines einfachen Namespace-Objekts.

Im Skript wird parse_args () normalerweise ohne Argumente aufgerufen ArgumentParser ruft automatisch Befehlszeilenargumente von sys.argv ab.

ArgumentParser-Objekt

class argparse.ArgumentParser(prog=None, usage=None, description=None,
 epilog=None, parents=[], formatter_class=argparse.helpFormatter,
 prefix_chars='-', fromfile_prefix_chars=None, argument_default=None,
 conflict_handler='error', add_help=true)

Alle Argumente sollten als Schlüsselwortargumente übergeben werden.

prog

Wenn Sie argparse verwenden, lautet der Programmname in der Hilfemeldung Standardmäßig wird es von sys.argv [0] abgerufen.

Wenn Sie ein Programm namens myprogram.py ausführen, lautet der Wert von sys.argv [0] Es wird zu "myprogram.py".

Je nachdem, wie das Programm in der Befehlszeile startet Dies ist in den meisten Fällen das gewünschte Verhalten, da eine Hilfemeldung erstellt wird.

Verwenden Sie das Argument prog = des ArgumentParser, um dieses Standardverhalten zu ändern Dies kann durch Angabe anderer Werte erreicht werden.

Der Programmname wurde mit dem Argument prog = angegeben, auch wenn er aus sys.argv [0] stammt. Auch wenn in der Hilfemeldung mit dem Formatbezeichner % (prog) s Verfügbar.

>>> parser = argparse.ArgumentParser(prog='myprogram')
>>> parser.add_argument('--foo', help='foo of the %(prog)s program')
>>> parser.print_help()
usage: myprogram [-h] [--foo FOO]

optional arguments:
  -h, --help  show this help message and exit
  --foo FOO   foo of the myprogram program

usage

usage: PROG [-h] [--foo [FOO]] bar [bar ...]

Standardmäßig wird die Verwendung automatisch erstellt. Sie kann explizit mit dem Schlüsselwortargument usage = angegeben werden.

parser = argparse.ArgumentParser(prog='PROG', usage='%(prog)s [options]')

usage: PROG [options]

description

Mit dem Schlüsselwortargument description =, der Befehlszeilenverwendung und dem Argument Was das Programm macht und wie es während der Hilfemeldung funktioniert Eine kurze Erklärung dazu wird angezeigt.

parser = argparse.ArgumentParser(description='A foo that bars')
parser.print_help()

usage: argparse.py [-h]

A foo that bars

optional arguments:
  -h, --help show this help message and exit

epilog

Zeigen Sie nach der Argumentbeschreibung eine zusätzliche Beschreibung des Programms an.

>>> parser = argparse.ArgumentParser(
  description='A foo that bars',
  epilog="And that's how you'd foo a bar")
>>> parser.print_help()  
usage: argparse.py

A foo that bars

optional arguments:
  -h, --help  show this help message and exit

And that's how you'd foo a bar

parents

Wenn Sie ein gemeinsames Argument auf mehrere Parser anwenden möchten Parser mit allen gängigen Argumenten im Argument "parent =" Kann übergeben werden.

Geben Sie add_help = False als übergeordneten Parser an.

parent_parser = argparse.ArgumentParser(add_help=False)
parent_parser.add_argument('--parent', type=int)

foo_parser = argparse.ArgumentParser(parents=[parent_parser])
foo_parser.add_argument('foo')
foo_parser.parse_args(['--parent', '2', 'XXX'])

bar_parser = argparse.ArgumentParser(parents=[parent_parser])
bar_parser.add_argument('--bar')
bar_parser.parse_args(['--bar', 'YYY'])

Methode add_argument ()

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const]
  [, default][, type][, choices][, required][, help][, metavar][, dest])

name or flags

Ist das angegebene Argument ein optionales Argument wie "-f" oder "--foo"? Ob es sich um ein Positionsargument wie eine Dateinamenliste handelt, im ersten Argument von "add_argument ()" geben.

Erstellen Sie optionale Argumente wie folgt.

parser.add_argument('-f', '--foo')

Positionsargumente werden wie folgt erstellt.

parser.add_argument('bar')

Wenn parse_args () aufgerufen wird, wird optionalen Argumenten - vorangestellt Es wird identifiziert und die anderen Argumente werden als Positionsargumente behandelt.

action

store

Speichert einfach den Wert des Arguments. Die Standardaktion.

store_const

speichert den durch das const-Schlüsselwortargument angegebenen Wert.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_const', const=42)

42 ist in einer Variablen namens foo gespeichert.

store_true, store_false

Speichert True bzw. False.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='store_true')
parser.add_argument('--bar', action='store_false')

Im obigen Fall speichert "foo" "True" und "bar" speichert "False".

append

Speichern Sie die Liste und fügen Sie den Wert jedes Arguments zur Liste hinzu.

Diese Aktion ist nützlich für Optionen, für die Sie mehrere Spezifikationen zulassen möchten.

parser = argparse.ArgumentParser()
parser.add_argument('--foo', action='append')
parser.parse_args('--foo 1 --foo 2'.splist())
Namespace(foo=['1', '2'])

append_const

Speichern Sie die Liste und legen Sie den Wert für das const-Schlüsselwortargument fest Zu dieser Liste hinzufügen.

parser = argparse.ArgumentParser()
parser.add_argument('--str', dest='types', action='append_const', const=str)
parser.add_argument('--int', dest='types', action='append_const', const=int)
parser.parse_args('--str --int'.split())
Namespace(types=[<class 'str'>, <class 'int'>])

count

Zählen Sie die Anzahl der Schlüsselwortargumente.

Zum Beispiel hilft es, das ausführliche Niveau zu erhöhen.

parser = argparse.ArgumentParser()
parser.add_argument('--versbose', '-v', action='count')
parser.parse_args('-vvv'.split())
Namespace(verbose=3)

nargs

Normalerweise ist das ArgumentParser-Objekt Übergeben Sie ein Befehlszeilenargument an eine Aktion.

Das nargs-Schlüsselwortargument bezieht sich auf eine Aktion und die Anzahl der anderen Befehlszeilenargumente können zugewiesen werden.

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', nargs=2)
>>> parser.add_argument('bar', nargs=1)
>>> parser.parse_args('c --foo a b'.split())
Namespace(bar=['c'], foo=['a', 'b'])

• N - Wenn nargs eine Ganzzahl ist, werden N Argumente über die Befehlszeile gesammelt. In einer Liste gespeichert.

*? - Wenn möglich, wird ein Argument aus der Befehlszeile übernommen, um ein Element zu erstellen. Wenn kein Befehlszeilenargument vorhanden ist, wird der Wert "default" generiert.

• '*' - Alle Befehlszeilenargumente werden in einer Liste gesammelt.

• '+' - Alle Befehlszeilenargumente werden in der Liste gesammelt, aber zumindest Generieren Sie eine Fehlermeldung, wenn kein Befehlszeilenargument vorhanden ist.

type

Standardmäßig verfügt das ArgumentParser-Objekt über Befehlszeilenargumente Als einfache Zeichenkette lesen.

Wenn die Befehlszeilenzeichenfolge als ein anderer Typ wie float, int usw. behandelt werden soll. Typprüfung und Typprüfung nach Typ Schlüsselwortargument von add_argument () Typkonvertierung kann durchgeführt werden.

Gängige integrierte Datentypen und Funktionen können direkt als Wert des Arguments "type" angegeben werden.

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('foo', type=int)
>>> parser.add_argument('bar', type=open)
>>> parser.parse_args('2 temp.text'.split())
Namespace(bar=<_io.TextIOWrapper name='temp.txt' encoding='UTF-8'>, foo=2)

choices

Wenn Sie möchten, dass das Befehlszeilenargument aus mehreren Optionen ausgewählt wird Möglich durch Übergeben des Schlüsselwortarguments "options".

Beim Parsen der Befehlszeile wird der Wert des Arguments überprüft und der Wert ist Wenn es nicht in den Optionen enthalten ist, wird eine Fehlermeldung angezeigt.

>>> parser = argparse.ArgumentParser(prog='game.py')
>>> parser = add_argument('move', choices=['rock', 'paper', 'scissors'])
>>> parser.parse_args(['rock'])
Namespace(move='rock')
>>> parser.parse_args(['fire'])
usage: game.py [-h] {rock,paper,scissors}
game.py: error: argument move: invalid choice: 'fire' (choose from 'rock', 'paper', 'scissors')

required

Um optionale Argumente obligatorisch zu machen, geben Sie "true" im Schlüsselwortargument "required =" an.

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', required=True)
>>> parser.parse_args(['--foo', 'BAR'])
Namespace(foo='BAR')
>>> parser.parse_args([])
usage: argparse.py [-h] [--foo FOO]
argparse.py: error: option --foo is required

help

Der Benutzer kann in der Befehlszeile usw. "-h" oder "--help" angeben. Wenn Sie um Hilfe bitten, wird diese "Hilfe" -Beschreibung in jedem Argument angezeigt.

>>> parser = argparse.ArgumentParser(prog='frobble')
>>> parser.add_argument('--foo', action='store_true',
      help='foo the bars before frobbling')
>>> parser.add_argument('bar', nargs='+',
      help='one of the bars to be frobbled')
>>> parser.parse_args('-h'.split())
usage: frobble [-h] [--foo] bar [bar ...]

positional arguments:
  bar  one of the bars to be frobbled

optional arguments:
  -h, --help   show this help message and exit
  --foo        foo the bars before frobbling

metavar

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.add_argument('bar')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage: [-h] [--foo FOO] bar

positional arguments:
  bar

optional arguments:
  -h, --help  show this help message and exit
  --foo FOO

Standardmäßig wird der Wert von "dest" wie für das Positionsargument verwendet. Konvertieren Sie für optionale Argumente den Wert von dest in Großbuchstaben und verwenden Sie ihn.

Positionsargumente mit einem "dest =" bar "werden als" bar "bezeichnet. Wenn ein optionales Argument "--foo" ein Befehlszeilenargument anfordert, Sein Argument wird als "FOO" bezeichnet.

Ein alternativer Name kann als "Metavar" angegeben werden.

>>> parser = argparse.ArgumnetParser()
>>> parser.add_argument('--foo', metavar='YYY')
>>> parser.add_argument('bar', metavar='XXX')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage: [-h] [--foo YYY] XXX

positional arguments:
  XXX

optional arguments:
  -h, --help show this help message and exit
  --foo YYY

Wenn Sie "nargs" angeben, können Sie einen Taple an "metavar" übergeben Sie können für jedes Argument einen anderen Namen angeben.

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x', nargs=2)
>>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))
>>> parser.print_help()
usage: PROG [-h] [-x X X] [--foo bar baz]

optional arguments:
  -h, --help    show this help message and exit
  -x X X
  --foo bar baz

dest

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('-f', '--foo-bar', '--foo')
>>> parser.add_argument('-x', '-y')
>>> parser.parse_args('-f 1 -x 2'.split())
Namespace(foo_bar='1', x='2')
>>> parser.parse_args('--foo 1 -y 2'.split())
Namespace(foo_bar='1', x='2')

ArgumentParser wählt die erste lange Optionszeichenfolge aus und ersetzt das führende -- Durch Entfernen wird der Wert von "dest" generiert.

Wenn keine lange Optionszeichenfolge angegeben ist, beginnen Sie mit der ersten kurzen Optionszeichenfolge Generieren Sie ein dest, indem Sie das führende- Zeichen entfernen.

Alle - Zeichen mit Ausnahme des Anfangs werden in _ konvertiert, sodass sie gültige Attributnamen sind.

Gehen Sie wie folgt vor, um dest einen benutzerdefinierten Attributnamen zu geben.

>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', dest='bar')
>>> parser.parse_args('--foo XXX'.split())
Namespace(bar='XXX')