Phân tích các giá trị boolean với argparse

Tôi muốn sử dụng argparse để phân tích các đối số dòng lệnh boolean được viết là "--foo True" hoặc "--foo Sai". Ví dụ:

my_program --my_boolean_flag False

Tuy nhiên, mã kiểm tra sau không thực hiện được những gì tôi muốn:

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)

Đáng buồn thay, parsed_args.my_boolđánh giá để True. Đây là trường hợp ngay cả khi tôi thay đổi cmd_lineđược ["--my_bool", ""], mà là ngạc nhiên, vì bool("")evalutates tới False.

Làm thế nào tôi có thể nhận được argparse để phân tích "False", "F"và thấp hơn trường hợp của họ biến thể được False?

Một giải pháp khác sử dụng các đề xuất trước đó, nhưng với lỗi phân tích "chính xác" từ 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.')

Điều này rất hữu ích để thực hiện chuyển đổi với các giá trị mặc định; ví dụ

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

cho phép tôi sử dụng:

script --nice
script --nice <bool>

và vẫn sử dụng một giá trị mặc định (cụ thể cho cài đặt người dùng). Một nhược điểm (liên quan gián tiếp) với cách tiếp cận đó là các 'nargs' có thể bắt được một đối số vị trí - xem câu hỏi liên quan này và báo cáo lỗi này .

Tôi nghĩ rằng một cách kinh điển hơn để làm điều này là thông qua:

command --feature

và

command --no-feature

argparse hỗ trợ phiên bản này độc đáo:

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

Tất nhiên, nếu bạn thực sự muốn --arg <True|False>phiên bản, bạn có thể chuyển ast.literal_evaldưới dạng "loại" hoặc chức năng do người dùng xác định ...

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?

Tôi khuyên bạn nên trả lời mgilson nhưng với một nhóm loại trừ lẫn nhau
để bạn không thể sử dụng --featurevà --no-featurecùng một lúc.

command --feature

và

command --no-feature

nhưng không

command --feature --no-feature

Kịch bả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)

Sau đó, bạn có thể sử dụng trình trợ giúp này nếu bạn định đặt nhiều trong số chúng:

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

Đây là một biến thể khác không có thêm hàng / s để đặt giá trị mặc định. Bool luôn có một giá trị được gán để nó có thể được sử dụng trong các câu lệnh logic mà không cần kiểm tra trước.

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

lót:

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

Dường như có một số nhầm lẫn về những gì type=boolvà type='bool'có thể có nghĩa. Một (hoặc cả hai) có nghĩa là 'chạy chức năng bool(), hoặc' trả lại một boolean '? Vì nó đứng type='bool'có nghĩa là không có gì. add_argumentđưa ra một 'bool' is not callablelỗi, giống như khi bạn sử dụng type='foobar', hoặc type='int'.

Nhưng argparsecó đăng ký cho phép bạn xác định các từ khóa như thế này. Nó chủ yếu được sử dụng cho action, ví dụ `action = 'store_true'. Bạn có thể thấy các từ khóa đã đăng ký với:

parser._registries

trong đó hiển thị một từ điển

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

Có rất nhiều hành động được xác định, nhưng chỉ có một loại, loại mặc định , argparse.identity.

Mã này xác định từ khóa '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()không được ghi lại, nhưng cũng không bị ẩn. Đối với hầu hết các phần, lập trình viên không cần biết về nó bởi vìtype và actionlấy các giá trị hàm và lớp. Có rất nhiều ví dụ stackoverflow về việc xác định giá trị tùy chỉnh cho cả hai.

Trong trường hợp không rõ ràng từ các cuộc thảo luận trước đó, bool() không có nghĩa là 'phân tích một chuỗi'. Từ tài liệu Python:

bool (x): Chuyển đổi một giá trị thành Boolean, sử dụng quy trình kiểm tra sự thật tiêu chuẩn.

Tương phản điều này với

int (x): Chuyển đổi một số hoặc chuỗi x thành một số nguyên.

Tôi đã tìm kiếm cùng một vấn đề, và imho giải pháp khá là:

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

và sử dụng điều đó để phân tích chuỗi thành boolean như đề xuất ở trên.

Một cách khá giống nhau là sử dụng:

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

và nếu bạn đặt đối số - tính năng trong lệnh của bạn

 command --feature

đối số sẽ là True, nếu bạn không đặt loại - hãy đảm bảo mặc định đối số luôn là Sai!

Ngoài những gì @mgilson nói, cần lưu ý rằng cũng có một ArgumentParser.add_mutually_exclusive_group(required=False)phương pháp sẽ khiến việc thực thi điều đó trở nên tầm thường --flagvà --no-flagkhông được sử dụng cùng một lúc.

Điều này hoạt động cho tất cả mọi thứ tôi mong đợi nó:

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

Mật mã:

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

Một cách đơn giản hơn sẽ được sử dụng như dưới đây.

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

Đơn giản nhất. Nó không linh hoạt, nhưng tôi thích sự đơn giản.

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

EDIT: Nếu bạn không tin tưởng đầu vào, đừng sử dụng eval.

Cách đơn giản nhất là sử dụng các lựa chọn :

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

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

Không vượt qua --my-flag đánh giá thành Sai. Các yêu cầu = True tùy chọn có thể được thêm vào nếu bạn luôn muốn người sử dụng để xác định một cách rõ ràng sự lựa chọn.

Tôi nghĩ rằng cách kinh điển nhất sẽ là:

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)

Cách đơn giản và đúng đắn nhất là

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

Xin lưu ý rằng các giá trị True là y, yes, t, true, on và 1; giá trị sai là n, không, f, false, off và 0. Tăng ValueError nếu val là bất cứ thứ gì khác.

Nhanh chóng và dễ dàng, nhưng chỉ cho các đối số 0 hoặc 1:

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

Đầu ra sẽ là "Sai" sau khi gọi từ thiết bị đầu cuối:

python myscript.py 0

Tương tự như @Akash nhưng đây là một cách tiếp cận khác mà tôi đã sử dụng. Nó sử dụng strhơn lambdavì trăn lambdaluôn mang đến cho tôi cảm giác xa lạ.

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

Để cải thiện câu trả lời của @Akash Desarda, bạn có thể làm

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)

Và nó hỗ trợ 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