Analisi dei valori booleani con argparse

Vorrei usare argparse per analizzare gli argomenti booleani della riga di comando scritti come "--foo True" o "--foo False". Per esempio:

my_program --my_boolean_flag False

Tuttavia, il seguente codice di prova non fa quello che vorrei:

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)

Purtroppo, parsed_args.my_boolvaluta True. Questo è il caso anche quando cambio cmd_linea esserlo ["--my_bool", ""], il che è sorprendente, dal momento che lo bool("")valuta False.

Come posso ottenere argparse per analizzare "False", "F"e la loro minuscole varianti di essere False?

Ancora un'altra soluzione che utilizza i suggerimenti precedenti, ma con l'errore di analisi "corretto" di 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.')

Questo è molto utile per creare switch con valori predefiniti; per esempio

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

mi permette di usare:

script --nice
script --nice <bool>

e utilizzare comunque un valore predefinito (specifico per le impostazioni dell'utente). Un aspetto negativo (indirettamente correlato) con questo approccio è che i 'nargs' potrebbero cogliere un argomento posizionale - vedi questa domanda correlata e questa segnalazione di bug argparse .

Penso che un modo più canonico per farlo sia tramite:

command --feature

e

command --no-feature

argparse supporta bene questa versione:

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

Naturalmente, se vuoi davvero la --arg <True|False>versione, potresti passare ast.literal_evalcome "tipo", o una funzione definita dall'utente ...

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?

Raccomando la risposta di mgilson ma con un gruppo
che si esclude a vicenda in modo che non sia possibile utilizzarlo --featuree --no-featureallo stesso tempo.

command --feature

e

command --no-feature

ma no

command --feature --no-feature

script:

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)

È quindi possibile utilizzare questo aiuto se si desidera impostare molti di essi:

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')

Ecco un'altra variante senza riga / e aggiuntiva per impostare i valori predefiniti. A bool è sempre assegnato un valore in modo che possa essere utilizzato in istruzioni logiche senza controlli preliminari.

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")

oneliner:

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

Sembra esserci un po 'di confusione su cosa type=boole cosa type='bool'potrebbe significare. Uno (o entrambi) dovrebbe significare "eseguire la funzione bool()o" restituire un valore booleano "? Così com'è type='bool'non significa nulla. add_argumentfornisce un 'bool' is not callableerrore, come se fosse stato utilizzato type='foobar', oppuretype='int' .

Ma argparseha un registro che ti consente di definire parole chiave come questa. È usato principalmente per action, ad esempio `action = 'store_true'. Puoi vedere le parole chiave registrate con:

parser._registries

che visualizza un dizionario

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

Sono state definite molte azioni, ma solo un tipo, quello predefinito, argparse.identity .

Questo codice definisce una parola chiave "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()non è documentato, ma anche non nascosto. Per la maggior parte il programmatore non ha bisogno di sapere perché typee actionvalori introito di funzione e di classe. Esistono molti esempi di stackoverflow per la definizione di valori personalizzati per entrambi.

Nel caso in cui non fosse ovvio dalla discussione precedente, bool()non significa "analizzare una stringa". Dalla documentazione di Python:

bool (x): converti un valore in un valore booleano, usando la procedura standard di verifica della verità.

Contrastare questo con

int (x): converte un numero o una stringa x in un numero intero.

Stavo cercando lo stesso problema, e immagino che la bella soluzione sia:

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

e usarlo per analizzare la stringa in booleano come suggerito sopra.

Un modo abbastanza simile è usare:

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

e se imposti l'argomento --feature nel tuo comando

 command --feature

l'argomento sarà True, se non si imposta type --feature l'argomento default è sempre False!

Oltre a ciò che ha detto @mgilson, va notato che esiste anche un ArgumentParser.add_mutually_exclusive_group(required=False)metodo che renderebbe banale farlo valere --flage --no-flagnon viene usato allo stesso tempo.

Questo funziona per tutto ciò che mi aspetto che:

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

Il codice:

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')

Un modo più semplice sarebbe usare come di seguito.

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

Più semplice. Non è flessibile, ma preferisco la semplicità.

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

EDIT: se non ti fidi dell'input, non usare eval.

Il modo più semplice sarebbe usare le scelte :

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

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

Non passando - my-flag restituisce False. L' opzione obbligatoria = True potrebbe essere aggiunta se si desidera sempre che l'utente specifichi esplicitamente una scelta.

Penso che il modo più canonico sarà:

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)

Il modo più semplice e corretto è

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

Si noti che i valori True sono y, yes, t, true, on e 1; i valori falsi sono n, no, f, false, off e 0. Aumenta ValueError se val è qualcos'altro.

Facile e veloce, ma solo per argomenti 0 o 1:

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

L'output sarà "Falso" dopo aver chiamato dal terminale:

python myscript.py 0

Simile a @Akash ma qui è un altro approccio che ho usato. Usa strche lambdaperché il pitone lambdami dà sempre sentimenti alieni.

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")

Come miglioramento alla risposta di @Akash Desarda, potresti fare

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)

E supporta 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