argparse的基本使用--参数解析

简介: argparse的基本使用--参数解析

argparse



开始使用


位置参数

int positionalArguments(int argc, char *argv[])
{
    argparse::ArgumentParser program("XHCompiler.exe", "0.0.0");

    program.add_argument("square")
            .help("display the square of a given integer")
            .scan<'i', int>();

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        return 1;
    }

    auto input = program.get<int>("square");
    std::cout << (input * input) << std::endl;

    return 0;
}


控制台命令和输出

XHCompiler.exe 15
-----------------------------------------------------------------------------------------
225


可选参数

int optionalArguments(int argc, char *argv[])
{
    argparse::ArgumentParser program("XHCompiler.exe", "0.0.0");

    program.add_argument("--verbose")
            .help("increase output verbosity")
            .default_value(false)
            .implicit_value(true);

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        std::exit(1);
    }

    if (program["--verbose"] == true) {
        std::cout << "Verbosity enabled" << std::endl;
    }
}


控制台命令和输出

XHCompiler.exe --verbose
-----------------------------------------------------------------------------------------
Verbosity enabled


使用flag()函数


flag函数像上面的.default_value(false).implicit_value(true);一样,是它的简写

int optionalArguments(int argc, char *argv[])
{
    argparse::ArgumentParser program("XHCompiler.exe", "0.0.0");

    program.add_argument("--verbose")
            .help("increase output verbosity")
            .flag();

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        std::exit(1);
    }

    if (program["--verbose"] == true) {
        std::cout << "Verbosity enabled" << std::endl;
    }
}


这里不在重复结果


必选参数


在某些情况下,我们需要一些必选参数,我们只要在可选参数中增加required()来表示即可

program.add_argument("-o", "--output")
  .required()
  .help("specify the output file.");


如果我们给该参数加了默认值,即可编程非必要参数,但是实际使用的时候该参数是以默认值形式存在的

program.add_argument("-o", "--output")
  .default_value(std::string("-"))
  .required()
  .help("specify the output file.");
int requiredArguments(int argc, char *argv[])
{
    argparse::ArgumentParser program("XHCompiler.exe", "0.0.0");

    program.add_argument("--verbose")
            .help("increase output verbosity")
            .flag();

    program.add_argument("-o", "--output")
            .required()
            .help("specify the output file.");


    program.add_argument("-b", "--base")
            .default_value(std::string("-"))
            .required()
            .help("specify the base.");

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        std::exit(1);
    }

    auto output = program.get<std::string>("--output");
    std::cout << output << std::endl;
    auto base = program.get<std::string>("--base");
    std::cout << base << std::endl;
    return 0;
}

控制台命令和输出

XHCompiler.exe -o "aaa" -b "bbb"
-----------------------------------------------------------------------------------------
aaa
bbb


is_used(“–arg”)

auto explicit_verbose = program.is_used("--verbose");
std::cout << explicit_verbose << std::endl;


使用is_used(“–arg”)来判断可选参数是否被使用, 可以在上面例子中加入如下代码,则输出的时候会输出你是否使用了verbose这个参数


重复和互斥的可选参数


  • 重复的可选参数
program.add_argument("--color")
  .default_value<std::vector<std::string>>({ "orange" })
  .append()
  .help("specify the cat's fur color");

try {
  program.parse_args(argc, argv);    // Example: ./main --color red --color green --color blue
}
catch (const std::exception& err) {
  std::cerr << err.what() << std::endl;
  std::cerr << program;
  std::exit(1);
}

auto colors = program.get<std::vector<std::string>>("--color");  // {"red", "green", "blue"}
int verbosity = 0;
program.add_argument("-V", "--verbose")
  .action([&](const auto &) { ++verbosity; })
  .append()
  .default_value(false)
  .implicit_value(true)
  .nargs(0);

program.parse_args(argc, argv);    // Example: ./main -VVVV

std::cout << "verbose level: " << verbosity << std::endl;    // verbose level: 4
  • 互斥的可选参数
auto &group = program.add_mutually_exclusive_group();
group.add_argument("--first");
group.add_argument("--second");


负数参数

int negativeNumbers(int argc, char *argv[])
{
    argparse::ArgumentParser program;

    program.add_argument("integer")
            .help("Input number")
            .scan<'i', int>();

    program.add_argument("floats")
            .help("Vector of floats")
            .nargs(4)
            .scan<'g', float>();

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        std::exit(1);
    }
    auto colors = program.get<std::vector<float>>("floats");
    auto inta = program.get<int>("integer");
    std::cout << colors[0] << std::endl;
    std::cout <<inta << std::endl;
    return 0;
}


输出结果

XHCompiler.exe -2 -2.2 -3.3 -4.4 -5.5
----------------------------------------------
-2.2
-2


