Analyser les valeurs booléennes avec argparse

Je voudrais utiliser argparse pour analyser les arguments de ligne de commande booléens écrits comme "--foo True" ou "--foo False". Par exemple:

my_program --my_boolean_flag False

Cependant, le code de test suivant ne fait pas ce que je voudrais:

import argparse
parser = argparse.ArgumentParser(description="My parser")
parser.add_argument("--my_bool", type=bool)
cmd_line = ["--my_bool", "False"]
parsed_args = parser.parse(cmd_line)

Malheureusement, parsed_args.my_boolévalue à True. C'est le cas même lorsque je change cmd_linepour être ["--my_bool", ""], ce qui est surprenant, car bool("")évalue à False.

Comment puis - je obtenir argparse pour analyser "False", "F"et leur minuscules variantes d'être False?

Encore une autre solution utilisant les suggestions précédentes, mais avec l'erreur d'analyse "correcte" de argparse:

def str2bool(v):
    if isinstance(v, bool):
       return v
    if v.lower() in ('yes', 'true', 't', 'y', '1'):
        return True
    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
        return False
    else:
        raise argparse.ArgumentTypeError('Boolean value expected.')

Ceci est très utile pour effectuer des commutations avec des valeurs par défaut; par exemple

parser.add_argument("--nice", type=str2bool, nargs='?',
                        const=True, default=False,
                        help="Activate nice mode.")

me permet d'utiliser:

script --nice
script --nice <bool>

et toujours utiliser une valeur par défaut (spécifique aux paramètres utilisateur). Un inconvénient (indirectement lié) à cette approche est que les `` nargs '' peuvent attraper un argument positionnel - voir cette question connexe et ce rapport de bug d'argparse .

Je pense qu'une façon plus canonique de le faire est via:

command --feature

et

command --no-feature

argparse prend bien en charge cette version:

parser.add_argument('--feature', dest='feature', action='store_true')
parser.add_argument('--no-feature', dest='feature', action='store_false')
parser.set_defaults(feature=True)

Bien sûr, si vous voulez vraiment la --arg <True|False>version, vous pouvez passer ast.literal_evalcomme "type", ou fonction définie par l'utilisateur ...

def t_or_f(arg):
    ua = str(arg).upper()
    if 'TRUE'.startswith(ua):
       return True
    elif 'FALSE'.startswith(ua):
       return False
    else:
       pass  #error condition maybe?

Je recommande la réponse de mgilson mais avec un groupe mutuellement exclusif
afin que vous ne puissiez pas utiliser --featureet --no-featureen même temps.

command --feature

et

command --no-feature

mais non

command --feature --no-feature

Scénario:

feature_parser = parser.add_mutually_exclusive_group(required=False)
feature_parser.add_argument('--feature', dest='feature', action='store_true')
feature_parser.add_argument('--no-feature', dest='feature', action='store_false')
parser.set_defaults(feature=True)

Vous pouvez ensuite utiliser cet assistant si vous allez en définir plusieurs:

def add_bool_arg(parser, name, default=False):
    group = parser.add_mutually_exclusive_group(required=False)
    group.add_argument('--' + name, dest=name, action='store_true')
    group.add_argument('--no-' + name, dest=name, action='store_false')
    parser.set_defaults(**{name:default})

add_bool_arg(parser, 'useful-feature')
add_bool_arg(parser, 'even-more-useful-feature')

Voici une autre variante sans ligne / s supplémentaire pour définir les valeurs par défaut. Le booléen a toujours une valeur assignée afin qu'il puisse être utilisé dans des instructions logiques sans pré-vérifications.

import argparse
parser = argparse.ArgumentParser(description="Parse bool")
parser.add_argument("--do-something", default=False, action="store_true" , help="Flag to do something")
args = parser.parse_args()

if args.do_something:
     print("Do something")
else:
     print("Don't do something")
print("Check that args.do_something=" + str(args.do_something) + " is always a bool")

bon mot:

parser.add_argument('--is_debug', default=False, type=lambda x: (str(x).lower() == 'true'))

Il semble y avoir une certaine confusion quant à ce que type=boolet type='bool'pourrait signifier. Doit-on (ou les deux) signifier 'exécuter la fonction bool(), ou' retourner un booléen '? En l'état, cela type='bool'ne veut rien dire. add_argumentdonne une 'bool' is not callableerreur, comme si vous l'avez utilisé type='foobar', ou type='int'.

