Python命令行参数的解析

【Python进阶】argparse库基础用法全总结：高效脚本参数解析 | 参数类型使用代码

argparse库是 Python 标准库中用于解析命令行参数和选项的模块。它使得编写命令行界面（CLI）变得更加容易。，在深度学习中用到的比较多~~

我们运行Python文件往往是直接输入命令

python test.py

但是如果我们想给Python文件脚本运行时候传入参数，像是下面这种

python test.py 123 456 -config

该怎么做呢？就是要用到argparse库~

将argparse库的基础用法总结如下

---

 

文章目录

• 1 参数的基本类型
• 2 用法
• • 2.1 创建参数总容器
  • 2.2 添加参数
  • • 2.3.1 name 添加参数名称
    • 2.3.2 type 解析类型
    • 2.3.3 参数默认值
    • 2.3.4 参数是否必须设置
    • 2.3.5 参数提示信息
    • 2.3.6 参数动作
    • 2.3.7 参数可选值列表
    • 2.3.8 参数个数
  • 2.3 解析命令行参数
  • 2.4 使用参数
• 3 完整代码

 

1 参数的基本类型

在命令行运行 Python 文件时，可以向文件传递不同类型的参数。主要有以下几种类型的参数：

1. 位置参数（Positional arguments）：位置参数是指在命令行中按照特定顺序传递给程序的参数，它们不带任何前缀。例如，在命令行中运行 python script.py arg1 arg2，arg1 和 arg2 就是位置参数。

2. 选项参数（Optional arguments）：选项参数是可选的参数，它们通常以短横线（-）或双短横线（--）开头。选项参数可以有一个或多个值。例如，-h 或 --help 是常见的用于显示帮助信息的选项参数。

3. 标志参数（Flag arguments）：标志参数是一种特殊的选项参数，它们不带值，只用于表示某个状态或开关是否打开。通常以短横线和单个字符表示，例如 -v 表示 verbose 模式。

4. 环境变量参数（Environment variable arguments）：有时候，程序可能会从环境变量中读取参数值。这种方式不需要在命令行中显式传递参数，而是通过预先设置的环境变量来传递参数信息。

这些参数可以混合使用，例如 python script.py arg1 -v --output result.txt，其中 arg1 是位置参数，-v 是标志参数，--output result.txt 是选项参数，表示输出到 result.txt 文件中。

2 用法

2.1 创建参数总容器

import argparse
parser=argparse.ArgumentParser()

用ArgumentParser类实例化即可创建一个总的容器类parser

之后我们添加参数就是往这个parser里面添加

2.2 添加参数

parser.add_argument('num1', type=int, help='The first number')
parser.add_argument('num2', type=int, help='The second number')

 

调用add_argument函数做参数的的添加

add_argument 方法是 argparse.ArgumentParser 类的一个方法，用于向解析器添加一个新的参数。add_argument 方法有很多参数

2.3.1 name 添加参数名称

• name or flags：参数的名称或者选项标志，可以是一个字符串（位置参数）或者一个列表（选项参数）。例如，'--output' 表示一个长选项，'-o', '--output' 表示一个短选项和一个长选项。

2.3.2 type 解析类型

• type：参数的类型，用于指定参数的值应该被解析成什么类型。例如，int 表示整数，float 表示浮点数，默认的话是字符型，这时候如果我们期望做数值运算，肯定得转换为整形或浮点型

2.3.3 参数默认值

• default：参数的默认值，如果用户没有提供该参数，则使用默认值。默认值可以是任何合法的 Python 值。

2.3.4 参数是否必须设置

• required：指定参数是否是必需的，默认为 False。如果设置为 True，则用户必须提供该参数，否则会显示错误信息。

2.3.5 参数提示信息

• help：参数的帮助信息，用于描述参数的作用和用法。当用户使用 -h 或 --help 选项时，会显示帮助信息。

2.3.6 参数动作

• action：参数的动作，指定参数应该如何处理。常用的值包括 store（存储参数值）、store_true（如果存在该参数则存储 True，否则存储 False）、store_false（如果存在该参数则存储 False，否则存储 True）等。

action 参数用于指定参数在解析时应该如何处理。它定义了当参数在命令行中出现时应该采取的动作。下面是一些常见的 action 参数值及其含义：

​ store：默认行为，将参数的值存储起来。如果不指定 action，则默认为 store。

​ store_const：将一个常量值存储到参数中。通常与 const 参数一起使用。例如：

parser.add_argument('--verbose', action='store_const', const=True)

 

这会将 --verbose 参数的值设置为 True。

​ store_true：将参数的值设置为 True。通常用于标记某个选项是否存在。例如：

parser.add_argument('--verbose', action='store_true')

 

如果用户在命令行中使用了 --verbose，则参数的值为 True，否则为 False。

​ store_false：将参数的值设置为 False。与 store_true 类似，用于标记某个选项是否不存在。

​ append：将参数值追加到列表中。通常与 nargs='+' 一起使用，表示参数可以接受多个值，这些值将被追加到一个列表中。

​ append_const：将一个常量值追加到列表中。通常与 const 参数一起使用。

​ count：统计参数出现的次数。用于统计某个选项在命令行中出现的次数。

​ help：显示帮助信息并退出。

2.3.7 参数可选值列表

• choices：参数的可选值列表，用户只能从列表中选择一个值作为参数的值。如果用户提供的值不在列表中，则会显示错误信息。

