Python optparse模块

命令行参数和解析输入参数是编程和开发的重要方面。命令行参数只不过是系统命令行中程序名称后面指定的参数。当我们在这些命令行参数中传递值时，这些值会直接传递到程序的参数中，这就是参数或变量的值存储在程序内存中的方式。命令行参数是在系统的命令提示符 Shell 中程序名称之后给出的，为此我们传递了这些参数。

所有这些参数都在程序的 main()函数内部传递，通常只包含以下两个参数:

• 程序中应该传递的参数数量
• 程序中传递的命令行参数列表

这两类参数在 main()函数中使用，第二类参数取自命令行参数。解析一个参数意味着我们传递的命令行参数在程序中是如何处理的。此外，我们在命令提示符 shell 中传递的所有命令行参数只由程序的 main()函数处理。当我们必须传递动态数据时，当一次传递多个值时，这些命令行参数非常有用。当在单个命令行调用中传递多个参数时，这些值将根据变量和函数的数据类型和功能分配给程序的相应变量。这使得我们可以轻松地同时传递多个值，甚至不必将所有值都赋给它们特定的变量和函数。

所有编程语言都为命令行参数和解析这些参数提供了不同类型的函数，但是专门讨论 Python 为我们提供了许多内置函数和多个包来执行这些任务。一个这样的 Python 包是 Python 的 Optparse 模块，我们可以使用它来设置命令行参数，并使用 Python 程序解析这些参数。这就是为什么我们将在本教程中学习 Python optparse 模块，并且我们将传递命令行参数&使用该模块的函数解析它们。

Python 中的 Optparse 模块介绍

Python 的 optparse 模块是一个非常好的替代 getopt 包的选项，它已经成为一个现代的替代选项来处理和解析 Python 程序中的命令行参数。该模块用于传递命令行参数，并使用该模块的功能在 Python 程序中解析这些参数。Optparse 模块是 getopt 包的一个很好的选择，因为许多以前在 getopt 包中没有的功能现在都可以在这个模块中使用。许多功能，如自动帮助生成、选项回调和类型转换，以前在 getopt 包中不可用，但现在这些选项在 optparse 模块中对我们可用。这就是为什么 optparse 模块比 getopt 包更受欢迎，更适合解析命令行参数。除了 getopt 包中以前没有的功能之外，optparse 模块还引入了许多新功能。在本教程中，我们将只讨论本模块的一些基本功能和特性。在本教程中，我们将使用一些示例程序来演示 optparse 模块的一些基本功能。

Python 的优化模块:优势

下面是 Python 的 optparse 模块相对于其他包的一些优势:

• optparse 模块使我们可以非常容易地使用命令行参数，并通过 Python 程序解析它们。
• 这个模块拥有 Python getopt 包中以前缺少的所有特性。
• optparse 模块使我们能够轻松处理动态输入数据，它还提供了根据动态输入数据更改输出的选项。
• 除此之外，它还为我们提供了一些非常新的特性，有助于顺利处理所有命令行参数。

这些是使用 Python 的 optparse 模块的一些常见优势，我们可以从这些优势中得到一个想法，即为什么这个模块在命令行参数方面非常受欢迎，并且比 Python 的所有其他包都更受欢迎。

Python 的优化模块:安装

optparse 模块内置了 Python，这就是为什么我们不需要执行任何安装过程来使用这个模块。通过将 optparse 模块导入示例 Python 程序，我们可以直接开始使用该模块。要在 Python 程序中导入该模块，我们可以使用以下代码行:

# Importing optparse module
import optparse

之后，我们可以在程序中使用这个模块的功能，并使用这个模块处理命令行参数。

使用操作分析模块

在这一部分中，我们将讨论 optparse 模块中可用的多个函数和选项，我们可以使用它们来非常容易地解析命令行参数。我们还将在这一部分使用示例程序来更好地理解 optparse 模块的实现。但是首先，我们将学习创建一个选项解析器对象，因为这个对象将解析为程序的 main()函数传递的命令行参数。

创建选项分析器对象