将位置参数和可选参数组合起来

int compareArgs(int argc, char *argv[])
{
    argparse::ArgumentParser program;

    program.add_argument("square")
            .help("display the square of a given number")
            .scan<'i', int>();

    program.add_argument("--verbose")
            .default_value(false)
            .implicit_value(true);

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        std::exit(1);
    }

    int input = program.get<int>("square");

    if (program["--verbose"] == true) {
        std::cout << "The square of " << input << " is " << (input * input) << std::endl;
    }
    else {
        std::cout << (input * input) << std::endl;
    }
    return 0;
}
E:\XHCompiler\cmake-build-debug>XHCompiler.exe 15
225

E:\XHCompiler\cmake-build-debug>XHCompiler.exe 15 --verbose
The square of 15 is 225

E:\XHCompiler\cmake-build-debug>XHCompiler.exe --verbose 15
The square of 15 is 225

打印帮助

int main(int argc, char *argv[]) {
    int ret = 0;
//    ret = positionalArguments(argc, argv);
//    ret = optionalArguments(argc, argv);
//    ret = requiredArguments(argc, argv);
//    ret = negativeNumbers(argc, argv);
//    ret = compareArgs(argc, argv);


    argparse::ArgumentParser program("main");
    program.add_argument("thing").help("Thing to use.").metavar("THING");
    program.add_argument("--member").help("The alias for the member to pass to.").metavar("ALIAS");
    program.add_argument("--verbose").default_value(false).implicit_value(true);

    program.add_description("Forward a thing to the next member.");
    program.add_epilog("Possible things include betingalw, chiz, and res.");

    program.parse_args(argc, argv);

    std::cout << program << std::endl;

    return ret;
}


输出结果

E:\XHCompiler\cmake-build-debug>XHCompiler.exe --help
Usage: main [--help] [--version] [--member ALIAS] [--verbose] THING

Forward a thing to the next member.

Positional arguments:
  THING           Thing to use.

Optional arguments:
  -h, --help      shows help message and exits
  -v, --version   prints version information and exits
  --member ALIAS  The alias for the member to pass to.
  --verbose

Possible things include betingalw, chiz, and res.


参数列表


我们可以说使用nargs(int) 来确定参数个数。也可是使用scan(‘g’,float)来确定输入和类型后续复合参数来确定

int paramsList(int argc, char *argv[])
{
    argparse::ArgumentParser program;

    program.add_argument("-i", "--input_files")
            .help("The list of input files")
            .nargs(2);

    try {
        program.parse_args(argc, argv);   // Example: ./main --input_files config.yml System.xml
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        std::exit(1);
    }

    auto files = program.get<std::vector<std::string>>("--input_files");  // {"config.yml", "System.xml"}

    for(auto file : files)
    {
        std::cout << file << " ";
    }
    std::cout << std::endl;
    return 0;
}


输出结果

E:\XHCompiler\cmake-build-debug>XHCompiler.exe --input_files "aa aa" "bb"
aa aa bb

E:\XHCompiler\cmake-build-debug>XHCompiler.exe --input_files aa bb
aa bb


复合参数

int compoundParamsList(int argc, char *argv[])
{
    argparse::ArgumentParser program;

    program.add_argument("-a")
            .default_value(false)
            .implicit_value(true);

    program.add_argument("-b")
            .default_value(false)
            .implicit_value(true);

    program.add_argument("-c")
            .nargs(2)
            .default_value(std::vector<float>{0.0f, 0.0f})
            .scan<'g', float>();

    try {
        program.parse_args(argc, argv);                  // Example: ./main -abc 1.95 2.47
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        std::exit(1);
    }

    auto a = program.get<bool>("-a");                  // true
    auto b = program.get<bool>("-b");                  // true
    auto c = program.get<std::vector<float>>("-c");    // {1.95, 2.47}
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    for(auto file : c)
    {
        std::cout << file << " ";
    }
    std::cout << std::endl;
    return 0;
}


输出结果

E:\XHCompiler\cmake-build-debug>XHCompiler.exe -abc 1.0 2.0
1
1
1 2


数值类型转换


我们在使用scan()函数的时候使用了’g’这个,这些转换有一些预定类型,如下:

Shape interpretation
‘a’ or ‘A’ 十六进制浮点数
‘e’ or ‘E’ 科学记数法(浮点数)
‘f’ or ‘F’ 固定表示法(浮点)
‘g’ or ‘G’ 一般形式(固定形式或科学形式)
‘d’ 十进制
‘i’ std::from_chars带基数的语法 == 10
‘o’ 八进制(无符号)
‘u’ 十进制(无符号)
‘x’ or ‘X’ 十六进制(无符号)


默认的-h和-v