通过使用 add_argument 方法，可以灵活地定义各种不同类型的参数，并在命令行中解析这些参数，从而实现更加复杂的命令行界面。

2.3.8 参数个数

• nargs 参数用于指定一个参数应该接受的命令行参数数量。它可以取以下几种值：

  • N：表示参数应该接受 N 个命令行参数。

  • ?：表示参数可以接受零个或一个命令行参数。如果没有提供命令行参数，则该参数的值为 None。

  • *：表示参数可以接受零个或多个命令行参数。命令行参数会被收集到一个列表中。

  • +：表示参数可以接受一个或多个命令行参数。命令行参数会被收集到一个列表中。

例如，对于一个参数定义如下：

parser.add_argument('--inputs', nargs='+')

 

这表示 --inputs 参数可以接受一个或多个命令行参数，这些参数会被收集到一个列表中。

另一个例子是：

parser.add_argument('--output', nargs='?', const='default.txt')

 

这表示 --output 参数可以接受零个或一个命令行参数。如果用户没有提供命令行参数，则参数的值将为 'default.txt'。

2.3 解析命令行参数

添加好后，我们进行解析

args = parser.parse_args()
#解析命令行参数

 

2.4 使用参数

解析好后，我们就可以

直接通过.来使用了

sum = args.num1 + args.num2
print(f'The sum of {args.num1} and {args.num2} is {sum}')

 

3 完整代码

import argparse

# 创建 ArgumentParser 对象
parser = argparse.ArgumentParser(description='Add two numbers')

# 添加两个参数
parser.add_argument('num1', type=int, help='The first number')
parser.add_argument('num2', type=int, help='The second number')

# 解析命令行参数
args = parser.parse_args()

# 计算和并输出结果
sum = args.num1 + args.num2
print(f'The sum of {args.num1} and {args.num2} is {sum}')

 

运行

python test.py 5 3

 

2024-07-18 16:28:56【出处】：https://blog.csdn.net/Q52099999/article/details/137028697

=======================================================================================

Python 进阶（十九）：解析命令行参数（argparse 模块）

大家好，我是水滴~~

当处理命令行参数时，Python 的 argparse 模块是一个强大而灵活的工具。它提供了一个简单且一致的方式来定义命令行参数、选项和子命令，并帮助你解析和验证用户提供的输入。本教程将详细介绍 argparse 模块的使用方法和常见用例。

文章中包含大量的示例代码，希望能够帮助新手同学快速入门。

本文收录于《Python入门核心技术》专栏，专栏总目录：点这里，订阅后可阅读专栏内所有文章。

 

文章目录

• 前言
• 一、使用 argparse 模块
• • 1.1 引入 argparse 模块
  • 1.2 创建参数解析器
  • 1.3 添加命令行参数
  • 1.4 解析命令行参数
  • 1.5 获取参数值
• 二、各类参数实例
• • 2.1 添加位置参数
  • 2.2 添加可选参数
  • 2.3 添加行为参数
  • 2.4 添加短参数
• 三、查看帮助信息
• 总结

 

---

前言

在开发命令行工具或需要从命令行接收用户输入的 Python 程序中，处理命令行参数是一项常见任务。为了简化这一过程，Python 提供了 argparse 模块，它能够帮助我们定义和解析命令行参数，并提供用户友好的命令行界面。本教程将详细介绍 argparse 模块的使用方法和常见用例，帮助你轻松处理命令行参数，提升程序的灵活性和易用性。

一、使用 argparse 模块

1.1 引入 argparse 模块

由于argparse 模块是 Python 标准库中自带的模块，所以不需要安装，使用导入即可。

下面代码使用 import 来导入 argparse 模块：

import argparse

 

1.2 创建参数解析器

在开始定义命令行参数之前，我们需要创建一个参数解析器对象。可以使用 ArgumentParser 类创建解析器。

如下代码：

parser = argparse.ArgumentParser(description='这是一个命令行参数示例')

 

上面代码创建了一个新的 ArgumentParser 参数解析器对象，为其名为 parser ，并传递了一个可选的 description参数，用于描述你的程序或命令行工具的功能。

ArgumentParser 类还有很多可选的参数供我们使用，下面列出这些参数以及功能描述：

• prog - 程序的名称 (默认值: os.path.basename(sys.argv[0]))
• usage - 描述程序用途的字符串（默认值：从添加到解析器的参数生成）
• description - 要在参数帮助信息之前显示的文本（默认：无文本）
• epilog - 要在参数帮助信息之后显示的文本（默认：无文本）
• parents - 一个 ArgumentParser 对象的列表，它们的参数也应包含在内
• formatter_class - 用于自定义帮助文档输出格式的类
• prefix_chars - 可选参数的前缀字符集合（默认值： ‘-’）
• fromfile_prefix_chars - 当需要从文件中读取其他参数时，用于标识文件名的前缀字符集合（默认值： None）
• argument_default - 参数的全局默认值（默认值： None）
• conflict_handler - 解决冲突选项的策略（通常是不必要的）
• add_help - 为解析器添加一个 -h/--help 选项（默认值： True）
• allow_abbrev - 如果缩写是无歧义的，则允许缩写长选项 （默认值：True）
• exit_on_error - 决定当错误发生时是否让 ArgumentParser 附带错误信息退出。 (默认值: True)

1.3 添加命令行参数

创建好参数解析器对象后，就可以使用 add_argument()方法来添加参数了。参数分好几种，在第二章我们详细介绍。

