Vérifiez si l'argument optionnel argparse est défini ou non
Je voudrais vérifier si un argument argparse facultatif a été défini par l'utilisateur ou non.
Puis-je vérifier en toute sécurité en utilisant isset?
Quelque Chose comme ceci:
if(isset(args.myArg)):
#do something
else:
#do something else
Cela fonctionne-t-il de même pour les arguments de type float / int / string?
Je pourrais définir un paramètre par défaut et le vérifier (par exemple, set myArg = -1, ou "" pour une chaîne, ou"NOT_SET"). Cependant, la valeur que je veux finalement utiliser n'est calculée que plus tard dans le script. Donc, je le mettrais à -1 comme un par défaut, puis le mettre à jour vers autre chose plus tard. Cela semble un peu maladroit en comparaison avec simplement vérifier si la valeur a été définie par l'utilisateur.
6 réponses
Je pense que les arguments optionnels (spécifiés avec --) sont initialisés à None s'ils ne sont pas fournis. Vous pouvez donc tester avec is not None. Essayez l'exemple ci-dessous:
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
Comme le note @ Honza is None est un bon test. C'est la valeur par défaut default, et l'utilisateur ne peut pas vous donner une chaîne qui la duplique.
Vous pouvez spécifier un autre default='mydefaultvalue, et tester pour cela. Mais que faire si l'utilisateur spécifie cette chaîne? Ça compte aussi ou non?
, Vous pouvez également spécifier default=argparse.SUPPRESS. Ensuite, si l'utilisateur n'utilise pas l'argument, il n'apparaîtra pas dans le args espace de noms. Mais les tests qui pourraient être plus compliqués:
args.foo # raises an AttributeError
hasattr(args, 'foo') # returns False
getattr(args, 'foo', 'other') # returns 'other'
En Interne, le parser conserve une liste de seen_actions, et l'utilise pour "requis" et "mutually_exclusive' essai. Mais il n'est pas disponible à l'extérieur de parse_args.
Si votre argument est position (c'est à dire qu'il n'a pas un "-" ou un "--" préfixe, juste l'argument, généralement un nom de fichier), vous pouvez utiliser la nargs paramètre pour ce faire:
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')
Vous pouvez vérifier un indicateur éventuellement passé avec store_true et store_false options d'action de l'argument:
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)
De Cette façon, vous n'avez pas à vous soucier de vérifier par conditionnelle is not None. Vous vérifiez simplement True ou False. En savoir plus sur ces options dans les documents ici
Je pense que l'utilisation de l'option default=argparse.SUPPRESS a le plus de sens. Alors, au lieu de vérifier si l'argument est not None, on vérifie si l'argument est in résultant de l'espace de noms.
Exemple:
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))
Utilisation:
$ 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
Voici ma solution pour voir si j'utilise une variable argparse
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
Cela pourrait donner plus de perspicacité à la réponse ci-dessus que j'ai utilisée et adaptée pour travailler pour mon programme.