我们可以通过以下两个阶段由 optparse 模块解析命令行参数:

• 首先，我们必须在程序中创建一个 OptionParser 实例来处理命令行参数，它应该用命令行参数中给出的预期选项或值来配置和构造。
• 之后，从命令行参数中给出一系列选项或值，并在程序中进行处理。

因此，首先，我们必须在程序中创建一个 OptionParser 实例，我们可以使用 optparse 模块的 optionparser()函数来实现这一点。我们可以创建一个 OptionParser 实例，让 optionparser 属性解析命令行参数，在任何 Python 程序中使用下面一行代码:

# Importing the optparse module
import optparse as opt
# Creating an OptionParser instance
opInstance = opt.optionparser()

正如我们所看到的，我们已经将 optparse 模块导入为 opt，之后，我们使用 optionparser()函数为 OptionParser 创建了一个实例，并将其命名为“opInstance”

一旦创建了 OptionParser 实例，程序中使用的所有 optparse 选项都会隐式添加到解析器实例中。它还为我们提供了在命令行中遇到定义的选项时我们可以做什么的信息。OptionParser 实例还为我们提供了一些函数，通过这些函数可以将选项列表传递给程序中的 OptionParser 构造器。但是应该注意的是，使用 OptionParser 实例中的选项的这种形式并不常用。

定义选项

当我们在程序的 OptionParser 实例中定义选项时，我们应该记住应该一次添加一个选项。程序中定义的每个选项实例代表一组同义的命令行选项字符串。我们可以使用 add_options()函数在程序中定义选项，该函数将被隐式添加到 OptionParser 实例中。在参数的开头，我们可以使用任何未命名的字符串参数，它们被视为选项实例名。我们可以为我们正在定义的选项创建别名，也就是说，通过简单地为它传递多个名称，我们已经定义了同一个选项的长形式和短形式。

我们有两种方法可以用 OptionParser 在程序中创建一个选项实例。以下是我们在程序中使用 OptionParser 创建选项实例的两种方法:

方法 1:仅给出选项参数:

在这个方法中，我们将在 add_option()参数中给出 option 参数，并使用下面一行代码来创建选项实例:

# Creating an option instance
oiVaribale = opInstance.add_option(option)

方法 2:给出字符串和值参数:

在这个方法中，我们将在定义 options 实例时，在函数的 attribute 选项中给出值参数，在 add_option()中给出可选字符串。我们可以使用下面一行代码通过这个方法来定义选项实例:

# Creating an option instance
oiVaribale = opInstance.add_option(*opt_str, attr = userValue, ...)

在这两种方法中，我们可以使用长形式和短形式的已定义选项实例。

如果我们只想为短选项字符串和长选项字符串定义选项，那么我们必须使用两种不同的方法(一种用于短选项字符串，另一种用于长选项字符串)。因此，通过这两种方法定义的选项将只接受短选项字符串值或长选项字符串值，这取决于我们用来定义选项的函数。以下是我们可以用来定义短选项字符串或长选项字符串的两个函数:

1)仅为长选项字符串定义选项:

我们可以使用下面的方法和 add_option()函数来为长选项字符串值定义一个选项:

# Option instance for long option string
losInstance = opInstance.add_option("--foo", attr = userValue, ...)

如我们所见，我们必须在 add_option()函数中的可选参数位置给出“- foo”值，为长选项字符串定义一个选项实例。

2)为短选项字符串定义选项实例:

我们可以使用下面一行带有 add_option()函数的代码来定义短选项字符串值的选项实例:

# An option instance for short option string value
sosVariable = opInstance.add_option("-f", attr = userValue, ...)

如我们所见，我们必须在 add_option()函数中给出“-f”参数来代替可选参数，从而为短选项字符串定义一个选项实例。

这就是我们如何专门为长选项字符串或短选项字符串定义一个选项实例，根据我们使用的方法，这些选项实例产生的输出只能是长字符串或短字符串形式。

选项实例的标准操作:

我们在程序中用 OptionParser 构造器定义的选项实例有一些标准的动作选项。这些标准选项操作用于执行几个功能，并在其中存储特定类型的输入值。根据程序的功能和预期的输出，我们可以使用这些选项操作来设置我们希望在这些选项实例中存储哪种类型的值。以下是选项实例可用的标准选项操作:

• “追加”:该动作用于将该选项实例的选项参数追加到列表中
• “store”:“store”动作用于存储选项实例的选项参数，在 add_option()函数中默认设置
• “store _ false”:此选项用于在选项实例中存储 false 参数
• “store _ true”:此选项用于在选项实例中存储 true 参数
• “append_const”:在选项实例中使用“append _ const”操作，将一个常量值从选项实例追加到列表中
• “store _ const”:该选项在选项实例中用于在实例中存储一个常量值

这些是标准的选项操作，适用于使用 add_option 函数和 optionparser 构造器定义的所有选项实例。我们可以使用其中的一个或多个来设置在解析命令行参数时存储或/和追加哪个值。

标准选项属性:

我们定义的选项实例也有几个属性来定义程序中这些选项实例的功能和工作。在解析输入命令或执行程序中的某些特定功能时，这些属性用作获取某些特定参数的值。

以下是我们使用 add_option()函数定义的选项实例的标准选项属性:

• optionInstance.default: 在命令行上看不到该选项实例时，选项实例中与该属性一起使用的值用于该选项实例的目标
• optionInstance.dest: 它是选项实例的默认属性，从作为输入参数提供的选项字符串中派生而来
• 选项实例.类型:该属性用于设置该选项实例取值的数据类型，默认设置为“字符串”
• optionInstance.action: 该属性在选项实例中用于设置将对选项实例中给定的值执行什么操作，默认情况下，该属性设置为“存储”操作

我们可以使用选项实例可用的这些属性来设置这些选项实例将采用哪些数据类型值，以及在程序中将对这些值执行哪些操作。

Python 中的 Optparse 模块:实现

在这一部分中，我们将通过一些解析命令行参数的示例程序来理解 Python 的 optparse 模块的实现。我们将通过执行多个功能来理解这个模块的实现，例如在命令行参数中获取输入值，使用这个模块的类和函数。我们将通过这些示例程序产生的输出和对它们的解释来理解它们的工作。

看下面的示例程序，了解 optparse 模块的工作原理:

实现 1:在选项实例中同时使用长选项值和短选项值:

在这个实现部分，我们将通过在一个示例程序中定义 optionparser 和 option 实例来理解它们的工作。我们将为长选项字符串和短选项字符串定义选项实例，并在从系统的命令 Shell 执行它们时逐个调用它们。请看下面的示例程序来理解 optparse 模块的这个实现部分。

示例 1: 看看下面的 Python 程序，其中我们定义了长的&短的选项实例:

# Importing the optparse module
import optparse as opt
# Import the sys module
import sys
# Printing the argv value
print('ARGV value for option instances    :', sys.argv[1:])
# Creating an optionparser constructor for option instances
opConst = opt.OptionParser()
# Defining an option instance with both short & long instance
opConst.add_option('-s', '--long', 
                                 dest = "output_filename",
                                 default = "default.out",
                                 )                                 
# Creating another option instances with several arguments
opConst.add_option('-v', '--verbose',
                                 dest = "verbose",
                                 default = False,
                                 action = "store_true",
                                )
opConst.add_option('--version',
                                dest = "version", 
                                default = 1.0,
                                type = "float",
                                )                              
# Creating parser arguments for options and remainder instances
oInstance, rInstance = opConst.parse_args()
# Printing values in the output
print('VERSION of the input string   :', oInstance.version)
print('VERBOSE for the input value   :', oInstance.verbose)
print('OUTPUT with respect to input string    :', oInstance.output_filename)
print('REMAINING for remainder is the function :', rInstance)

输出:

While calling with the short option string argument:
C:\Users\Manish\Downloads>python code.py -s sample3.txt
ARGV value for option instances    : ['-s', 'sample3.txt']
VERSION of the input string   : 1.0
VERBOSE for the input value   : False
OUTPUT with respect to input string    : sample3.txt
REMAINING for remainder is the function : []
While calling with the long option string argument:
python code.py --long sample4.txt
ARGV value for option instances    : ['--long', 'sample4.txt']
VERSION of the input string   : 1.0
VERBOSE for the input value   : False
OUTPUT with respect to input string    : sample4.txt
REMAINING for remainder is the function : []
While calling with a custom argument for the option instance:
python code.py --lon sample4.txt
ARGV value for option instances    : ['--lon', 'sample4.txt']
VERSION of the input string   : 1.0
VERBOSE for the input value   : False
OUTPUT with respect to input string    : sample4.txt
REMAINING for remainder is the function : [] 

如我们所见，我们在函数中使用 long 或 short 关键字参数调用了选项实例中的 long 选项字符串和 short 选项。我们还为选项实例提供了一个自定义参数，选项实例也用自定义参数调用，这就是它存储这些值的方式。这就是我们如何使用 optparse 模块的函数来创建长和短选项字符串实例。

说明:

我们首先在程序中导入了 optparse 和 sys模块，以使用这些模块的功能。之后，我们在 print 语句中使用了 sys模块的 argv 函数来打印选项实例，它是从程序中调用的。然后，我们使用 optionparser()函数创建了 OptionParser 构造器，并将构造器变量命名为“opConst”。之后，我们使用这个变量 optionparser 构造器在程序中使用 add_opions()函数创建选项实例。然后，我们在程序中创建了三个选项实例，在这些选项实例中，我们给出了长或短的选项字符串参数来定义选项实例的类型。之后，我们使用 optparse 模块的 parse_args()函数来解析命令行参数。最后，我们在 print 语句中使用了 optparse 模块的这些 args 变量来打印选项实例中的一些特定信息。解析命令行参数后，我们在打印信息之前定义了信息类别。

实现 2:在选项实例中传递值:

在这个实现部分，我们将为我们在选项实例中定义的参数传递值。在程序中解析命令行参数后，我们在程序中传递的这些值将打印在输出中。我们应该记住，我们传递的值的数据类型应该与我们在选项实例中定义的数据类型相同；否则，它将在输出中产生错误。请看下面的示例程序来理解 optparse 模块的这个实现部分。

示例 2: 看看下面的程序，我们在其中传递了选项实例的值:

# Importing the optparse module
import optparse as opt
# Creating an optionparser constructor for option instances
opConst = opt.OptionParser()
# Defining multiple option instances with different data types
opConst.add_option('-a', action = "store", type = "int")
opConst.add_option('-b', action = "store", type = "float")
opConst.add_option('-c', action = "store", type = "long")
opConst.add_option('-d', action = "store", type = "complex")
opConst.add_option('-s', action = "store", type = "string")
# Parsing options instance to show input given values
parsedOptions, args = opConst.parse_args()
# Printing input string values with the respective option instances
print(The int data type input value for the first option : %-16r %s' % (type(parsedOptions.a), parsedOptions.a))
print(The float data type input value for the second option : %-16r %s' % (type(parsedOptions.b), parsedOptions.b))
print(The long data type input value for the third option : %-16r %s' % (type(parsedOptions.c), parsedOptions.c))
print(The complex data type input value for the fourth option : %-16r %s' % (type(parsedOptions.d), parsedOptions.d))
print(The string data type input value for the last option : %-16r %s' % (type(parsedOptions.s), parsedOptions.s))

输出:

code.py -a 5 -b 31.26 -c 24260000 -d 24+26j -s max
The int data type input value for the first option : <class 'int'>    5
The float data type input value for the second option : <class 'float'>  31.26
The long data type input value for the third option : <class 'int'>    24260000
The complex data type input value for the fourth option : <class 'complex'> (24+26j)
The string data type input value for the last option : <class 'str'>    max

如我们所见，在给出不同数据类型的输入值后，这些输入值被分配给各自的数据类型选项实例。这就是我们如何给出不同的数据类型输入值，并使用命令行 shell 将它们解析为已定义的选项实例。

说明:

在定义了 optionparser 构造器之后，我们已经在程序中定义了多个选项实例。这些选项实例是用设置为“存储”的操作参数来定义的，以便为这些选项实例存储给定的输入值。此外，这些选项实例被设置为采用不同的数据类型，以便当输入中给出特定的数据类型值时，它将仅存储到该特定的选项实例中。最后，我们打印输入值，使用 print 语句中的 parsedOptions 构造器对输入值进行解析并存储到特定的选项实例中。我们还在结果中用值打印了值的数据类型。

注意:应该注意的是，在为选项实例提供输入值时，如果我们提供的数据类型输入值不同于选项实例中定义的值，将会出现错误，并且在输出中会显示错误消息。为了演示这一点，我们将运行 Python 代码，并给出不同的数据类型值，而不是选项实例的数据类型。查看下面的示例程序，了解选项实例的概念:

# Importing the optparse module
import optparse as opt
# Creating an optionparser constructor for option instances
opConst = opt.OptionParser()
# Defining multiple option instances with different data types
opConst.add_option('-a', action = "store", type = "int")
# Parsing options instance to show input given values
parsedOptions, args = opConst.parse_args()
# Printing input string values with the respective option instances
print(The int data type input value for the first option : %-16r %s' % (type(parsedOptions.a), parsedOptions.a))

输出:

code.py -a c
Usage: code.py [options]

code.py: error: option -a: invalid integer value: 'c'  

如我们所见，当我们为选项实例提供不同的数据类型输入值时，输出中会显示一条错误消息。

实现 3:解析命令行参数以打印表格:

到目前为止，我们已经理解了选项实例和 optionparser 构造器的工作和实现。现在，我们将使用 optparse 模块及其函数根据输入值在命令行 shell 中打印一个表。我们将在程序中使用 for循环来循环输入值，因此，使用 optparse 模块的功能打印命令 Shell 中的表。这将帮助我们更好地理解使用 optparse 模块解析命令行参数的工作和实际实现。请看下面的示例程序，其中我们在命令 Shell 中打印了表:

示例 4: 查看下面的 Python 程序，了解 optparse 模块的实际实现:

# Importing the optparse module
import optparse as opt

# Define a function to print table of n
def tablePrint(num, destCheak):
        # Using for loop to print the table
    for a in range(1,11):
        table = a * num
        # Using if to check if destination input given is other than 0
        if destCheak:
            print(table)    
    return table

# Define main function to add options for taking input value
def Main():
    # Create the OptionParser constructor
    opConst = opt.OptionParser()

    # Adding multiple option instances with specific functions
    opConst.add_option('-m', dest = 'num',
                    type = 'int',
                    help = 'specify the nth table number to print table in the output') # Using help argument to show help message in the case of error
    opConst.add_option('-c', dest = 'out',
                    type = 'string',
                    help = 'specify an output file for the input value (Optional)')
    opConst.add_option("-b", "--all",
                    action = "store_true",
                    dest = "prin",
                    default = False,
                    help = "print all numbers up to N from the print table function")
    # Adding parsed options constructor
    (optionParsed, args) = opConst.parse_args()
    if (optionParsed.num == None):
            print (opConst.usage)
            exit(0)
    else:
            number = optionParsed.num   
    # Calling the print table function
    result = tablePrint(number, optionParsed.prin)
    # Printing the last term of table in the result
    print ("This is the table of given input value number with last term:" + str(result))
        # Checking if given input value is not 0
    if (optionParsed.out != None):
        # Opening a file in append mode to print table
        func = open(optionParsed.out, "a")      
        # Writing in the file we appended
        func.write(str(result) + '\n')

# Driver code to call main function
if __name__ == '__main__':
    # Calling the main function
    Main()

输出:

python code.py -m 7 -b
7
14
21
28
35
42
49
56
63
70
This is the table of given input value number with last term:70   

正如我们所看到的，“7”的表，也是命令 Shell 中的输入值，在程序中解析命令行参数后，会打印在输出中。

这就是我们如何使用 Python 的 optparse 模块来解析命令行参数，并通过 Python 程序使用它们。