Analysieren von booleschen Werten mit argparse

Ich möchte argparse verwenden, um boolesche Befehlszeilenargumente zu analysieren, die als "--foo True" oder "--foo False" geschrieben sind. Zum Beispiel:

my_program --my_boolean_flag False

Der folgende Testcode macht jedoch nicht das, was ich möchte:

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)

Leider parsed_args.my_boolbewertet zu True. Dies ist auch dann der Fall, wenn ich mich cmd_linezu bin ["--my_bool", ""], was überraschend ist, da es sich um eine bool("")Bewertung handelt False.

Wie kann ich argparse zu analysieren "False", "F"und ihre unteren Gehäusevarianten zu sein False?

Noch eine andere Lösung unter Verwendung der vorherigen Vorschläge, jedoch mit dem "richtigen" Analysefehler von 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.')

Dies ist sehr nützlich, um Schalter mit Standardwerten zu erstellen. zum Beispiel

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

erlaubt mir zu verwenden:

script --nice
script --nice <bool>

und verwenden Sie weiterhin einen Standardwert (spezifisch für die Benutzereinstellungen). Ein (indirekt verwandter) Nachteil dieses Ansatzes ist, dass die 'Nargs' möglicherweise ein Positionsargument auffangen - siehe diese verwandte Frage und diesen Argparse-Fehlerbericht .

Ich denke, ein kanonischerer Weg, dies zu tun, ist über:

command --feature

und

command --no-feature

argparse unterstützt diese Version gut:

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

Wenn Sie die --arg <True|False>Version wirklich wollen , können Sie sie natürlich ast.literal_evalals "Typ" oder als benutzerdefinierte Funktion übergeben ...

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?

Ich empfehle mgilson Antwort aber mit einer unvereinbaren Gruppe ,
so dass Sie nicht verwenden können , --featureund --no-featurezur gleichen Zeit.

command --feature

und

command --no-feature

aber nicht

command --feature --no-feature

Skript:

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)

Sie können diesen Helfer dann verwenden, wenn Sie viele davon festlegen möchten:

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

Hier ist eine weitere Variante ohne zusätzliche Zeile (n) zum Festlegen von Standardwerten. Dem Bool ist immer ein Wert zugewiesen, damit er ohne Vorabprüfung in logischen Anweisungen verwendet werden kann.

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

Einzeiler:

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

Es scheint einige Verwirrung darüber zu geben, was type=boolund type='bool'was bedeuten könnte. Sollte einer (oder beide) bedeuten, dass die Funktion ausgeführt bool()oder ein Boolescher Wert zurückgegeben wird? Wie es steht, type='bool'bedeutet nichts. add_argumentgibt einen 'bool' is not callableFehler aus, als ob Sie verwendet hätten type='foobar', oder type='int'.

Hat argparseaber eine Registrierung, mit der Sie Schlüsselwörter wie diese definieren können. Es wird meistens verwendet für actionzB `action = 'store_true'. Sie können die registrierten Schlüsselwörter sehen mit:

parser._registries

welches ein Wörterbuch anzeigt

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

Es sind viele Aktionen definiert, aber nur ein Typ, der Standardtyp argparse.identity.

Dieser Code definiert ein 'bool'-Schlüsselwort:

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()ist nicht dokumentiert, aber auch nicht versteckt. Zum größten Teil muss der Programmierer nicht darüber Bescheid wissen typeund actionFunktions- und Klassenwerte annehmen. Es gibt viele Beispiele für Stapelüberläufe zum Definieren benutzerdefinierter Werte für beide.

Falls dies aus der vorherigen Diskussion nicht ersichtlich ist, bool()bedeutet dies nicht "Parse a String". Aus der Python-Dokumentation:

bool (x): Konvertiert einen Wert in einen Booleschen Wert unter Verwendung des Standardverfahrens zum Testen der Wahrheit.

Vergleichen Sie dies mit

int (x): Konvertiert eine Zahl oder Zeichenfolge x in eine Ganzzahl.

Ich habe nach dem gleichen Problem gesucht und imho ist die hübsche Lösung:

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

und damit den String wie oben vorgeschlagen in einen Booleschen Wert analysieren.

Ein ganz ähnlicher Weg ist zu verwenden:

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

und wenn Sie das Argument --feature in Ihrem Befehl setzen

 command --feature

Das Argument ist True, wenn Sie den Typ --feature nicht festlegen. Die Standardeinstellung für Argumente ist immer False!

Zusätzlich zu dem, was @mgilson gesagt hat, sollte beachtet werden, dass es auch eine ArgumentParser.add_mutually_exclusive_group(required=False)Methode gibt, die es trivial macht, dies durchzusetzen, --flagund --no-flagnicht gleichzeitig verwendet wird.

Dies funktioniert für alles, was ich erwarte:

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

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

Ein einfacherer Weg wäre, wie unten zu verwenden.

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

Am einfachsten. Es ist nicht flexibel, aber ich bevorzuge Einfachheit.

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

BEARBEITEN: Wenn Sie der Eingabe nicht vertrauen, verwenden Sie sie nicht eval.

Der einfachste Weg wäre, Entscheidungen zu treffen :

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

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

Nicht übergeben --my-flag wird als False ausgewertet. Die erforderliche = True- Option kann hinzugefügt werden, wenn der Benutzer immer explizit eine Auswahl angeben soll.

Ich denke, der kanonischste Weg wird sein:

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)

Der einfachste und korrekteste Weg ist

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

Beachten Sie, dass True-Werte y, yes, t, true, on und 1 sind. falsche Werte sind n, no, f, false, off und 0. Löst ValueError aus, wenn val etwas anderes ist.

Schnell und einfach, aber nur für Argumente 0 oder 1:

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

Die Ausgabe ist nach dem Aufruf vom Terminal "False":

python myscript.py 0

Ähnlich wie @Akash, aber hier ist ein anderer Ansatz, den ich verwendet habe. Es verwendet strals, lambdaweil Python lambdamir immer ein fremdes Gefühl gibt.

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

Als Verbesserung der Antwort von @Akash Desarda könnten Sie dies tun

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)

Und es unterstützt 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