如下代码：

parser.add_argument('--arg1', type=str, help='参数1')
parser.add_argument('arg2', type=int, help='参数2')

 

上面代码中添加了两个参数：arg1 和 arg2，并使用 type 参数指定数据类型，使用 help 参数添加该选项的功能描述。

add_argument()方法还有很多可选的参数供我们使用，下面列出这些参数以及功能描述：

• name or flags - 一个命名或者一个选项字符串的列表，例如 foo 或 -f, --foo。
• action - 当参数在命令行中出现时使用的动作基本类型，例如 store_true。
• nargs - 命令行参数应当消耗的数目。
• const - 被一些 action 和 nargs 选择所需求的常数。
• default - 当参数未在命令行中出现并且也不存在于命名空间对象时所产生的值。
• type - 命令行参数应当被转换成的类型。
• choices - 由允许作为参数的值组成的序列。
• required - 此命令行选项是否可省略 （仅选项可用）。
• help - 一个此选项作用的简单描述。
• metavar - 在使用方法消息中使用的参数值示例。
• dest - 被添加到 parse_args() 所返回对象上的属性名。

1.4 解析命令行参数

定义完命令行参数后，我们需要解析用户提供的命令行输入。使用 parse_args() 方法解析命令行参数：

args = parser.parse_args()

 

parse_args() 方法会解析命令行参数并返回一个 args 对象，其中包含了我们定义的参数的值。

1.5 获取参数值

通过 args 对象，我们可以获取用户提供的命令行参数的值，并在程序中进行相应的处理：

arg1_value = args.arg1
arg2_value = args.arg2

 

在上面的示例中，我们通过 args.arg1 和 args.arg2来获取对应参数的值。

二、各类参数实例

在使用过程中，添加命令行参数的过程是多变的，下面我们通过一些实例来演示不同各类的参数的添加方法。

2.1 添加位置参数

位置参数是必需的参数，它们没有前缀，直接跟在命令行中的位置上。使用 add_argument() 方法添加位置参数。

创建一个 argparse_test.py Python程序，其如下代码：

import argparse

# 1.创建参数解析器
parser = argparse.ArgumentParser(description='这是一个解析命令行参数示例')

# 2.添加位置参数（positional arguments）
parser.add_argument('arg1', type=int, help='位置参数1')
parser.add_argument('arg2', type=str, help='位置参数2')

# 3.解析命令行参数
args = parser.parse_args()

# 4.获取并打印参数值
print(args)
print(args.arg1)
print(args.arg2)

 

add_argument() 方法接受一些参数，其中最重要的是参数的名称、类型和帮助信息。在上面的示例中，我们定义了两个位置参数 arg1 和 arg2，一个是整数类型，一个是字符串类型，并提供了相应的帮助信息。

使用时，在命令行中 python .\argparse_test.py 10 ABC，其中 10 和 ABC 为位置参数。

$ python .\argparse_test.py 10 ABC
Namespace(arg1=10, arg2='ABC')
10
ABC

 

位置参数是必填的，否则会报错：

$ python .\argparse_test.py 10
usage: argparse_test.py [-h] arg1 arg2
argparse_test.py: error: the following arguments are required: arg2

 

2.2 添加可选参数

可选参数不是必需的，它们通常以双破折线 -- 作为前缀。使用 add_argument() 方法添加可选参数，还可以指定其默认值。

如下代码：

import argparse

# 1.创建参数解析器
parser = argparse.ArgumentParser(description='这是一个解析命令行参数示例')

# 2.添加位置参数（positional arguments）
parser.add_argument('--option1', type=str, help='可选参数1')
parser.add_argument('--option2', type=str, help='可选参数2', default='a')
parser.add_argument('--option3', type=str, help='可选参数3', default='a')

# 3.解析命令行参数
args = parser.parse_args()

# 4.获取并打印参数值
print(args)
print(args.option1)
print(args.option2)
print(args.option3)

 

在可选参数的定义中，我们使用了 --option1、--option2和 --option3 作为参数名，并提供了相应的帮助信息，还设置了它们的数据类型，--option2 和 --option3 还设置了默认值。

使用时，在命令行中输入 python .\argparse_test.py --option3=ABC，只为 --option3 指定了值 ABC，输出如下：

$ python .\argparse_test.py --option3=ABC  
Namespace(option1=None, option2='a', option3='ABC')
None
a
ABC

 

可以看出，option1 没有默认值，也没有输入值，其值为 None；option2 值为默认值 a；option3 值为输入值 ABC。

2.3 添加行为参数

行为参数是一种特殊的可选参数，它只有两个值 True 和 False，用于标记使用。只需要在 add_argument() 方法中添加 action 参数，并将值设为 store_true 即可。

如下代码：

import argparse

# 1.创建参数解析器
parser = argparse.ArgumentParser(description='这是一个解析命令行参数示例')

# 2.添加行为参数（action arguments）
parser.add_argument('--action1', action='store_true', help='行为参数1')
parser.add_argument('--action2', action='store_true', help='行为参数2')

# 3.解析命令行参数
args = parser.parse_args()

# 4.获取并打印参数值
print(args)
print(args.action1)
print(args.action2)

 

上面代码添加了两个行为参数：--action1 和 --action2，都为它们指定了 action 参数值为 store_true。

使用时，在命令行中输入 python .\argparse_test.py --action1，输入时无需指定参数的值，这里只指定了 --action1，输出如下：