对于默认的-h和-v如果我们需要自己的,可以使用下列函数禁用默认的参数

int defaultCommand(int argc, char *argv[])
{
    argparse::ArgumentParser program("XHCompiler.exe", "1.0"
                                     , argparse::default_arguments::none);

    program.add_argument("-h", "--help")
            .action([=](const std::string& s) {
                std::cout << program.help().str();
            })
            .default_value(false)
            .help("shows help message")
            .implicit_value(true)
            .nargs(0);
    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        std::exit(1);
    }
    return 0;
}


收集剩余参数


只需要在参数使用remaining()函数即可

int remainingParamsList(int argc, char *argv[])
{
    argparse::ArgumentParser program;

    program.add_argument("-o")
            .default_value(std::string("a.out"));

    program.add_argument("files")
            .remaining();

    program.add_argument("-m")
            .default_value(std::string("a.out"));

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        std::exit(1);
    }

    try {
        auto files = program.get<std::vector<std::string>>("files");
        std::cout << files.size() << " files provided" << std::endl;
        for (auto& file : files)
            std::cout << file << std::endl;
    } catch (std::logic_error& e) {
        std::cout << "No files provided" << std::endl;
    }
    return 0;
}


输出

E:\XHCompiler\cmake-build-debug>XHCompiler.exe aa bb ccbb ddfb
4 files provided
aa
bb
ccbb
ddfb


注意:请记住将所有可选参数放在其余参数之前。如果可选参数放在其余参数之后,它也将被视为剩余参数:


父子解析器

int parentAndChildParamsList(int argc, char *argv[])
{
    argparse::ArgumentParser program("XHCompiler.exe");

    // git add subparser
    argparse::ArgumentParser add_command("add");
    add_command.add_description("Add file contents to the index");
    add_command.add_argument("files")
            .help("Files to add content from. Fileglobs (e.g.  *.c) can be given to add all matching files.")
            .remaining();

    // git commit subparser
    argparse::ArgumentParser commit_command("commit");
    commit_command.add_description("Record changes to the repository");
    commit_command.add_argument("-a", "--all")
            .help("Tell the command to automatically stage files that have been modified and deleted.")
            .default_value(false)
            .implicit_value(true);

    commit_command.add_argument("-m", "--message")
            .help("Use the given <msg> as the commit message.");

    // git cat-file subparser
    argparse::ArgumentParser catfile_command("cat-file");
    catfile_command.add_description("Provide content or type and size information for repository objects");
    catfile_command.add_argument("-t")
            .help("Instead of the content, show the object type identified by <object>.");

    catfile_command.add_argument("-p")
            .help("Pretty-print the contents of <object> based on its type.");

    // git submodule subparser
    argparse::ArgumentParser submodule_command("submodule");
    submodule_command.add_description("Initialize, update or inspect submodules");
    argparse::ArgumentParser submodule_update_command("update");
    submodule_update_command.add_description("Update the registered submodules to match what the superproject expects");
    submodule_update_command.add_argument("--init")
            .default_value(false)
            .implicit_value(true);
    submodule_update_command.add_argument("--recursive")
            .default_value(false)
            .implicit_value(true);
    submodule_command.add_subparser(submodule_update_command);

    program.add_subparser(add_command);
    program.add_subparser(commit_command);
    program.add_subparser(catfile_command);
    program.add_subparser(submodule_command);

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        return 1;
    }
    return 0;
}


执行输出自己尝试。


  • 解析器具有is_subcommand_used(),该命令用来检查是否使用了子命令
  • 我们还可以用下列函数获取子解析器
argparse::ArgumentParser program("test");

program.add_argument("--dir");
program.at("--dir").default_value(std::string("/home/user"));

program.add_subparser(argparse::ArgumentParser{"walk"});
program.at<argparse::ArgumentParser>("walk").add_argument("depth");


解析未知参数

int unknownParamsList(int argc, char *argv[])
{
    argparse::ArgumentParser program("XHCompiler.exe");
    program.add_argument("--foo").implicit_value(true).default_value(false);
    program.add_argument("bar");

    auto unknown_args =
            program.parse_known_args({"test", "--foo", "--badger", "BAR", "spam"});

    assert(program.get<bool>("--foo") == true);
    assert(program.get<std::string>("bar") == std::string{"BAR"});
    assert((unknown_args == std::vector<std::string>{"--badger", "spam"}));
    return 0;
}


自定义前缀字符

