Python Optparse模块

Python Optparse模块

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

所有这些参数都传递给程序的main()函数，它通常只包含以下两个参数：

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

这两种类型的参数在main()函数中使用，并且第二种类型的参数是从命令行参数中获取的。解析参数意味着我们如何处理我们传递的命令行参数。此外，所有的命令行参数或我们在命令提示符shell中传递的参数只能由程序的main()函数处理。当我们需要传递动态数据和同时传递多个值时，这些命令行参数非常有用。当多个参数在单个命令行调用中传递时，根据变量和函数的数据类型和功能，值将被赋给程序的相应变量。这样我们就可以方便地同时传递多个值，而且我们甚至不需要将所有值分配给它们的特定变量和函数。

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

Python中Optparse模块的介绍

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

Python的Optparse模块：优势

以下是 optparse 模块相对于其他包的一些优势：

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

这些是使用Python的optparse模块的一些常见优点，从这些优点我们可以了解到为什么这个模块在处理命令行参数时非常受欢迎并且优先于其他Python包。

Python的Optparse模块：安装

Optparse模块是Python内置的，因此我们不需要执行任何安装过程就可以使用该模块。我们可以通过将该模块导入到示例Python程序中来直接开始使用optparse模块。要在Python程序中导入此模块，我们可以使用以下代码行：

# Importing optparse module
import optparse

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

使用Optparse模块处理命令行参数

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

创建OptionParser对象

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

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

因此，首先在程序中创建一个OptionParser实例，我们可以使用optparse模块的optionparser()函数来完成这个任务。我们可以在任何Python程序中使用以下代码行创建一个OptionParser实例，该实例具有用于解析命令行参数的optionparser属性：

# 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()参数中给出选项参数，并使用以下代码行创建选项实例：

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

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

在这种方法中，我们将在函数的属性选项中给出值参数，并在定义选项实例时在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构造函数定义的选项实例具有一些标准动作选项。这些标准选项操作用于执行多个功能并在其中存储特定类型的输入值。根据程序的功能和预期输出，我们可以使用这些选项操作来设置我们想要存储在这些选项实例中的值的类型。

以下是可用于选项实例的标准选项操作：

• “append”： 该操作用于将该选项实例的选项参数追加到列表中
• “store”： “store”操作用于存储选项实例的选项参数，并且在add_option()函数中默认设置
• “store_false”： 此选项用于在选项实例中存储false参数
• “store_true”： 此选项用于在选项实例中存储true参数
• “append_const”： “append_const”操作用于将选项实例中的常量值追加到列表中
• “store_const”： 此选项用于在选项实例中存储常量值

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

标准选项属性：

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

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

• optionInstance.default： 与该属性一起使用的选项实例的值用于在命令行上未看到该选项实例时的目标
• optionInstance.dest： 它是一个选项实例的默认属性，它是从提供的选项字符串中派生的输入参数
• optionInstance.type： 该属性用于设置由此选项实例接受的值的数据类型，默认情况下设置为字符串
• optionInstance.action： 该属性用于在选项实例中设置对选项实例中给定值的执行的操作，默认情况下，此属性设置为“store”操作

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

Python中的Optparse模块：实现

在这部分中，我们将通过一些示例程序来理解Python的optparse模块的实现，其中我们将解析命令行参数。我们将通过执行多个函数（如在命令行参数中输入值，使用该模块的类和函数）来理解该模块的实现。我们通过输出和解释示例程序的工作原理来理解这些示例程序的工作方式。

请看以下示例程序以了解optparse模块的工作原理：

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

在这个实现部分中，我们将通过在示例程序中定义optionparser和option实例来理解它们的工作原理。我们将为长选项字符串和短选项字符串分别定义选项实例，并在从系统的命令行执行它们时逐个调用它们。请查看以下示例程序以了解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 : [] 

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

解释：

我们首先在程序中导入了optparse和sys模块以使用这些模块的函数。然后，我们在print语句中使用了sys模块的argv函数来打印从程序中调用的选项实例。然后，我们使用OptionParser()函数创建了optionparser构造函数，并将构造函数变量命名为’opConst’。然后，我们使用这个变量optionparser构造函数来使用add_options()函数在程序中创建选项实例。然后，在程序中创建了三个选项实例，在这些选项实例中，我们给出了长选项字符串或者短选项字符串参数来定义选项实例的类型。然后，我们使用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构造函数之后，我们在程序中定义了多个选项实例。这些选项实例的action参数设置为“store”，这样给定的输入值将被存储到这些选项实例中。此外，这些选项实例被设置为接受不同的数据类型，这样当给定特定数据类型的值时，它将仅存储到该特定选项实例中。最后，我们使用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'  

从输出可以看出，当我们为option实例提供不同的数据类型输入值时，会显示一个错误消息。

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

到目前为止，我们已经了解了option实例和optionparser构造函数的工作原理和实现方法。现在，我们将使用optparse模块及其函数从输入值在命令行中打印一个表格。我们将在程序中使用for循环来遍历输入值，并使用optparse模块的函数在命令行中打印表格。这将帮助我们更好地理解使用optparse模块解析命令行参数的工作原理和实际实现。请看以下示例程序，在命令行中打印了一个表格：

示例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”也是命令行中的输入值，在程序中解析命令行参数之后，在输出中打印出来。

这就是我们可以使用Python的optparse模块来解析命令行参数并通过Python程序处理它们的方式。