Überprüfen Sie, ob das optionale Argument argparse festgelegt ist oder nicht

Ich möchte prüfen, ob der Benutzer ein optionales Argument für argparse festgelegt hat oder nicht.

Kann ich mit isset sicher prüfen?

Etwas wie das:

if(isset(args.myArg)):
    #do something
else:
    #do something else

Funktioniert dies auch für Argumente vom Typ float / int / string?

Ich könnte einen Standardparameter festlegen und ihn überprüfen (z. B. myArg = -1 oder "" für einen String oder "NOT_SET"). Der Wert, den ich letztendlich verwenden möchte, wird jedoch erst später im Skript berechnet. Also würde ich es als Standard auf -1 setzen und es später auf etwas anderes aktualisieren. Dies scheint etwas ungeschickt im Vergleich zu der einfachen Überprüfung, ob der Wert vom Benutzer festgelegt wurde.

Ich denke, dass optionale Argumente (angegeben mit --) initialisiert werden, Nonewenn sie nicht angegeben werden. So können Sie mit testen is not None. Versuchen Sie das folgende Beispiel:

import argparse as ap

def main():
    parser = ap.ArgumentParser(description="My Script")
    parser.add_argument("--myArg")
    args, leftovers = parser.parse_known_args()

    if args.myArg is not None:
        print "myArg has been set (value is %s)" % args.myArg

Wie @Honza bemerkt, is Noneist ein guter Test. Dies ist die Standardeinstellung default, und der Benutzer kann Ihnen keine Zeichenfolge geben, die sie dupliziert.

Sie können eine andere angeben default='mydefaultvalueund diese testen. Was aber, wenn der Benutzer diese Zeichenfolge angibt? Zählt das als Einstellung oder nicht?

Sie können auch angeben default=argparse.SUPPRESS. Wenn der Benutzer das Argument dann nicht verwendet, wird es nicht im argsNamespace angezeigt. Aber das könnte komplizierter sein:

args.foo # raises an AttributeError
hasattr(args, 'foo')  # returns False
getattr(args, 'foo', 'other') # returns 'other'

Intern parserführt der eine Liste von seen_actionsund verwendet sie für 'erforderliche' und 'gegenseitig ausschließende' Tests. Aber es steht Ihnen außerhalb von nicht zur Verfügung parse_args.

Ich denke, die Option default=argparse.SUPPRESSist am sinnvollsten. Anstatt zu prüfen, ob das Argument ist not None, prüft man dann, ob das Argument inder resultierende Namespace ist.

Beispiel:

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--foo", default=argparse.SUPPRESS)
ns = parser.parse_args()

print("Parsed arguments: {}".format(ns))
print("foo in namespace?: {}".format("foo" in ns))

Verwendung:

$ python argparse_test.py --foo 1
Parsed arguments: Namespace(foo='1')
foo in namespace?: True

$ python argparse_test.py
Parsed arguments: Namespace()
foo in namespace?: False

Sie können ein optional übergebenes Flag mit store_trueund store_falseArgumentaktionsoptionen überprüfen :

import argparse

argparser = argparse.ArgumentParser()
argparser.add_argument('-flag', dest='flag_exists', action='store_true')

print argparser.parse_args([])
# Namespace(flag_exists=False)
print argparser.parse_args(['-flag'])
# Namespace(flag_exists=True)

Auf diese Weise müssen Sie sich keine Gedanken über die Überprüfung durch Bedingungen machen is not None. Sie suchen einfach nach Trueoder False. Weitere Informationen zu diesen Optionen finden Sie in den Dokumenten hier

Wenn Ihr Argument positionell ist (dh es hat kein "-" oder "-" Präfix, nur das Argument, normalerweise einen Dateinamen), können Sie den Parameter nargs verwenden , um dies zu tun:

parser = argparse.ArgumentParser(description='Foo is a program that does things')
parser.add_argument('filename', nargs='?')
args = parser.parse_args()

if args.filename is not None:
    print('The file name is {}'.format(args.filename))
else:
    print('Oh well ; No args, no problems')

Hier ist meine Lösung, um zu sehen, ob ich eine Argparse-Variable verwende

import argparse

ap = argparse.ArgumentParser()
ap.add_argument("-1", "--first", required=True)
ap.add_argument("-2", "--second", required=True)
ap.add_argument("-3", "--third", required=False) 
# Combine all arguments into a list called args
args = vars(ap.parse_args())
if args["third"] is not None:
# do something

Dies könnte einen besseren Einblick in die obige Antwort geben, die ich für mein Programm verwendet und angepasst habe.

Um den Kommentar von @ kcpr zu der (derzeit akzeptierten) Antwort von @Honza Osobne zu adressieren

Leider funktioniert es nicht, dann hat das Argument seinen Standardwert definiert.

Man kann zuerst überprüfen, ob das Argument bereitgestellt wurde, indem man es mit dem NamespaceObjekt abd vergleicht, das die default=argparse.SUPPRESSOption bereitstellt (siehe Antworten von @ hpaulj und @Erasmus Cedernaes und dieses python3-Dokument ). Wenn es nicht angegeben wurde, setzt man es auf einen Standardwert.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--infile', default=argparse.SUPPRESS)
args = parser.parse_args()
if 'infile' in args: 
    # the argument is in the namespace, it's been provided by the user
    # set it to what has been provided
    theinfile = args.infile
    print('argument \'--infile\' was given, set to {}'.format(theinfile))
else:
    # the argument isn't in the namespace
    # set it to a default value
    theinfile = 'your_default.txt'
    print('argument \'--infile\' was not given, set to default {}'.format(theinfile))

Verwendung

$ python3 testargparse_so.py
argument '--infile' was not given, set to default your_default.txt

$ python3 testargparse_so.py --infile user_file.txt
argument '--infile' was given, set to user_file.txt

Sehr einfach, nachdem die Variable args durch 'args = parser.parse_args ()' definiert wurde, enthält sie auch alle Daten der Variablen der Teilmenge args. Um zu überprüfen, ob eine Variable gesetzt ist oder nicht, wird angenommen, dass 'action = "store_true" verwendet wird ...

if args.argument_name:
   # do something
else:
   # do something else