int selfPrefixChar(int argc, char *argv[])
{
    argparse::ArgumentParser program("XHCompiler.exe");
    program.set_prefix_chars("-+/");

    program.add_argument("+f");
    program.add_argument("--bar");
    program.add_argument("/foo");

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        return 1;
    }

    if (program.is_used("+f")) {
        std::cout << "+f    : " << program.get("+f") << "\n";
    }

    if (program.is_used("--bar")) {
        std::cout << "--bar : " << program.get("--bar") << "\n";
    }

    if (program.is_used("/foo")) {
        std::cout << "/foo  : " << program.get("/foo") << "\n";
    }

    return 0;
}


自定义分配字符

int selfAssignmentChar(int argc, char *argv[])
{
    argparse::ArgumentParser program("XHCompiler.exe");
    program.set_prefix_chars("-+/");
    program.set_assign_chars("=:");

    program.add_argument("--foo");
    program.add_argument("/B");

    try {
        program.parse_args(argc, argv);
    }
    catch (const std::exception& err) {
        std::cerr << err.what() << std::endl;
        std::cerr << program;
        return 1;
    }

    if (program.is_used("--foo")) {
        std::cout << "--foo : " << program.get("--foo") << "\n";
    }

    if (program.is_used("/B")) {
        std::cout << "/B    : " << program.get("/B") << "\n";
    }
    return 0;
}


输出

E:\XHCompiler\cmake-build-debug>XHCompiler.exe /B a
/B    : a

E:\XHCompiler\cmake-build-debug>XHCompiler.exe /B=a
/B    : a

E:\XHCompiler\cmake-build-debug>XHCompiler.exe /B:a
/B    : a
目录
相关文章
|
10天前
|
安全
BOSHIDA DC电源模块的基本参数解析
BOSHIDA DC电源模块的基本参数解析
BOSHIDA  DC电源模块的基本参数解析
|
10天前
|
前端开发 Java
SpringBoot之数组,集合,日期参数的详细解析
SpringBoot之数组,集合,日期参数的详细解析
21 0
|
10天前
|
域名解析 网络协议 安全
阿里云DNS常见问题之dns sec参数找不到如何解决
阿里云DNS(Domain Name System)服务是一个高可用和可扩展的云端DNS服务,用于将域名转换为IP地址,从而让用户能够通过域名访问云端资源。以下是一些关于阿里云DNS服务的常见问题合集:
|
8天前
|
SQL 存储 NoSQL
实时计算 Flink版产品使用合集之使用ParameterTool.fromArgs(args)解析参数为null,该怎么处理
实时计算Flink版作为一种强大的流处理和批处理统一的计算框架,广泛应用于各种需要实时数据处理和分析的场景。实时计算Flink版通常结合SQL接口、DataStream API、以及与上下游数据源和存储系统的丰富连接器,提供了一套全面的解决方案,以应对各种实时计算需求。其低延迟、高吞吐、容错性强的特点,使其成为众多企业和组织实时数据处理首选的技术平台。以下是实时计算Flink版的一些典型使用合集。
23 2
|
10天前
|
分布式计算 DataWorks 调度
DataWorks操作报错合集之DataWorks配置参数在开发环境进行调度,参数解析不出来,收到了 "Table does not exist" 的错误,该怎么处理
DataWorks是阿里云提供的一站式大数据开发与治理平台,支持数据集成、数据开发、数据服务、数据质量管理、数据安全管理等全流程数据处理。在使用DataWorks过程中,可能会遇到各种操作报错。以下是一些常见的报错情况及其可能的原因和解决方法。
29 0
|
10天前
|
分布式计算 大数据 数据处理
MaxCompute操作报错合集之在开发环境中配置MaxCompute参数进行调度,但参数解析不出来,如何解决
MaxCompute是阿里云提供的大规模离线数据处理服务,用于大数据分析、挖掘和报表生成等场景。在使用MaxCompute进行数据处理时,可能会遇到各种操作报错。以下是一些常见的MaxCompute操作报错及其可能的原因与解决措施的合集。
|
10天前
|
存储 开发者 Python
Python中的argparse模块:命令行参数解析的利器
Python中的argparse模块:命令行参数解析的利器
18 2
|
10天前
|
JSON 前端开发 Java
SpringBoot之JSON参数,路径参数的详细解析
SpringBoot之JSON参数,路径参数的详细解析
18 0
|
10天前
|
前端开发 Java
SpringBoot之实体参数的详细解析
SpringBoot之实体参数的详细解析
16 0
|
10天前
|
数据安全/隐私保护 C++
C++ 类方法解析:内外定义、参数、访问控制与静态方法详解
C++ 中的类方法(成员函数)分为类内定义和类外定义,用于操作类数据。类内定义直接在类中声明和定义,而类外定义则先在类中声明,再外部定义。方法可以有参数,访问权限可通过 public、private 和 protected 控制。静态方法与类关联,不依赖对象实例,直接用类名调用。了解这些概念有助于面向对象编程。
16 0

推荐镜像

更多