Mais argparsea un registre qui vous permet de définir des mots clés comme celui-ci. Il est principalement utilisé pour action, par exemple, `action = 'store_true'. Vous pouvez voir les mots-clés enregistrés avec:

parser._registries

qui affiche un dictionnaire

{'action': {None: argparse._StoreAction,
  'append': argparse._AppendAction,
  'append_const': argparse._AppendConstAction,
...
 'type': {None: <function argparse.identity>}}

Il y a beaucoup d'actions définies, mais un seul type, la valeur par défaut un, argparse.identity.

Ce code définit un mot clé 'bool':

def str2bool(v):
  #susendberg's function
  return v.lower() in ("yes", "true", "t", "1")
p = argparse.ArgumentParser()
p.register('type','bool',str2bool) # add type keyword to registries
p.add_argument('-b',type='bool')  # do not use 'type=bool'
# p.add_argument('-b',type=str2bool) # works just as well
p.parse_args('-b false'.split())
Namespace(b=False)

parser.register()n'est pas documenté, mais n'est pas non plus caché. Pour la plupart, le programmeur n'a pas besoin de le savoir car typeil actionprend des valeurs de fonction et de classe. Il existe de nombreux exemples de stackoverflow de définition de valeurs personnalisées pour les deux.

Dans le cas où cela n'est pas évident à partir de la discussion précédente, bool()cela ne signifie pas «analyser une chaîne». Dans la documentation Python:

bool (x): convertit une valeur en booléen, en utilisant la procédure standard de test de vérité.

Comparez cela avec

int (x): convertit un nombre ou une chaîne x en entier.

Je cherchais le même problème, et à mon humble avis, la jolie solution est:

def str2bool(v):
  return v.lower() in ("yes", "true", "t", "1")

et en utilisant cela pour analyser la chaîne en booléen comme suggéré ci-dessus.

Une manière assez similaire consiste à utiliser:

feature.add_argument('--feature',action='store_true')

et si vous définissez l'argument --feature dans votre commande

 command --feature

l'argument sera True, si vous ne définissez pas type --feature les arguments par défaut sont toujours False!

En plus de ce que @mgilson a dit, il convient de noter qu'il existe également une ArgumentParser.add_mutually_exclusive_group(required=False)méthode qui rendrait l'application de cela triviale --flaget qui --no-flagn'est pas utilisée en même temps.

Cela fonctionne pour tout ce que j'attends:

add_boolean_argument(parser, 'foo', default=True)
parser.parse_args([])                   # Whatever the default was
parser.parse_args(['--foo'])            # True
parser.parse_args(['--nofoo'])          # False
parser.parse_args(['--foo=true'])       # True
parser.parse_args(['--foo=false'])      # False
parser.parse_args(['--foo', '--nofoo']) # Error

Le code:

def _str_to_bool(s):
    """Convert string to bool (in argparse context)."""
    if s.lower() not in ['true', 'false']:
        raise ValueError('Need bool; got %r' % s)
    return {'true': True, 'false': False}[s.lower()]

def add_boolean_argument(parser, name, default=False):                                                                                               
    """Add a boolean argument to an ArgumentParser instance."""
    group = parser.add_mutually_exclusive_group()
    group.add_argument(
        '--' + name, nargs='?', default=default, const=True, type=_str_to_bool)
    group.add_argument('--no' + name, dest=name, action='store_false')

Une manière plus simple serait d'utiliser comme ci-dessous.

parser.add_argument('--feature', type=lambda s: s.lower() in ['true', 't', 'yes', '1'])

Le plus simple. Ce n'est pas flexible, mais je préfère la simplicité.

  parser.add_argument('--boolean_flag',
                      help='This is a boolean flag.',
                      type=eval, 
                      choices=[True, False], 
                      default='True')

EDIT: Si vous ne faites pas confiance à l'entrée, ne l'utilisez pas eval.

Le moyen le plus simple serait d'utiliser des choix :

parser = argparse.ArgumentParser()
parser.add_argument('--my-flag',choices=('True','False'))

args = parser.parse_args()
flag = args.my_flag == 'True'
print(flag)

Ne passe pas --my-flag est évalué à False. L' option required = True peut être ajoutée si vous souhaitez toujours que l'utilisateur spécifie explicitement un choix.

Je pense que la manière la plus canonique sera:

parser.add_argument('--ensure', nargs='*', default=None)

ENSURE = config.ensure is None

class FlagAction(argparse.Action):
    # From http://bugs.python.org/issue8538

    def __init__(self, option_strings, dest, default=None,
                 required=False, help=None, metavar=None,
                 positive_prefixes=['--'], negative_prefixes=['--no-']):
        self.positive_strings = set()
        self.negative_strings = set()
        for string in option_strings:
            assert re.match(r'--[A-z]+', string)
            suffix = string[2:]
            for positive_prefix in positive_prefixes:
                self.positive_strings.add(positive_prefix + suffix)
            for negative_prefix in negative_prefixes:
                self.negative_strings.add(negative_prefix + suffix)
        strings = list(self.positive_strings | self.negative_strings)
        super(FlagAction, self).__init__(option_strings=strings, dest=dest,
                                         nargs=0, const=None, default=default, type=bool, choices=None,
                                         required=required, help=help, metavar=metavar)

    def __call__(self, parser, namespace, values, option_string=None):
        if option_string in self.positive_strings:
            setattr(namespace, self.dest, True)
        else:
            setattr(namespace, self.dest, False)

La manière la plus simple et la plus correcte est

from distutils import util
arser.add_argument('--feature', dest='feature', type=lambda x:bool(distutils.util.strtobool(x)))

Notez que les valeurs vraies sont y, oui, t, true, on et 1; les fausses valeurs sont n, non, f, faux, désactivé et 0. Déclenche ValueError si val est autre chose.

Rapide et facile, mais uniquement pour les arguments 0 ou 1:

parser.add_argument("mybool", default=True,type=lambda x: bool(int(x)))
myargs=parser.parse_args()
print(myargs.mybool)

La sortie sera "False" après avoir appelé depuis le terminal:

python myscript.py 0

Similaire à @Akash mais voici une autre approche que j'ai utilisée. Il utilise strque lambdaparce que le python lambdame donne toujours des sentiments extraterrestres.

import argparse
from distutils.util import strtobool

parser = argparse.ArgumentParser()
parser.add_argument("--my_bool", type=str, default="False")
args = parser.parse_args()

if bool(strtobool(args.my_bool)) is True:
    print("OK")

Pour améliorer la réponse de @Akash Desarda, vous pourriez faire

import argparse
from distutils.util import strtobool

parser = argparse.ArgumentParser()
parser.add_argument("--foo", 
    type=lambda x:bool(strtobool(x)),
    nargs='?', const=True, default=False)
args = parser.parse_args()
print(args.foo)

Et il prend en charge python test.py --foo

(base) [costa@costa-pc code]$ python test.py
False
(base) [costa@costa-pc code]$ python test.py --foo 
True
(base) [costa@costa-pc code]$ python test.py --foo True
True
(base) [costa@costa-pc code]$ python test.py --foo False
False