Analiza wartości logicznych za pomocą argparse

Chciałbym użyć argparse do analizy argumentów wiersza poleceń boolean zapisanych jako „--foo True” lub „--foo False”. Na przykład:

my_program --my_boolean_flag False

Jednak poniższy kod testowy nie robi tego, co chciałbym:

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)

Niestety parsed_args.my_boolocenia True. Jest tak nawet w przypadku, kiedy zmieni cmd_linesię["--my_bool", ""] , co jest zaskakujące, ponieważ bool("")evalutates do False.

Jak mogę uzyskać argparse do analizowania "False", "F"a ich małymi literami warianty być False?

Jeszcze inne rozwiązanie wykorzystujące poprzednie sugestie, ale z „poprawnym” błędem analizy z 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.')

Jest to bardzo przydatne do tworzenia przełączników z wartościami domyślnymi; na przykład

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

pozwala mi używać:

script --nice
script --nice <bool>

i nadal używaj wartości domyślnej (specyficznej dla ustawień użytkownika). Jednym (pośrednio powiązanym) minusem tego podejścia jest to, że „nargs” może złapać argument pozycyjny - zobacz to powiązane pytanie i ten raport o błędach argparse .

Myślę, że bardziej kanonicznym sposobem na to jest:

command --feature

i

command --no-feature

argparse ładnie obsługuje tę wersję:

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

Oczywiście, jeśli naprawdę chcesz --arg <True|False>wersję, możesz przekazać ją ast.literal_evaljako „typ” lub funkcję zdefiniowaną przez użytkownika ...

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?

Polecam odpowiedź mgilson, ale z ekskluzywnej grupy wzajemnie
tak, że nie można używać --featurei --no-featurew tym samym czasie.

command --feature

i

command --no-feature

ale nie

command --feature --no-feature

Scenariusz:

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)

Możesz użyć tego pomocnika, jeśli chcesz ustawić wiele z nich:

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

Oto kolejna odmiana bez dodatkowych wierszy / s, aby ustawić wartości domyślne. Wartość bool zawsze ma przypisaną wartość, dzięki czemu można jej używać w instrukcjach logicznych bez wstępnej kontroli.

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

Wydaje się, że istnieje pewne zamieszanie co do tego type=bool i type='bool'może oznaczać. Czy jeden (lub oba) powinien oznaczać „uruchomić funkcję bool(), czy„ zwrócić wartość logiczną ”? W obecnej formie type='bool'nic nie znaczy. add_argumentdaje 'bool' is not callablebłąd, taki sam jak w przypadku użycia type='foobar', lub type='int'.

Ale argparsema rejestr, który pozwala zdefiniować takie słowa kluczowe. Jest używany głównie do action, np. `Action = 'store_true'. Możesz zobaczyć zarejestrowane słowa kluczowe za pomocą:

parser._registries

który wyświetla słownik

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

Istnieje wiele działań zdefiniowana, ale tylko jeden rodzaj, wartość domyślna, argparse.identity.

Ten kod definiuje słowo kluczowe „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()nie jest udokumentowany, ale także nie jest ukryty. W większości przypadków programista nie musi o tym wiedzieć, ponieważtype i actionfunkcja odbioru i klasy wartości. Istnieje wiele przykładów przepływu stosu definiowania niestandardowych wartości dla obu.

Jeśli nie jest to oczywiste z poprzedniej dyskusji, bool() nie oznacza to „parsowania łańcucha”. Z dokumentacji Python:

bool (x): Konwertuj wartość na wartość logiczną, używając standardowej procedury sprawdzania prawdy.

Porównaj to z

int (x): Konwertuje liczbę lub ciąg x na liczbę całkowitą.

Szukałem tego samego problemu, a imho ładnym rozwiązaniem jest:

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

i użycie go do parsowania łańcucha na wartość logiczną, jak sugerowano powyżej.

Całkiem podobny sposób polega na użyciu:

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

a jeśli ustawisz argument - funkcja w swoim poleceniu

 command --feature

argumentem będzie Prawda, jeśli nie ustawisz typu - funkcja argumentami domyślnie jest zawsze Fałsz!

Oprócz tego, co powiedział @mgilson, należy zauważyć, że istnieje również ArgumentParser.add_mutually_exclusive_group(required=False)metoda, która sprawiłaby, że wymuszenie tego byłoby trywialne --flagi --no-flagnie jest używane jednocześnie.

Działa to na wszystko, czego oczekuję:

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

Kod:

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

Prostszym sposobem byłoby użycie jak poniżej.

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

Najprostszy Nie jest elastyczny, ale wolę prostotę.

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

EDYCJA: Jeśli nie ufasz danych wejściowych, nie używaj eval.

Najprostszym sposobem byłoby użycie opcji :

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

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

Nieprzekazanie - moja-flaga zwraca wartość False. Wymagane = True opcji można dodać, jeśli zawsze chcesz użytkownikowi podanie wyboru.

Myślę, że najbardziej kanonicznym sposobem będzie:

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)

Najprostszym i najbardziej poprawnym sposobem jest

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

Zauważ, że wartościami True są y, tak, t, true, on i 1; fałszywe wartości to n, no, f, false, off i 0. Podnosi wartośćError, jeśli val jest czymś innym.

Szybko i łatwo, ale tylko dla argumentów 0 lub 1:

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

Wyjście będzie „False” po wywołaniu z terminala:

python myscript.py 0

Podobne do @Akash, ale oto inne podejście, którego użyłem. Używa strniż lambdadlatego, że python lambdazawsze daje mi obce uczucia.

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

Jako ulepszenie odpowiedzi @Akash Desarda możesz to zrobić

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)

I obsługuje 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