Análisis de valores booleanos con argparse

Me gustaría utilizar argparse para analizar argumentos de línea de comandos booleanos escritos como "--foo True" o "--foo False". Por ejemplo:

my_program --my_boolean_flag False

Sin embargo, el siguiente código de prueba no hace lo que me gustaría:

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)

Tristemente, parsed_args.my_boolevalúa a True. Este es el caso incluso cuando cambio cmd_linea ser ["--my_bool", ""], lo cual es sorprendente, ya que bool("")evalúa False.

¿Cómo puedo obtener argparse a analizar "False", "F"y su minúscula variantes que se vayan False?

Otra solución más usando las sugerencias anteriores, pero con el error de análisis "correcto" 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.')

Esto es muy útil para hacer cambios con valores predeterminados; por ejemplo

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

me permite usar:

script --nice
script --nice <bool>

y aún usa un valor predeterminado (específico para la configuración del usuario). Una desventaja (indirectamente relacionada) con ese enfoque es que los 'nargs' pueden atrapar un argumento posicional: vea esta pregunta relacionada y este informe de error de argparse .

Creo que una forma más canónica de hacer esto es a través de:

command --feature

y

command --no-feature

argparse admite esta versión muy bien:

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

Por supuesto, si realmente quieres la --arg <True|False>versión, puedes pasarla ast.literal_evalcomo "tipo" o como una función definida por el usuario ...

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?

Recomiendo la respuesta de mgilson pero con un grupo mutuamente excluyente
para que no pueda usar --featurey --no-featureal mismo tiempo.

command --feature

y

command --no-feature

pero no

command --feature --no-feature

Guión:

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)

Luego puede usar este asistente si va a configurar muchos de ellos:

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

Aquí hay otra variación sin fila / s extra para establecer valores predeterminados. El bool siempre tiene un valor asignado para que pueda usarse en declaraciones lógicas sin comprobaciones previas.

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

un trazador de líneas:

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

Parece haber cierta confusión en cuanto a qué type=booly type='bool'podría significar. ¿Debería uno (o ambos) significar 'ejecutar la función bool()o' devolver un booleano '? Tal como está type='bool', no significa nada. add_argumentda un 'bool' is not callableerror, igual que si usara type='foobar', otype='int' .

Pero argparsetiene un registro que le permite definir palabras clave como esta. Se utiliza principalmente para action, por ejemplo, `action = 'store_true'. Puede ver las palabras clave registradas con:

parser._registries

que muestra un diccionario

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

Hay muchas acciones definidas, pero solo un tipo, el predeterminado, argparse.identity .

Este código define una palabra clave '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()no está documentado, pero tampoco está oculto. En su mayor parte el programador no necesita saber al respecto porque typey actionvalores de la función toma y de clase. Hay muchos ejemplos de stackoverflow para definir valores personalizados para ambos.

En caso de que no sea obvio de la discusión anterior, bool()no significa 'analizar una cadena'. De la documentación de Python:

bool (x): convierte un valor a un booleano, utilizando el procedimiento estándar de prueba de verdad.

Contrasta esto con

int (x): Convierte un número o cadena x en un entero.

Estaba buscando el mismo problema, y ​​en mi humilde opinión, la bonita solución es:

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

y usar eso para analizar la cadena a booleano como se sugirió anteriormente.

Una forma bastante similar es usar:

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

y si establece el argumento --característica en su comando

 command --feature

el argumento será Verdadero, si no establece el tipo --característica, el argumento predeterminado siempre es Falso!

Además de lo que dijo @mgilson, debe tenerse en cuenta que también hay un ArgumentParser.add_mutually_exclusive_group(required=False)método que haría que sea trivial hacer cumplir eso --flagy que --no-flagno se usen al mismo tiempo.

Esto funciona para todo lo que espero:

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

El código:

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

Una forma más sencilla sería usar la siguiente.

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

Más simple No es flexible, pero prefiero la simplicidad.

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

EDITAR: si no confía en la entrada, no la use eval.

La forma más sencilla sería usar opciones :

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

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

No pasa --mi-flag se evalúa como False. La opción required = True podría agregarse si siempre desea que el usuario especifique explícitamente una opción.

Creo que la forma más canónica será:

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 forma más simple y correcta es

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

Tenga en cuenta que los valores verdaderos son y, yes, t, true, on y 1; los valores falsos son n, no, f, falso, apagado y 0. Aumenta ValueError si val es otra cosa.

Rápido y fácil, pero solo para los argumentos 0 o 1:

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

El resultado será "Falso" después de llamar desde la terminal:

python myscript.py 0

Similar a @Akash pero aquí hay otro enfoque que he usado. Utiliza strque lambdadebido pitón lambdasiempre me da un extranjero sentimientos.

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

Como una mejora a la respuesta de @Akash Desarda, podrías hacer

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)

Y es compatible 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