Einfaches argparse-Beispiel gesucht: 1 Argument, 3 Ergebnisse

Question

Le site Dokumentation für die argparse python modul Das ist zwar ausgezeichnet, aber für mein kleines Anfängerhirn im Moment noch zu viel. Ich muss nicht in der Befehlszeile rechnen oder mich mit der Formatierung von Zeilen auf dem Bildschirm befassen oder Optionszeichen ändern. Alles, was ich tun möchte, ist "Wenn Arg A ist, tue dies, wenn B ist, tue das, wenn nichts davon zutrifft, zeige Hilfe und kündige" .

Answer 1

So mache ich es mit argparse (mit mehreren Argumenten):

parser = argparse.ArgumentParser(description='Description of your program')
parser.add_argument('-f','--foo', help='Description for foo argument', required=True)
parser.add_argument('-b','--bar', help='Description for bar argument', required=True)
args = vars(parser.parse_args())

args wird ein Wörterbuch sein, das die Argumente enthält:

if args['foo'] == 'Hello':
    # code here

if args['bar'] == 'World':
    # code here

In Ihrem Fall fügen Sie einfach nur ein Argument hinzu.

Answer 2

Ich verstehe die ursprüngliche Frage in zweierlei Hinsicht. Erstens bin ich im Hinblick auf das einfachste mögliche Argparse-Beispiel überrascht, dass ich es hier noch nicht gesehen habe. Natürlich ist es, um ganz einfach zu sein, auch nur ein Overhead mit wenig Leistung, aber es könnte ein Anfang sein.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("a")
args = parser.parse_args()

if args.a == 'magic.name':
    print 'You nailed it!'

Aber dieses Positionsargument ist jetzt erforderlich. Wenn Sie es beim Aufrufen dieses Programms weglassen, erhalten Sie eine Fehlermeldung über fehlende Argumente. Dies führt mich zum zweiten Teil der ursprünglichen Frage. Matt Wilkie scheint ein einzelnes optional Argument ohne benanntes Label (die --option Labels). Mein Vorschlag wäre, den obigen Code wie folgt zu ändern:

...
parser.add_argument("a", nargs='?', default="check_string_for_empty")
...
if args.a == 'check_string_for_empty':
    print 'I can tell that no argument was given and I can deal with that here.'
elif args.a == 'magic.name':
    print 'You nailed it!'
else:
    print args.a

Vielleicht gibt es eine elegantere Lösung, aber diese funktioniert und ist minimalistisch.

Answer 3

Le site argparse Die Dokumentation ist recht gut, lässt aber einige nützliche Details aus, die vielleicht nicht offensichtlich sind. (@Diego Navarro hat bereits einiges davon erwähnt, aber ich werde versuchen, seine Antwort etwas zu erweitern). Die grundlegende Verwendung ist wie folgt:

parser = argparse.ArgumentParser()
parser.add_argument('-f', '--my-foo', default='foobar')
parser.add_argument('-b', '--bar-value', default=3.14)
args = parser.parse_args()

Das Objekt, das Sie von parse_args() ist ein 'Namespace'-Objekt: Ein Objekt, dessen Mitgliedsvariablen nach Ihren Befehlszeilenargumenten benannt sind. Die Namespace Objekt können Sie auf Ihre Argumente und die damit verbundenen Werte zugreifen:

args = parser.parse_args()
print (args.my_foo)
print (args.bar_value)

(Beachten Sie, dass argparse ersetzt bei der Benennung der Variablen das '-' in den Argumenten durch Unterstriche).

In vielen Situationen werden Sie Argumente einfach als Flags verwenden wollen, die keinen Wert haben. Sie können diese in argparse wie folgt hinzufügen:

parser.add_argument('--foo', action='store_true')
parser.add_argument('--no-foo', action='store_false')

Dadurch werden Variablen mit den Namen "foo" mit dem Wert True bzw. "no_foo" mit dem Wert False erstellt:

if (args.foo):
    print ("foo is true")

if (args.no_foo is False):
    print ("nofoo is false")

Beachten Sie auch, dass Sie die Option "erforderlich" verwenden können, wenn Sie ein Argument hinzufügen:

parser.add_argument('-o', '--output', required=True)

Wenn Sie dieses Argument in der Befehlszeile weglassen, können Sie argparse wird Ihnen mitteilen, dass es fehlt und die Ausführung Ihres Skripts stoppen.

Schließlich ist zu beachten, dass es möglich ist, eine Diktatstruktur Ihrer Argumente zu erstellen, indem Sie die vars Funktion, wenn Ihnen das das Leben leichter macht.

args = parser.parse_args()
argsdict = vars(args)
print (argsdict['my_foo'])
print (argsdict['bar_value'])

Wie Sie sehen können, vars gibt ein Diktat mit den Namen Ihrer Argumente als Schlüssel und ihren Werten als, äh, Werte zurück.