$ python .\argparse_test.py --action1    
Namespace(action1=True, action2=False)
True
False

 

从输出结果可以看出，指定了的 --action1 值为 True，未指定的 --action2 值为 False。

2.4 添加短参数

还可以添加短参数，使用一个-指定短参数，例如 '-f'。短参数可以独立使用，但我们通常和长参数共同使用：'-f', '--foo'。

如下代码：

import argparse

# 1.创建参数解析器
parser = argparse.ArgumentParser(description='这是一个解析命令行参数示例')

# 2.添加短参数
parser.add_argument('-f', '--foo', type=str, help='短参数')

# 3.解析命令行参数
args = parser.parse_args()

# 4.获取并打印参数值
print(args)
print(args.foo)

 

这里需要说明一下，如果短参数和长参数同时指定，参数名为长参数的名字。

在使用时，可以通过 -f=ABC 和 --foo=ABC 两个方式指定参数值：

$ python .\argparse_test.py -f=ABC
Namespace(foo='ABC')
ABC

$ python .\argparse_test.py --foo=ABC
Namespace(foo='ABC')
ABC

 

三、查看帮助信息

可以使用 -h或--help来查看我们添加的参数信息。

下面是完整代码：

import argparse

# 1.创建参数解析器
parser = argparse.ArgumentParser(description='这是一个解析命令行参数示例')

# 2.添加位置参数（positional arguments）
parser.add_argument('arg1', type=int, help='位置参数1')
parser.add_argument('arg2', type=str, help='位置参数2')

# 2.添加可选参数（options arguments）
parser.add_argument('--option1', type=str, help='可选参数1')
parser.add_argument('--option2', type=str, help='可选参数2', default='a')
parser.add_argument('--option3', type=str, help='可选参数3', default='a')

# 2.添加行为参数（action arguments）
parser.add_argument('--action1', action='store_true', help='行为参数1')
parser.add_argument('--action2', action='store_true', help='行为参数2')

# 2.添加短参数
parser.add_argument('-f', '--foo', type=str, help='短参数')

# 3.解析命令行参数
args = parser.parse_args()

# 4.获取并打印参数值
print(args)

 

查看帮助信息：

$ python .\argparse_test.py --help
usage: argparse_test.py [-h] [--option1 OPTION1] [--option2 OPTION2] [--option3 OPTION3] [--action1] [--action2] [-f FOO] arg1 arg2

这是一个解析命令行参数示例

positional arguments:
  arg1               位置参数1
  arg2               位置参数2

options:
  -h, --help         show this help message and exit
  --option1 OPTION1  可选参数1
  --option2 OPTION2  可选参数2
  --option3 OPTION3  可选参数3
  --action1          行为参数1
  --action2          行为参数2
  -f FOO, --foo FOO  短参数

 

可以看出，帮助信息将我们添加的参数信息都输出了。

总结

argparse 模块是 Python 的一个标准库模块，用于处理命令行参数。通过 argparse，我们可以定义位置参数和可选参数，并指定它们的类型、帮助信息以及其他选项。模块还提供了命令行帮助信息的自动生成功能，能够帮助用户理解和正确使用程序。在本教程中，我们学习了如何使用 argparse 模块的基本功能，包括创建参数解析器、添加位置参数和可选参数、解析命令行参数以及获取参数值。我们还演示了一个完整的示例，并给出了一些常见的命令行命令和输出。通过掌握 argparse 模块，你可以更有效地处理命令行参数，提升程序的交互性和易用性，为用户提供更好的体验。祝你在开发命令行工具或处理命令行参数时取得成功！

 

2024-07-18 16:29:10【出处】：https://blog.csdn.net/weixin_67276852/article/details/138581109

=======================================================================================

argparse --- 用于命令行选项、参数和子命令的解析器

https://docs.python.org/zh-cn/3.12/library/argparse.html

=======================================================================================

通常，我们运行 Python 项目或者脚本采用直接执行脚本的方式，但是 Python 作为一个脚本语言，在 Linux 中经常会结合 Shell 脚本使用，这个时候执行的 Python 脚本多半需要使用命令行参数传入一些变量，以更加灵活、动态地传递一些数据。

例如，运行命令：

python argv.py 1 2 3

其中1 2 3就是传递给 argv.py 的命令行参数，也就是说命令行参数是调用某个程序时除程序名外的其他参数。

命令行参数工具是常用的工具，它给使用者提供了友好的交互体验。

例如，当我们需要经常调节参数的时候，如果参数都是通过硬编码写在程序中的话，我们每次修改参数都需要修改对应的代码和逻辑，这显然不太方便。比较好的方法是把必要的待修改的参数设置成通过命令行参数传入的形式，这样我们只需要在运行的时候修改参数即可。因此，在使用 Python 开发脚本，并需要接受用户参数运行时，我们可以使用命令行传参的方式。

Python 命令行参数解析库

Python 的命令行参数解析模块主要分为两类，一种是 Python 内置的模块，主要包括 sys.argv、argparse 和 getopt，另一种是第三方模块，比较有名的是 click 模块，如图1所示。

图1：Python 命令行参数解析模块

下面我们将简要阐述对比各模块，如表1所示，然后简单解释解析命令行参数的原理，方便大家进一步理解。

表1：命令行参数解析模块

