补充一下其他人已经说过的话:

我通常喜欢使用'dest'参数指定变量名，然后使用'globals().update()'将这些变量放在全局命名空间中。

用法:

$ python script.py -i "Hello, World!"

代码:

...
parser.add_argument('-i', '--input', ..., dest='inputted_variable',...)
globals().update(vars(parser.parse_args()))
...
print(inputted_variable) # Prints "Hello, World!"

最简单的答案!

附注:编写argparse文档的人是愚蠢的

python代码:

import argparse
parser = argparse.ArgumentParser(description='')
parser.add_argument('--o_dct_fname',type=str)
parser.add_argument('--tp',type=str)
parser.add_argument('--new_res_set',type=int)
args = parser.parse_args()
o_dct_fname = args.o_dct_fname
tp = args.tp
new_res_set = args.new_res_set

运行代码

python produce_result.py --o_dct_fname o_dct --tp father_child --new_res_set 1

argparse文档相当不错，但遗漏了一些可能不明显的有用细节。(@Diego Navarro已经提到了一些，但我会试着稍微扩展一下他的答案。)基本用法如下:

parser = argparse.ArgumentParser()
parser.add_argument('-f', '--my-foo', default='foobar')
parser.add_argument('-b', '--bar-value', default=3.14)
args = parser.parse_args()

从parse_args()返回的对象是一个“Namespace”对象:其成员变量以命令行参数命名的对象。Namespace对象是你访问参数和与它们相关的值的方式:

args = parser.parse_args()
print (args.my_foo)
print (args.bar_value)

(请注意，argparse在命名变量时用下划线替换参数名中的'-'。)

在许多情况下，您可能希望将参数简单地用作不带值的标志。你可以像这样在argparse中添加它们:

parser.add_argument('--foo', action='store_true')
parser.add_argument('--no-foo', action='store_false')

上面的代码将分别创建值为True的变量'foo'和值为False的变量'no_foo':

if (args.foo):
    print ("foo is true")

if (args.no_foo is False):
    print ("nofoo is false")

还要注意，你可以在添加参数时使用"required"选项:

parser.add_argument('-o', '--output', required=True)

这样，如果你在命令行中忽略了这个参数，argparse会告诉你它缺失了，并停止脚本的执行。

最后，请注意，可以使用vars函数创建参数的dict结构，如果这使您的生活更容易的话。

args = parser.parse_args()
argsdict = vars(args)
print (argsdict['my_foo'])
print (argsdict['bar_value'])

如你所见，vars返回一个dict，参数名作为键，值作为值。

还有许多其他选项和可以做的事情，但这应该涵盖最基本的常见使用场景。

由于你没有澄清参数“A”和“B”是位置的还是可选的，我将两者混合。

默认情况下，位置参数是必需的。如果没有给出一个将抛出'Few arguments given'这不是可选参数的情况下，以他们的名字。默认情况下，此程序将接受一个数字并返回其方框，如果使用cube选项，则将返回其方框。

import argparse
parser = argparse.ArgumentParser('number-game')
parser.add_argument(
    "number",
    type=int,
    help="enter a number"
   )
parser.add_argument(
   "-c", "--choice",
   choices=['square','cube'],
   help="choose what you need to do with the number"
)

# all the results will be parsed by the parser and stored in args
args = parser.parse_args()

# if square is selected return the square, same for cube 
if args.c == 'square':
    print("{} is the result".format(args.number**2))
elif args.c == 'cube':
    print("{} is the result".format(args.number**3))
else:
    print("{} is not changed".format(args.number))

使用

$python3 script.py 4 -c square
16

这里的可选参数是有值的，如果你只是想把它当作一个标志来使用，你也可以。因此，通过对square使用-s，对cube使用-c，我们可以通过添加action = "store_true"来改变行为。仅在使用时才更改为true。

parser.add_argument(
    "-s", "--square",
    help="returns the square of number",
    action="store_true"
    )
parser.add_argument(
    "-c", "--cube",
    help="returns the cube of number",
    action="store_true"
    )

所以条件块可以更改为，

if args.s:
    print("{} is the result".format(args.number**2))
elif args.c:
    print("{} is the result".format(args.number**3))
else:
    print("{} is not changed".format(args.number))

使用

$python3 script.py 4 -c
64

也可以使用plac (argparse的包装器)。

作为奖励，它生成整洁的帮助说明-见下文。

示例脚本:

#!/usr/bin/env python3
def main(
    arg: ('Argument with two possible values', 'positional', None, None, ['A', 'B'])
):
    """General help for application"""
    if arg == 'A':
        print("Argument has value A")
    elif arg == 'B':
        print("Argument has value B")

if __name__ == '__main__':
    import plac
    plac.call(main)

示例输出:

没有提供参数- example.py:

usage: example.py [-h] {A,B}
example.py: error: the following arguments are required: arg

提供了意外的参数- example.py

usage: example.py [-h] {A,B}
example.py: error: argument arg: invalid choice: 'C' (choose from 'A', 'B')

提供正确的参数- example.py

Argument has value A

完整帮助菜单(自动生成)- example.py -h:

usage: example.py [-h] {A,B}

General help for application

positional arguments:
  {A,B}       Argument with two possible values

optional arguments:
  -h, --help  show this help message and exit

简短说明:

实参的名称通常等于形参名称(arg)。

arg参数后的元组注释的含义如下:

描述(有两个可能值的参数) 参数类型- 'flag'， 'option'或'positional' (positional)之一 缩写(无) 参数值的类型-例如。float, string (None) 限制选项集(['A'， 'B'])

文档:

要了解更多关于使用placa的知识，请查看它的伟大文档:

Plac:解析命令行的简单方法

作为现有答案的补充，如果你足够懒惰，可以使用称为protoargs的代码生成工具。它从配置生成参数解析器。对于python，它使用argparse。

配置可选A和B:

syntax = "proto2";
message protoargs
{
    optional string A     = 1; // A param description
    optional string B     = 2; // B param description
}//protoargs

配置所需的A和B:

syntax = "proto2";
message protoargs
{
    required string A     = 1; // A param description
    required string B     = 2; // B param description
}//protoargs

位置A和B的构型:

syntax = "proto2";
message protoargs
{
    required string A     = 1; // A param description
    required string B     = 2; // B param description
}//protoargs
message protoargs_links
{
}//protoargs_links

现在你要做的就是:

python ./protoargs.py -i test.proto -o . --py

并使用它(这里可以举其他例子):

import sys
import test_pa

class ArgsParser:
    program = "test"
    description = "Simple A and B parser test."

    def parse(self, argv):
        self.config = test_pa.parse(self.program, self.description, argv)

    def usage(self):
        return test_pa.usage(self.program, self.description)

if __name__ == "__main__":
    parser = ArgsParser()

    if len(sys.argv) == 1:
        print(parser.usage())
    else:
        parser.parse(sys.argv[1:])

        if parser.config.A:
            print(parser.config.A)

        if parser.config.B:
            print(parser.config.B)

如果你想要更多的改变配置，重新生成解析器，使用更新的parser.config。

UPD:正如规则中提到的，我必须指定这是我自己的项目