Parsing nilai boolean dengan argparse

Saya ingin menggunakan argumen argparse untuk mem-parsing baris perintah boolean yang ditulis sebagai "--foo True" atau "--foo False". Sebagai contoh:

my_program --my_boolean_flag False

Namun, kode tes berikut tidak melakukan apa yang saya inginkan:

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)

Sedihnya, parsed_args.my_booldievaluasi menjadi True. Ini adalah kasus bahkan ketika saya berubah cmd_linemenjadi ["--my_bool", ""], yang mengejutkan, sejak bool("")dievakuasi False.

Bagaimana saya bisa mendapatkan argparse untuk mengurai "False", "F"dan huruf kecil mereka varian untuk menjadi False?

Namun solusi lain menggunakan saran sebelumnya, tetapi dengan kesalahan parse "benar" dari 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.')

Ini sangat berguna untuk membuat sakelar dengan nilai default; contohnya

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

memungkinkan saya untuk menggunakan:

script --nice
script --nice <bool>

dan masih menggunakan nilai default (khusus untuk pengaturan pengguna). Satu kelemahan (terkait tidak langsung) dengan pendekatan itu adalah bahwa 'nargs' mungkin menangkap argumen posisi - lihat pertanyaan terkait ini dan laporan bug argparse ini .

Saya pikir cara yang lebih kanonik untuk melakukan ini adalah melalui:

command --feature

dan

command --no-feature

argparse mendukung versi ini dengan baik:

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

Tentu saja, jika Anda benar-benar menginginkan --arg <True|False>versi tersebut, Anda dapat lulus ast.literal_evalsebagai "tipe", atau fungsi yang ditentukan pengguna ...

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?

Saya merekomendasikan jawaban mgilson tetapi dengan grup yang saling eksklusif
sehingga Anda tidak dapat menggunakan --featuredan --no-featurepada saat yang sama.

command --feature

dan

command --no-feature

tapi tidak

command --feature --no-feature

Naskah:

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)

Anda kemudian dapat menggunakan pembantu ini jika Anda akan mengatur banyak dari mereka:

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

Berikut adalah variasi lain tanpa baris tambahan untuk menetapkan nilai default. Bool selalu memiliki nilai yang ditetapkan sehingga dapat digunakan dalam pernyataan logis tanpa pemeriksaan awal.

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

Tampaknya ada beberapa kebingungan tentang apa type=booldan apa type='bool'artinya. Haruskah satu (atau keduanya) berarti 'menjalankan fungsi bool(), atau' mengembalikan boolean '? Seperti berdiri type='bool'tidak ada artinya. add_argumentmemberikan 'bool' is not callablekesalahan, sama seperti jika Anda menggunakan type='foobar', atau type='int'.

Tetapi argparseapakah memiliki registri yang memungkinkan Anda menentukan kata kunci seperti ini. Ini sebagian besar digunakan untuk action, misalnya `action = 'store_true'. Anda dapat melihat kata kunci yang terdaftar dengan:

parser._registries

yang menampilkan kamus

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

Ada banyak tindakan yang ditentukan, tetapi hanya satu jenis, yang standar argparse.identity,.

Kode ini mendefinisikan kata kunci '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()tidak didokumentasikan, tetapi juga tidak disembunyikan. Untuk sebagian besar programmer tidak perlu tahu tentang hal itu karena typedan actionfungsi mengambil dan kelas nilai-nilai. Ada banyak contoh stackoverflow mendefinisikan nilai-nilai khusus untuk keduanya.

Dalam hal ini tidak jelas dari diskusi sebelumnya, bool()tidak berarti 'mengurai string'. Dari dokumentasi Python:

bool (x): Konversi nilai menjadi Boolean, menggunakan prosedur pengujian kebenaran standar.

Bandingkan ini dengan

int (x): Konversi angka atau string x ke integer.

Saya mencari masalah yang sama, dan solusi yang bagus adalah:

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

dan menggunakannya untuk mengurai string ke boolean seperti yang disarankan di atas.

Cara yang sangat mirip adalah dengan menggunakan:

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

dan jika Anda mengatur argumen - fitur dalam perintah Anda

 command --feature

argumennya adalah True, jika Anda tidak menyetel tipe --feature, argumen default selalu False!

Selain apa yang dikatakan @mgilson, perlu dicatat bahwa ada juga ArgumentParser.add_mutually_exclusive_group(required=False)metode yang membuatnya sepele untuk menerapkannya --flagdan --no-flagtidak digunakan pada saat yang sama.

Ini berfungsi untuk semua yang saya harapkan:

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

Kode:

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

Cara yang lebih sederhana adalah menggunakan seperti di bawah ini.

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

Paling sederhana. Ini tidak fleksibel, tetapi saya lebih suka kesederhanaan.

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

EDIT: Jika Anda tidak percaya input, jangan gunakan eval.

Cara paling sederhana adalah menggunakan pilihan :

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

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

Tidak lewat --my-flag mengevaluasi ke False. Opsi diperlukan = Benar dapat ditambahkan jika Anda selalu ingin pengguna untuk secara eksplisit menentukan pilihan.

Saya pikir cara yang paling kanonik adalah:

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)

Cara paling sederhana & paling benar adalah

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

Perhatikan bahwa nilai True adalah y, ya, t, benar, dan 1; nilai false adalah n, no, f, false, off dan 0. Meningkatkan ValueError jika val adalah hal lain.

Cepat dan mudah, tetapi hanya untuk argumen 0 atau 1:

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

Output akan menjadi "Salah" setelah menelepon dari terminal:

python myscript.py 0

Mirip dengan @Akash tapi di sini ada pendekatan lain yang pernah saya gunakan. Ini menggunakan strdaripada lambdakarena python lambdaselalu memberi saya perasaan asing.

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

Sebagai peningkatan jawaban @Akash Desarda, Anda bisa melakukannya

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)

Dan itu mendukung 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