模块	描述
sys.argv	sys.argv 模块传入参数的方式比较简单，功能也比较少，该模块比较适合参数数量很少且固定的脚本。
argparse	argparse 模块可以让开发人员轻松地编写用户友好的命令行接口，argparse 模块会自动生成帮助和使用手册，并在用户给程序传入无效参数时报出错误信息。
getopt	getopt 模块相比 sys.argv 模块，支持长参数和短参数，以及对参数解析赋值，有很多的高级用法，因此掌握 getopt 模块相对复杂，学习成本高。
click	click 模块相比其他模块的优势就是支持多个命令的嵌套和组合，可以快速构建命令行程序，但是在扩展性上就没有 argparse 模块好，需要额外安装除 click 模块以外的第三方模块。

argparse模块的使用

本文将着重讲解如何使用 argparse 模块进行命令行参数解析，argparse 模块是 Python 自带的命令行参数解析模块。在程序中定义我们需要的参数，argparse 模块会从 sys.argv 模块解析出这些参数。

使用 argparse 模块的步骤如下：

• 构建一个参数实例，生成一个命令行参数的对象。
• 给对象添加一些参数。
• 从属性中提取传入的参数并使用。

1) 创建一个解析器

通过 argparse 模块中的 ArgumentParser() 方法创建一个 ArgumentParser 对象，ArgumentParser 对象包含将命令行解析成 Python 数据类型所需的全部信息。示例如下：

parse = argparse.ArgumentParser(prog='argument.py',description='编写命令行的示例文件')

ArgumentParser() 方法其他参数如表2所示其中大部分参数不常用到。

表2：ArgumentParser() 方法的参数

参数	描述
prog	程序名，默认为 sys.argv[0]。
usage	描述程序用途的字符串，默认值从添加到解析器的参数生成。
description	在参数帮助文档之前显示的文本。
parents	一个 ArgumentParser 对象的列表，它们的参数应包含在内。
formatter_class	用于自定义帮助文档输出格式的类。
prefix_chars	可选参数的前缀字符集合，默认为-。
fromfile_prefix_chars	当需要从文件中读取其他参数时，用于标识文件名的前缀字符集合。
argument_default	参数的全局默认值。
conflict_handler	解决冲突选项的策略（通常不必要）。
add_help	为解析器添加一个-h/--help选项，默认为 True。
allow_abbrev	如果缩写是无歧义的，则允许缩写长选项，默认为 True。

2) 添加参数

给 ArgumentParser 对象添加参数是通过调用 add_argument() 方法完成的。示例如下：

复制纯文本复制

• parser.add_argument('name',type=str,help='名字') # 添加位置参数（必选）
• parser.add_argument('age',type=int,help='年龄') # 添加位置参数（必选）
• parser.add_argument('-s',dest='--sex',type=str,help='性别') # 添加可选参数

parser.add_argument('name',type=str,help='名字') # 添加位置参数（必选）
parser.add_argument('age',type=int,help='年龄') # 添加位置参数（必选）
parser.add_argument('-s',dest='--sex',type=str,help='性别') # 添加可选参数

其中，add_argument() 方法更多的可选参数如表3所示。

表3：add_argument() 方法的参数

参数	描述
name or flags	选项字符串的名字或者列表，如 foo、-f 或 --foo。
action	在命令行使用该参数时采取的基本动作类型。
nargs	应该读取的命令行参数数量。
const	某些 action 和 nargs 要求的常数值。
default	如果命令行中没有出现该参数时，该参数的默认值。
type	命令行参数应该转换的类型。
choices	参数可允许的值的容器。
required	表示该命令行参数是否可以省略（只针对可选参数）。
help	参数的简短描述。
metavar	参数在帮助信息中的名称。
dest	给 parse_args() 返回的对象要添加的属性名称。

此处，我们重点讲解下必选参数、可选参数、默认值、参数类型、可选值、参数数量、参数传递等几个常用功能的设置方法。

① 必选参数

它的定义和函数中的必填参数是一样的，即运行程序必须要的参数。如果不传入，那么程序会报错并提示。

定义必选参数的方法非常简单，我们只需要通过 add_argument() 方法传入参数的名称即可。示例如下：

parser.add_argument('param')

这样就定义了一个名为 param 的参数，我们可以通过 args.param 来访问它。假设需要运行的程序名称为 test.py，那么我们直接执行以下命令即可：

python test.py xxx

其中必选参数直接传入，不需要加上前缀。

② 可选参数

有必选参数当然就有可选参数，可选参数因为可选可不选，所以我们在使用的时候需要在参数前加上标识-或--。

例如，我们的参数名为 param，可以定义成 -param 或者 --param，这两种方式都可以使用，也可以同时使用两种方式。示例如下：

parser.add_argument('-param', '--param')

如果要给这个可选参数一个解释或提示，方便其他人理解这个参数，那么我们可以加 help，示例如下：

parser.add_argument('-param', '--param', help='this is a param of name')

③ 默认值

如果参数很多，我们可能不希望每一个都指定一个值，而是希望可以在不指定值的时候有一个默认值。我们可以通过 default 参数实现这个需求。示例如下：

parser.add_argument('-param', '--param', default=3, help='this is a param of num')

④ 参数类型

我们可以定义参数的默认值，也可以定义它的类型。因为命令行传入的参数默认都是字符串类型，如果我们要进行数学计算，使用字符串类型还需要先转换，这很不方便。我们可以在传入参数的时候就完成类型的匹配，这样传入参数的类型不对将直接报错，不继续运行程序。