Es gibt noch viele andere Optionen und Möglichkeiten, aber dies sollte die wichtigsten und häufigsten Anwendungsszenarien abdecken.

Answer 4

Matt fragt nach Positionsparametern in argparse, und ich stimme zu, dass die Python-Dokumentation zu diesem Aspekt mangelhaft ist. Es gibt kein einziges vollständiges Beispiel auf den ~20 Seiten, das sowohl Analyse und Verwendung von Positionsparametern .

Keine der anderen Antworten hier zeigt ein vollständiges Beispiel für Positionsparameter, daher hier ein vollständiges Beispiel:

# tested with python 2.7.1
import argparse

parser = argparse.ArgumentParser(description="An argparse example")

parser.add_argument('action', help='The action to take (e.g. install, remove, etc.)')
parser.add_argument('foo-bar', help='Hyphens are cumbersome in positional arguments')

args = parser.parse_args()

if args.action == "install":
    print("You asked for installation")
else:
    print("You asked for something other than installation")

# The following do not work:
# print(args.foo-bar)
# print(args.foo_bar)

# But this works:
print(getattr(args, 'foo-bar'))

Die Sache, die mich verwirrt hat, ist, dass argparse das benannte Argument "--foo-bar" in "foo_bar" umwandelt, aber ein Positionsparameter mit dem Namen "foo-bar" bleibt als "foo-bar", was es weniger offensichtlich macht, wie man ihn in seinem Programm verwendet.

Beachten Sie die beiden Zeilen am Ende meines Beispiels - keine davon wird funktionieren, um den Wert des Positionsparameters foo-bar zu erhalten. Die erste ist offensichtlich falsch (es ist ein arithmetischer Ausdruck args.foo minus bar), aber die zweite funktioniert auch nicht:

AttributeError: 'Namespace' object has no attribute 'foo_bar'

Wenn Sie die foo-bar Attribut, müssen Sie getattr wie in der letzten Zeile meines Beispiels zu sehen ist. Das Verrückte daran ist, dass, wenn Sie versuchen würden dest=foo_bar um den Eigenschaftsnamen in etwas zu ändern, auf das man leichter zugreifen kann, würden Sie eine wirklich bizarre Fehlermeldung erhalten:

ValueError: dest supplied twice for positional argument

Das obige Beispiel läuft folgendermaßen ab:

$ python test.py
usage: test.py [-h] action foo-bar
test.py: error: too few arguments

$ python test.py -h
usage: test.py [-h] action foo-bar

An argparse example

positional arguments:
  action      The action to take (e.g. install, remove, etc.)
  foo-bar     Hyphens are cumbersome in positional arguments

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

$ python test.py install foo
You asked for installation
foo

Answer 5

Eine weitere zusammenfassende Einführung, inspiriert von diese Stelle .

import argparse

# define functions, classes, etc.

# executes when your script is called from the command-line
if __name__ == "__main__":

    parser = argparse.ArgumentParser()
    #
    # define each option with: parser.add_argument
    #
    args = parser.parse_args() # automatically looks at sys.argv
    #
    # access results with: args.argumentName
    #

Die Argumente werden durch Kombinationen der folgenden Angaben definiert:

parser.add_argument( 'name', options... )              # positional argument
parser.add_argument( '-x', options... )                # single-char flag
parser.add_argument( '-x', '--long-name', options... ) # flag with long name

---

Übliche Optionen sind:

• Hilfe Beschreibung: Beschreibung für dieses Argument, wenn --help verwendet wird.
• Standard : Standardwert, wenn das Argument weggelassen wird.
• Typ : wenn Sie eine float o int (sonst ist str ).
• dest : einen anderen Namen für ein Flag vergeben (z.B. '-x', '--long-name', dest='longName' ).
  _Hinweis: Standardmäßig --long-name wird zugegriffen mit args.long_name_
• Aktion für die besondere Behandlung bestimmter Argumente
  • store_true, store_false : für boolesche Argumente
    '--foo', action='store_true' => args.foo == True
  • store_const : zu verwenden mit der Option const
'--foo', action='store_const', const=42 => args.foo == 42
  • count : für wiederholte Optionen, wie in ./myscript.py -vv
'-v', action='count' => args.v == 2
  • append : für wiederholte Optionen, wie in ./myscript.py --foo 1 --foo 2
'--foo', action='append' => args.foo == ['1', '2']
• erforderlich Wenn ein Flag erforderlich ist, oder wenn ein Positionsargument nicht erforderlich ist.
• nargs N Args: für eine Flagge zur Erfassung von N Args
  ./myscript.py --foo a b => args.foo = ['a', 'b']
• Auswahlmöglichkeiten : um die möglichen Eingaben einzuschränken (Angabe als Liste von Strings oder Ints, wenn type=int ).