如何约束使用 argparse 解析的值（例如，将整数限制为正值）？

Question

到目前为止我有这个代码：

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-g", "--games", type=int, default=162,
                    help="The number of games to simulate")
args = parser.parse_args()

为游戏数量提供负值是没有意义的，但

type=int

允许任何整数。例如，如果我运行

python simulate_many.py -g -2

，

args.games

将被设置为

-2

，程序将继续运行，就好像没有任何问题一样。

我意识到我可以在解析参数后显式检查

args.games

的值。但是我可以让

argparse

本身检查这个条件吗？怎么办？

我希望它以这种方式工作，以便自动使用消息可以向用户解释需求。理想情况下，输出看起来像这样：

python simulate_many.py -g -2
usage: simulate_many.py [-h] [-g GAMES] [-d] [-l LEAGUE]
simulate_many.py: error: argument -g/--games: invalid positive int value: '-2'

就像它当前处理无法转换为整数的参数一样：

python simulate_many.py -g a
usage: simulate_many.py [-h] [-g GAMES] [-d] [-l LEAGUE]
simulate_many.py: error: argument -g/--games: invalid int value: 'a'

Answer 1

这应该可以利用

type

实现。您仍然需要定义一个实际的方法来为您决定这一点：

def check_positive(value):
    ivalue = int(value)
    if ivalue <= 0:
        raise argparse.ArgumentTypeError("%s is an invalid positive int value" % value)
    return ivalue

parser = argparse.ArgumentParser(...)
parser.add_argument('foo', type=check_positive)

这基本上只是

perfect_square

上的 docs 中的

argparse

函数的改编示例。

Answer 2

type

将是处理条件/检查的推荐选项，如 Yuushi 的回答所示。

在您的具体情况下，如果您的上限也已知，您还可以使用

choices

参数：

parser.add_argument('foo', type=int, choices=xrange(5, 10))

注意： 对于 python 3.x，请使用

range

而不是

xrange

Answer 3

如果您的参数有可预测的最大值和最小值，则快速而肮脏的方法是使用

choices

和范围

parser.add_argument('foo', type=int, choices=xrange(0, 1000))

Answer 4

如果有人（像我一样）在 Google 搜索中遇到这个问题，这里有一个示例，说明如何使用模块化方法来巧妙地解决允许 argparse 整数仅在指定范围内的更普遍的问题：

# Custom argparse type representing a bounded int
class IntRange:

    def __init__(self, imin=None, imax=None):
        self.imin = imin
        self.imax = imax

    def __call__(self, arg):
        try:
            value = int(arg)
        except ValueError:
            raise self.exception()
        if (self.imin is not None and value < self.imin) or (self.imax is not None and value > self.imax):
            raise self.exception()
        return value

    def exception(self):
        if self.imin is not None and self.imax is not None:
            return argparse.ArgumentTypeError(f"Must be an integer in the range [{self.imin}, {self.imax}]")
        elif self.imin is not None:
            return argparse.ArgumentTypeError(f"Must be an integer >= {self.imin}")
        elif self.imax is not None:
            return argparse.ArgumentTypeError(f"Must be an integer <= {self.imax}")
        else:
            return argparse.ArgumentTypeError("Must be an integer")

这允许您执行以下操作：

parser = argparse.ArgumentParser(...)
parser.add_argument('foo', type=IntRange(1))     # Must have foo >= 1
parser.add_argument('bar', type=IntRange(1, 7))  # Must have 1 <= bar <= 7

变量

foo

现在只允许正整数，就像OP所要求的那样。

请注意，除了上述形式之外，还可以使用

IntRange

：

只取最大值

parser.add_argument('other', type=IntRange(imax=10))  # Must have other <= 10

Answer 5

根据 Yuushi 的回答，您还可以定义一个简单的辅助函数，可以检查各种数字类型的数字是否为正数：

def positive(numeric_type):
    def require_positive(value):
        number = numeric_type(value)
        if number <= 0:
            raise ArgumentTypeError(f"Number {value} must be positive.")
        return number

    return require_positive

辅助函数可用于注释任何数字参数类型，如下所示：

parser = argparse.ArgumentParser(...)
parser.add_argument("positive-integer", type=positive(int))
parser.add_argument("positive-float", type=positive(float))

Answer 6

一个更简单的替代方案，特别是在子类化

argparse.ArgumentParser

的情况下，是从

parse_args

方法内部启动验证。

在这样的子类中：

def parse_args(self, args=None, namespace=None):
    """Parse and validate args."""
    namespace = super().parse_args(args, namespace)
    if namespace.games <= 0:
         raise self.error('The number of games must be a positive integer.')
    return namespace

这种技术可能不如自定义可调用那么酷，但它可以完成工作。

---

关于

ArgumentParser.error(message)

：

此方法打印一条使用消息，其中包括发送到标准错误的消息，并以状态代码 2 终止程序。

---

信用：乔纳坦回答

Answer 7

荣誉Yuushi的回答：

def make_range_checker(lb, ub, varname='UNDEFINED'):
    flb, fub = float(lb), float(ub)
    def checker(val):
        val = int(val)
        assert flb <= val <= fub, (
            f'value of var {varname} out of scope: {lb} - {ub}')
        return val
    return checker

## args usage
parser.add_argument("--sleep",
                    default=5,
                    type=make_range_checker(1, 'inf', 'sleep'),
                    help="sleep time in sec, must be postive int")