我们可以通过 type 参数实现这个需求。示例如下：

parser.add_argument('-param', '--param', default=3,type=int, help='this is a param of num')

⑤ 可选值

可选值很好理解，就是我们希望限制传入参数的范围仅在几个值当中。例如，我们希望传入的值不是 0 就是 1，或者是在某几个具体的值当中，那么可以通过 choices 参数实现这个需求。

choices 参数传入的是一个列表，也就是我们的限制范围。示例如下：

parser.add_argument('-param', '--param', default=3, choices=[2,3,4], type=int, help='this is a param of num')

⑥ 参数数量

nargs 是一个非常有用的参数，可以用来说明传入的参数个数。例如，+表示传入至少1个参数；2表示必须传入2个参数，在程序运行时，这2个参数的值会以列表的形式赋给 param。

parser.add_argument('-param', '--param', nargs=2, type=int, help='this is a param of num')

⑦ 参数传递

dest 参数用于指定后面的参数传递给谁，在 dest 参数定义后的程序中，我们可以使用 dest 指定的参数名获取对应的值。示例如下：

复制纯文本复制

• parser.add_argument('-param', '--param', dest = 'port')
• args = parser.parse_args()
• server_port = args.port # 通过dest参数指定的port获取。

parser.add_argument('-param', '--param', dest = 'port')
args = parser.parse_args()
server_port = args.port # 通过dest参数指定的port获取。

3) 解析参数

通过 parse_args() 方法将参数字符串转换为对象，并将其设为命名空间的属性，返回带有成员的命名空间：

ArgumentParser.parse_args(args=None, namespace=None)

其中，args 表示要解析的字符串列表，默认值从 sys.argv 获取；namespace 用于获取属性的对象，默认值是一个新的空 Namespace 对象。

注意，可选参数的参数和参数值可以作为两个单独参数传入。对于长参数，参数和参数值可以作为单个命令行参数传入，使用=分隔它们；对于短参数，参数和参数值可以拼接在一起。

示例如下：

复制纯文本复制

• parser = argparse.ArgumentParser(prog='PROG')
• parser.add_argument('-x')
• parser.add_argument('--foo')
• parser.add_argument('bar')
• print(parser.parse_args(['--foo=FOO', '-xX', 'bar']))

parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('-x')
parser.add_argument('--foo')
parser.add_argument('bar')
print(parser.parse_args(['--foo=FOO', '-xX', 'bar']))

另外，当短参数看起来像负数时，解析器会将命令行中所有的负数参数解析为短参数。

位置参数只有在是负数并且解析器中没有任何参数看起来像负数时，才能以-开头。如果必须使用以-开头的位置参数，我们可以插入伪参数--告诉 parse_args() 在那之后的内容是位置参数。示例如下：

复制纯文本复制

• parser = argparse.ArgumentParser(prog='PROG')
• parser.add_argument('-1', dest='one')
• parser.add_argument('foo', nargs=1)
• parser.add_argument('bar', nargs=1)
• print(parser.parse_args(['-1', 'X', '--', '-2', '-3']))

parser = argparse.ArgumentParser(prog='PROG')
parser.add_argument('-1', dest='one')
parser.add_argument('foo', nargs=1)
parser.add_argument('bar', nargs=1)
print(parser.parse_args(['-1', 'X', '--', '-2', '-3']))

图2中展示的是一个综合示例，演示了一个简单登录的验证和提示语。

图2：Python 命令行参数解析综合示例

 

 

出处：https://c.biancheng.net/view/40rtyk8.html

=======================================================================================

Python之命令行参数解析

解析命令行参数模块

Python中由三个内建的模块用于处理命令行参数：
第一个：getopt，只能简单的处理命令行参数

官网资料：https://docs.python.org/2/library/getopt.html#module-getopt
第二个：optparse，功能强大，易于使用，可以方便地生成标准的、符合Unix/Posix 规范的命令行说明。（Python2.7以后弃用，不会继续发展）
官网资料：https://docs.python.org/2/library/optparse.html
第三个：argparse，使其更加容易的编写用户友好的命令行接口。它所需的程序进程了参数定义，argparse将更好的解析sys.argv。同时argparse模块还能自动生成帮助及用户输入错误参数时的提示信息。

官网资料：https://docs.python.org/2/library/argparse.html#module-argparse

getopt

　 　在运行程序时，可能需要根据不同的条件，输入不同的命令行选项来实现不同的功能。目前常用的由短选项和长选项两种格式。短选项格式为"-"加上单个字母 选项，长选项为"--"加上一个单词。长格式实在Linux下引入的。许多Linux程序都支持这两种格式。在Python中提供了getopt模块很好 的实现了对着两种用法的支持，而且使用简单。

获取命令行参数

Python环境下可以使用sys模块得到命令行参数

import getopt
import sys

print(sys.argv)

C:\Users\Administrator\>python 222.py -o t --help cmd file1 file2
['222.py', '-o', 't', '--help', 'cmd', 'file1', 'file2']

# 由此可见，所有命令行参数以空格为分隔符，保存在sys.argv列表中，其中第一个为文件名

选项的写法要求：
短格式："-"号后面要紧跟一个选项字母。如果还有此选项的附加参数，可以用空格分开，也可以不分开。长度任意，可以用引号。
例如：
-o
-o "a b"
长格式："--"号后面要跟一个单词。如果还有些选项的附加参数，后面要紧跟"="，再加上参数。"="号前后不能有空格。
例如：
--help=file1

如何使用getopt进行参数分析及处理？

第一步：导入sys，getopt模块
第二步：分析命令行参数
第三步：处理结果

import getopt
import sys

# print(sys.argv)
def usage():
    print(
"""
Usage:sys.args[0] [option]
-h or --help：显示帮助信息
-m or --module：模块名称   例如：ansible all -m shell -a 'date'
-a or --args：模块对于的参数  例如：ansible all -m shell -a 'date'
-v or --version：显示版本
"""
    )
if len(sys.argv) == 1:
    usage()
    sys.exit()

try:
    opts, args = getopt.getopt(sys.argv[1:], "ho:m:a:", ["help", "output="])   # sys.argv[1:] 过滤掉第一个参数(它是脚本名称，不是参数的一部分)
except getopt.GetoptError:
    print("argv error,please input")

# 使用短格式分析串“ho:m:a:”
 当一个选项只表示开关状态时，即后面不带任何参数时，在分析串中写入选项字符，例如：-h表示获取帮助信息，显示完成即可，不需任何参数
 当一个选项后面需要带附加参数时，在分析串中写入选项字符同时后面加一个“：”号，例如：-m表示指定模块名称，后面需加模块名称

# 使用长格式分析串列表：["help", "output="]。
长格式串也可以有开关状态，即后面不跟"="号。如果跟一个等号则表示后面还应有一个参数。这个长格式表示"help"是一个开关选项；"output="则表示后面应该带一个参数。
# print(opts)
# print(args)
# 调用getopt函数。函数返回两个列表：opts和args。
# opts为分析出的格式信息，是一个两元组的列表。每个元素为：(选项串,附加参数)。如果没有附加参数则为空串''。
# args为不属于格式信息的剩余的命令行参数。
# 整个过程使用异常来包含，这样当分析出错时，就可以打印出使用信息来通知用户如何使用这个程序。

# 以下部分即根据分析出的结果做相应的处理，并将处理结果返回给用户
for cmd, arg in opts:  # 使用一个循环，每次从opts中取出一个两元组，赋给两个变量。cmd保存选项参数，arg为附加参数。接着对取出的选项参数进行处理。
    if cmd in ("-h", "--help"):
        print("help info")
        sys.exit()
    elif cmd in ("-o", "--output"):
        output = arg
    elif cmd in ("-m", "--module"):
        module_name = arg
    elif cmd in ("-a", "--module_args"):
        module_args = arg
    elif cmd in ("-v", "--version"):
        print("%s version 1.0" % sys.argv[0])

import getopt  
    import sys  
      
    config = {  
        "input":"",  
        "output":".",  
          
    }  
      
    #getopt三个选项，第一个一般为sys.argv[1:],第二个参数为短参数，如果参数后面必须跟值，须加:，第三个参数为长参数  
    #是一个列表，  
    opts, args = getopt.getopt(sys.argv[1:], 'hi:o:d',   
          [  
            'input=',   
            'output=',   
            'help'  
            ]  
          )  
      
    #参数的解析过程,长参数为--，短参数为-  
    for option, value in opts:  
        if  option in ["-h","--help"]:  
            print """  
            usage:%s --input=[value] --output=[value]  
            usage:%s -input value -o value  
            """  
        elif option in ['--input', '-i']:  
            config["input"] = value  
        elif option in ['--output', '-o']:  
            config["output"] = value  
        elif option == "-d":  
            print "usage -d"  
      
    print config   
# 结果
输入的参数：--input=c:\temp\aa -o c:\temp\output -d
打印的结果：
usage -d
{'input': 'c:\\temp\\aa', 'output': 'c:\\temp\\output'}

argparse

 argparse简介

　 　argparse是Python用于解析命令行参数和选项的标准模块，用于代替已经过时的optparse模块。argparse模块的作用是用于解析 命 令行参数，例如python parseTest.py input.txt output.txt --user=name --port=8080。

argparse讲解

将以下代码保存为prog.py

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')   # 首先创建一个ArgumentParser对象
parser.add_argument('integers', metavar='N', type=int, nargs='+',           # 添加参数
                    help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                    const=sum, default=max,
                    help='sum the integers (default: find the max)')     # 添加--sum则返回所有数之和，否则返回列表中的最大值

args = parser.parse_args()
print args.accumulate(args.integers)

在命令行中输入如下：
$ python prog.py -h
usage: prog.py [-h] [--sum] N [N ...]

Process some integers.

positional arguments:
 N           an integer for the accumulator

optional arguments:
 -h, --help  show this help message and exit
 --sum       sum the integers (default: find the max)

# 输入正确的参数信息
$ python prog.py 1 2 3 4
4

$ python prog.py 1 2 3 4 --sum
10

# 输入错误的参数信息
$ python prog.py a b c
usage: prog.py [-h] [--sum] N [N ...]
prog.py: error: argument N: invalid int value: 'a'

ArgumentParser对象的参数
prog - The name of the program (default: sys.argv[0])
usage - The string describing the program usage (default: generated from arguments added to parser)
description - Text to display before the argument help (default: none)
epilog - Text to display after the argument help (default: none)
parents - A list of ArgumentParser objects whose arguments should also be included
formatter_class - A class for customizing the help output
prefix_chars - The set of characters that prefix optional arguments (default: ‘-‘)
fromfile_prefix_chars - The set of characters that prefix files from which additional arguments should be read (default: None)
argument_default - The global default value for arguments (default: None)
conflict_handler - The strategy for resolving conflicting optionals (usually unnecessary)
add_help - Add a -h/–help option to the parser (default: True)
每个参数的详细说明：
prog：即运行程序的名称，默认取sys.argv[0]的值，可以修改为指定的名称
usage：指定usage信息的内容及格式，默认是根据你添加的信息自动生成的，可以自定义修改为指定的内容
description：这个程序的功能概述
epilog：在整个帮助信息最后添加的附加信息
parents：用于定义一些公共的信息供子类调用
formatter_class：整个信息的类定义，主要包含三个类，每个类的功能如下：

• class argparse.RawDescriptionHelpFormatter # 如何显示文本描述
• class argparse.RawTextHelpFormatter # 如何显示文本描述
• class argparse.ArgumentDefaultsHelpFormatter # 自定添加参数信息

prefix_chars：自定义参数个前缀类型
fromfile_prefix_chars：指定文件替代命令行输入参数的方式
argument_default：
conflict_handler：检测是否存在相同的参数选项，不加该参数直接报错，添加该参数可以兼容（conflict_handler='resolve'） 
add_help：  设置是否显示帮助信息那表之类（默认显示）

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo', help='foo help')
args = parser.parse_args()

$ python myprogram.py --help
usage: myprogram.py [-h] [--foo FOO]

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

>>> parser = argparse.ArgumentParser(prog='PROG', add_help=False)
>>> parser.add_argument('--foo', help='foo help')
>>> parser.print_help()
usage: PROG [--foo FOO]

optional arguments:
 --foo FOO  foo help

add_argument()方法    

    格式： ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

• name or flags - Either a name or a list of option strings, e.g. foo or -f, --foo.    # 参数选项列表
• action - The basic type of action to be taken when this argument is encountered at the command line.
• nargs - The number of command-line arguments that should be consumed.
• const - A constant value required by some action and nargs selections.
• default - The value produced if the argument is absent from the command line.
• type - The type to which the command-line argument should be converted.
• choices - A container of the allowable values for the argument.
• required - Whether or not the command-line option may be omitted (optionals only).
• help - A brief description of what the argument does.
• metavar - A name for the argument in usage messages.
• dest - The name of the attribute to be added to the object returned by parse_args().

实际案例讲解

# 基本认识，只有就基本框架
import argparse

parser = argparse.ArgumentParser()
parser.parse_args()

# 结果
C:\Users\Administrator\Desktop>python3 getopt_help.py -h
usage: getopt_help.py [-h]

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

C:\Users\Administrator\Desktop>python3 getopt_help.py foo
usage: getopt_help.py [-h]
getopt_help.py: error: unrecognized arguments: foo

C:\Users\Administrator\Desktop>python3 getopt_help.py -f
usage: getopt_help.py [-h]
getopt_help.py: error: unrecognized arguments: -f

# 结果分析
1）不给参数而运行这个程序，将不会得到任何结果
2）没有做任何特别设置，可以得到一个很简洁的帮助信息（第二三个例子）
3）无需人为设置--help参数，就能得到一个良好的帮助信息。但是若给其他参数（比如foo）就会产生一个错误。

 其他

 if len(sys.argv) == 1:
     parser.print_help()
     sys.exit(1)

 

 

【出处】：https://www.cnblogs.com/madsnotes/articles/5687079.html

=======================================================================================

个人测试

我自己的测试案例：

import argparse

def get_args():
    parser = argparse.ArgumentParser(prog='argument.py',description='编写命令行的示例文件')
    parser.add_argument('name',type=str,help='名字') # 添加位置参数（必选）
    parser.add_argument('age',type=int,help='年龄') # 添加位置参数（必选）
    parser.add_argument('-s',dest='sex',type=str,help='性别') # 添加可选参数
    args = parser.parse_args()
    print(args)
    print('-----------------')
    print(args.sex) # 通过dest参数指定的sex获取。
    print(args.name)


def get_args1():
    parser = argparse.ArgumentParser()
    parser.add_argument('-b', '--batch_size', type=int, default=64, help='batch size help')
    parser.add_argument('-i', '--image_directory', type=str, default='FGNET/images')
    parser.add_argument('-ls', '--leave_subject', type=int, default=1)
    parser.add_argument('-lr', '--learning_rate', type=float, default=0.001)
    parser.add_argument('-e', '--epoch', type=int, default=100)
    parser.add_argument('-r', '--resume', type=str, default=None)
    parser.add_argument('-K', '--K', type=int, default=6)
    return parser.parse_args()

class ObjectConfiger(object):
    def __init__(self,config):
        self.config = config

    def __getattr__(self, item):
        if item in self.config:
            return self.config[item]
        else:
            raise AttributeError


if __name__ == '__main__':
    print('hello')
    print('===========================')
    parg=get_args()
    # parg=get_args1()
    print(parg)

    configer = ObjectConfiger({
        'boy':{
            'name': '岳云鹏',
            'age' : 5,
            'school': '北极光第五中学'
        },
        'student':{
            '__extends__':['boy'],
            'school': '庞各庄大学',
            'score': 30
        }
    })
    print(configer.get_selection('boy'))
    # 输出 {'name': '岳云鹏', 'age': 5, 'school': '北极光第五中学'}
    
    print(configer.get_selection('student'))
    # 输出