36.1. `optparse` — 命令行参数解析¶

3.2版本后开始弃用:optparse 模块已经弃用且无继续开发的计划; 新的开发将转向argparse 模块.

optparse是比旧的getopt模块更方便，灵活且功能强大的库，用于解析命令行选项。optparse使用更具声明性的命令行解析样式：创建OptionParser的实例，使用选项填充它，并解析命令行。optparse允许用户在常规GNU / POSIX语法中指定选项，并为您生成使用和帮助消息。

以下是在简单脚本中使用optparse的示例：

from optparse import OptionParser
...
parser = OptionParser()
parser.add_option("-f", "--file", dest="filename",
                  help="write report to FILE", metavar="FILE")
parser.add_option("-q", "--quiet",
                  action="store_false", dest="verbose", default=True,
                  help="don't print status messages to stdout")

(options, args) = parser.parse_args()

有了这几行代码，你的脚本的用户现在可以在命令行上做“通常的事情”，例如：

<yourscript> --file=outfile -q

解析命令行时，optparse根据用户提供的命令行值设置parse_args()返回的options对象的属性。When parse_args() returns from parsing this command line, options.filename will be "outfile" and options.verbose will be False. optparse支持长选项和短选项，允许将短选项合并在一起，并允许以各种方式将选项与其参数相关联。因此，以下命令行都等效于上面的示例：

<yourscript> -f outfile --quiet
<yourscript> --quiet --file outfile
<yourscript> -q -foutfile
<yourscript> -qfoutfile

此外，用户可以运行其中之一

<yourscript> -h
<yourscript> --help

和optparse将打印出您脚本选项的简要摘要：

Usage: <yourscript> [options]

Options:
  -h, --help            show this help message and exit
  -f FILE, --file=FILE  write report to FILE
  -q, --quiet           don't print status messages to stdout

其中yourscript的值在运行时确定（通常从sys.argv[0]）。

36.1.1. Background¶

optparse旨在鼓励使用直接，常规的命令行界面创建程序。为此，它仅支持在Unix下常用的最常用的命令行语法和语义。如果您不熟悉这些约定，请阅读本部分以熟悉它们。

36.1.1.1. Terminology¶

论据

在命令行上输入的字符串，并由shell传递给execl()或execv()。在Python中，参数是sys.argv[1:]（sys.argv[0]是要执行的程序的名称）的元素。Unix shell也使用术语“word”。

It is occasionally desirable to substitute an argument list other than sys.argv[1:], so you should read “argument” as “an element of sys.argv[1:], or of some other list provided as a substitute for sys.argv[1:]”.

选项

用于提供额外信息以引导或定制程序执行的参数。选项有很多不同的语法；传统的Unix语法是一个连字符（“ - ”）后跟一个单字母，例如。-x或-F。此外，传统的Unix语法允许将多个选项合并到单个参数中，例如。-x -F等效于-xF。GNU项目引入了--，后面跟着一系列连字符分隔的单词，例如。--file或--dry-run。这些是optparse提供的唯一两个选项语法。

一些其他的选项语法，世界已经看到包括：

连字符后跟几个字母，例如。-pf（这是不是与合并到单个参数中的多个选项相同）
连字符后跟整个字，例如。-file（这在技术上等同于以前的语法，但是它们通常不会出现在同一个程序中）
加号，后跟单个字母，或几个字母，或单词，例如。+f，+rgb
一个斜线后跟一个字母，或几个字母，或一个字，例如。/f，/file

optparse不支持这些选项语法，它们从不会。这是故意的：前三个是任何环境下的非标准，如果您专门针对VMS，MS-DOS和/或Windows，最后一个是有意义的。

选项参数

在选项后面的参数与该选项紧密相关，并且当该选项为时，从参数列表中消耗。使用optparse，选项参数可以在其选项的单独参数中：

-f foo
--file foo

或包含在同一个参数中：

-ffoo
--file=foo

通常，给定的选项或者接受一个参数，或者不接受。很多人想要一个“可选的选项参数”功能，意味着一些选项将接受一个参数，如果他们看到它，如果他们不会。这有点有争议，因为它使解析模糊：如果-a采用可选参数，而-b是另一个选项，我们如何解释-ab由于这种模糊性，optparse不支持此功能。

位置参数

在选项被解析之后在参数列表中剩余的东西，即后选项及其参数已解析并从参数列表中删除。

必需选项

必须在命令行上提供的选项；注意“需要的选项”一词在英语中是自相矛盾的。optparse不会阻止您实施所需的选项，但也不会给您很多帮助。

例如，考虑这个假设的命令行：

prog -v --report report.txt foo bar

-v和--report都是选项。假设--report有一个参数，report.txt是一个选项参数。foo和bar是位置参数。

36.1.1.2. What are options for?¶

选项用于提供额外的信息来调整或定制程序的执行。如果不清楚，选项通常为可选。一个程序应该能够运行很好，没有任何选择。（从Unix或GNU工具集中选择一个随机程序。它可以运行没有任何选项，仍然有意义吗？主要的例外是find，tar和dd - 所有这些都是突变的怪物，混乱界面）。

许多人希望他们的计划有“必要的选择”。想想吧。如果需要，则不可选！如果有一条信息，你的程序绝对需要为了成功运行，这是位置参数是什么。

作为良好命令行界面设计的示例，考虑用于复制文件的谦逊cp实用程序。尝试复制文件而不提供目标和至少一个源没有多大意义。因此，如果没有参数运行，cp将失败。但是，它有一个灵活，有用的语法，不需要任何选项：

cp SOURCE DEST
cp SOURCE ... DEST-DIR

你可以得到相当遥远的。大多数cp实现提供了一组选项来精确地调整文件的复制方式：可以保留模式和修改时间，避免遵循符号链接，在删除现有文件之前请求等。但是没有一个会分散于cp的核心任务，即将一个文件复制到另一个文件，或将几个文件复制到另一个目录。

36.1.1.3. What are positional arguments for?¶

位置参数是你的程序绝对，积极地要求运行的那些信息。

良好的用户界面应该具有尽可能少的绝对要求。如果您的程序需要17条不同的信息才能成功运行，那么从用户处获取信息并不重要，因为大多数人会在成功运行之前放弃并离开这些信息。程序。无论用户界面是命令行，配置文件还是GUI，这都适用：如果您对用户提出了很多要求，他们大多数都会放弃。

总之，尽量减少用户绝对需要提供的信息量 - 尽可能使用合理的默认值。当然，你也想让你的程序相当灵活。这是什么选项。同样，如果它们是配置文件中的条目，GUI的“首选项”对话框中的窗口小部件或命令行选项，则实现的选项越多，程序越灵活，并且越复杂其实现就变成了。太多的灵活性也有缺点，当然；太多的选项可能会淹没用户，使您的代码更难以维护。

36.1.2. Tutorial¶

虽然optparse非常灵活和强大，但在大多数情况下也可以直接使用。本节涵盖任何基于optparse的程序所共有的代码模式。

首先，需要导入OptionParser类；那么，在早期的主程序中，创建一个OptionParser实例：

from optparse import OptionParser
...
parser = OptionParser()

然后可以开始定义选项。基本语法是：

parser.add_option(opt_str, ...,
                  attr=value, ...)

每个选项都有一个或多个选项字符串，例如-f或--file，以及几个选项属性，用于指示optparse在命令行遇到该选项时该怎么做。

通常，每个选项将具有一个短选项字符串和一个长选项字符串，例如。：

parser.add_option("-f", "--file", ...)

您可以自由定义尽可能多的短选项字符串和尽可能多的长选项字符串（包括零），只要至少有一个选项字符串。

传递给OptionParser.add_option()的选项字符串实际上是该调用定义的选项的标签。为了简洁起见，我们经常在命令行上参考遇到选项；实际上，optparse遇到选项字符串，并从中查找选项。

一旦定义了所有选项，指示optparse解析程序的命令行：

(options, args) = parser.parse_args()

（如果你喜欢，你可以传递一个自定义参数列表到parse_args()，但这很少需要：默认情况下使用sys.argv[1:]

parse_args()返回两个值：

options，包含所有选项的值的对象，例如。如果--file采用单个字符串参数，则options.file将是用户提供的文件，或None不提供该选项
args，解析选项后剩余的位置参数列表

本教程部分仅介绍四个最重要的选项属性：action，type，dest（目标）和help其中，action是最基本的。

36.1.2.1. Understanding option actions¶

操作告诉optparse在命令行遇到选项时该怎么做。有一组固定的动作硬编码到optparse中；添加新操作是Extending optparse部分中介绍的高级主题。大多数操作会告诉optparse在某些变量中存储值，例如，从命令行取一个字符串并将其存储在options的属性中。

如果您未指定选项操作，optparse默认为store。

36.1.2.2. The store action¶

最常见的选项操作是store，它告诉optparse接受下一个参数（或当前参数的其余部分），确保它是正确的类型，将其存储到您选择的目的地。

例如：

parser.add_option("-f", "--file",
                  action="store", type="string", dest="filename")

现在让我们组成一个假的命令行，并要求optparse来解析它：

args = ["-f", "foo.txt"]
(options, args) = parser.parse_args(args)

当optparse看到选项字符串-f时，它会使用下一个参数foo.txt，并将其存储在options.filename。So, after this call to parse_args(), options.filename is "foo.txt".

optparse支持的其他某些选项类型为int和float。这里是一个期望一个整数参数的选项：

parser.add_option("-n", type="int", dest="num")

请注意，此选项没有长选项字符串，这是完全可以接受的。此外，没有明确的操作，因为默认值为store。

让我们剖析另一个假的命令行。这一次，我们将阻塞选项参数，直到选项：因为-n42（一个参数）等效于-n 42 （两个参数），代码

(options, args) = parser.parse_args(["-n42"])
print(options.num)

将打印42。

如果您未指定类型，则optparse假定为string。结合默认操作为store的事实，这意味着我们的第一个例子可以更短：

parser.add_option("-f", "--file", dest="filename")

如果您不提供目的地，则optparse会从选项字符串中找出明智的默认值：如果第一个长选项字符串为--foo-bar，则默认目标是foo_bar。如果没有长选项字符串，optparse会查看第一个短选项字符串：-f的默认目标是f。

optparse还包括内建complex类型。在Extending optparse部分中介绍了添加类型。

36.1.2.3. Handling boolean (flag) options¶

标志选项 - 当看到特定选项时，将变量设置为true或false - 非常常见。optparse通过两个单独的操作（store_true和store_false）支持它们。例如，您可能有一个verbose标志，它使用-v打开，并且关闭-q：

parser.add_option("-v", action="store_true", dest="verbose")
parser.add_option("-q", action="store_false", dest="verbose")

这里我们有两个不同的选项与相同的目的地，这是完全OK。（这只是意味着你必须在设置默认值时有点小心 - 见下文）。

当optparse在命令行遇到-v时，会将options.verbose设置为True；当遇到-q时，options.verbose设置为False。

36.1.2.4. Other actions¶

optparse支持的其他一些操作包括：

"store_const": 存储恒定值
"append": 将此选项的参数附加到列表
"count": 将计数器递增1
"callback": 调用指定的函数

这些在Reference Guide，参考指南和Option Callbacks部分中有所介绍。

36.1.2.5. Default values¶

所有上述示例涉及在看到某些命令行选项时设置一些变量（“目标”）。如果没有看到这些选项，会发生什么？由于我们没有提供任何默认值，因此它们都设置为None。这通常很好，但有时你想要更多的控制。optparse允许您为每个目标提供默认值，在分析命令行之前分配该默认值。

首先，考虑verbose / quiet示例。如果我们希望optparse将verbose设置为True，除非出现-q

parser.add_option("-v", action="store_true", dest="verbose", default=True)
parser.add_option("-q", action="store_false", dest="verbose")

由于默认值适用于目标，而不适用于任何特定选项，并且这两个选项恰好具有相同的目标，这完全等效：

parser.add_option("-v", action="store_true", dest="verbose")
parser.add_option("-q", action="store_false", dest="verbose", default=True)

考虑这个：

parser.add_option("-v", action="store_true", dest="verbose", default=False)
parser.add_option("-q", action="store_false", dest="verbose", default=True)

同样，verbose的默认值为True：为任何特定目标提供的最后一个默认值是计数的值。

指定默认值的更清晰的方法是OptionParser的set_defaults()方法，您可以在调用parse_args()之前随时调用该方法：

parser.set_defaults(verbose=True)
parser.add_option(...)
(options, args) = parser.parse_args()

与之前一样，为给定选项目标指定的最后一个值是计数的值。为了清楚起见，尝试使用一种方法或另一种方法设置默认值，而不是两者。

36.1.2.6. Generating help¶

optparse的自动生成帮助和使用文本的能力对于创建用户友好的命令行界面非常有用。您所要做的就是为每个选项提供help值，并为整个程序提供一个简短的使用消息。这里是一个OptionParser填充用户友好（文档）选项：

usage = "usage: %prog [options] arg1 arg2"
parser = OptionParser(usage=usage)
parser.add_option("-v", "--verbose",
                  action="store_true", dest="verbose", default=True,
                  help="make lots of noise [default]")
parser.add_option("-q", "--quiet",
                  action="store_false", dest="verbose",
                  help="be vewwy quiet (I'm hunting wabbits)")
parser.add_option("-f", "--filename",
                  metavar="FILE", help="write output to FILE")
parser.add_option("-m", "--mode",
                  default="intermediate",
                  help="interaction mode: novice, intermediate, "
                       "or expert [default: %default]")

如果optparse在命令行遇到-h或--help，或者如果您只是调用parser.print_help()，它会将以下内容打印到标准输出：

Usage: <yourscript> [options] arg1 arg2

Options:
  -h, --help            show this help message and exit
  -v, --verbose         make lots of noise [default]
  -q, --quiet           be vewwy quiet (I'm hunting wabbits)
  -f FILE, --filename=FILE
                        write output to FILE
  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or
                        expert [default: intermediate]

（如果帮助输出由帮助选项触发，则在打印帮助文本后，optparse退出。）

这里有很多事情可以帮助optparse生成最好的帮助消息：

该脚本定义自己的使用消息：
```
usage = "usage: %prog [options] arg1 arg2"
```
optparse将用法字符串中的%prog扩展为当前程序的名称，即os.path.basename(sys.argv[0])。然后在详细选项帮助之前打印扩展字符串。
如果您不提供使用字符串，optparse使用平淡但明智的默认值：“用法：％prog [options]“，如果你的脚本没有任何位置参数，这是很好。
每个选项定义一个帮助字符串，不用担心换行 - optparse会处理换行并使帮助输出看起来不错。
为“模式”选项：
```
-m MODE, --mode=MODE
```
这里，“MODE”被称为元变量：它代表用户期望提供给-m / --mode的参数。默认情况下，optparse将目标变量名称转换为大写，并将其用作元变量。有时，这不是你想要的 - 例如，--filename选项显式设置metavar="FILE"，导致自动生成的选项描述：
```
-f FILE, --filename=FILE
```
这对于不只是节省空间很重要：手动写的帮助文本使用元变量FILE来引用用户，因为半形式语法 -f FILE和非正式语义描述“写输出到FILE”。这是一个简单但有效的方法，使您的帮助文本更清晰，更有用的最终用户。
具有默认值的选项可以包括帮助字符串中的%default - optparse将替换为该选项默认值的str()。如果某个选项没有默认值（或默认值为None），则%default会展开为none。

36.1.2.6.1. Grouping Options¶

当处理许多选项时，将这些选项分组以获得更好的帮助输出是方便的。OptionParser可以包含多个选项组，每个选项组可以包含多个选项。

使用类OptionGroup获取选项组：

class optparse.OptionGroup(parser, title, description=None)¶

哪里

解析器是OptionParser实例中的组将被放置到
title是组标题
description，可选，是组的长说明

OptionGroup继承自OptionContainer（如OptionParser），因此add_option()方法可用于添加选项到组。

一旦声明了所有选项，使用OptionParser方法add_option_group()将组添加到先前定义的解析器。

继续前面部分中定义的解析器，向解析器添加OptionGroup很容易：

group = OptionGroup(parser, "Dangerous Options",
                    "Caution: use these options at your own risk.  "
                    "It is believed that some of them bite.")
group.add_option("-g", action="store_true", help="Group option.")
parser.add_option_group(group)

这将产生以下帮助输出：

Usage: <yourscript> [options] arg1 arg2

Options:
  -h, --help            show this help message and exit
  -v, --verbose         make lots of noise [default]
  -q, --quiet           be vewwy quiet (I'm hunting wabbits)
  -f FILE, --filename=FILE
                        write output to FILE
  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or
                        expert [default: intermediate]

  Dangerous Options:
    Caution: use these options at your own risk.  It is believed that some
    of them bite.

    -g                  Group option.

一个更完整的示例可能涉及使用多个组：仍然扩展前一个示例：

group = OptionGroup(parser, "Dangerous Options",
                    "Caution: use these options at your own risk.  "
                    "It is believed that some of them bite.")
group.add_option("-g", action="store_true", help="Group option.")
parser.add_option_group(group)

group = OptionGroup(parser, "Debug Options")
group.add_option("-d", "--debug", action="store_true",
                 help="Print debug information")
group.add_option("-s", "--sql", action="store_true",
                 help="Print all SQL statements executed")
group.add_option("-e", action="store_true", help="Print every action done")
parser.add_option_group(group)

导致以下输出：

Usage: <yourscript> [options] arg1 arg2

Options:
  -h, --help            show this help message and exit
  -v, --verbose         make lots of noise [default]
  -q, --quiet           be vewwy quiet (I'm hunting wabbits)
  -f FILE, --filename=FILE
                        write output to FILE
  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or expert
                        [default: intermediate]

  Dangerous Options:
    Caution: use these options at your own risk.  It is believed that some
    of them bite.

    -g                  Group option.

  Debug Options:
    -d, --debug         Print debug information
    -s, --sql           Print all SQL statements executed
    -e                  Print every action done

另一个有趣的方法，特别是当使用选项组以编程方式工作时：

OptionParser.get_option_group(opt_str)¶: 返回OptionGroup，其中包含short或long选项字符串opt_str（例如，'-o'或'--option'）。如果没有这样的OptionGroup，则返回None。

36.1.2.7. Printing a version string¶

与简短的使用字符串类似，optparse也可以为您的程序打印版本字符串。您必须将该字符串作为OptionParser的version参数提供：

parser = OptionParser(usage="%prog [-f] [-q]", version="%prog 1.0")

%prog会像在usage中一样展开。除此之外，version可以包含任何您喜欢的内容。当您提供时，optparse会自动向解析器添加--version选项。如果在命令行上遇到此选项，它会扩展version字符串（通过替换%prog），将其打印到stdout并退出。

例如，如果您的脚本名为/usr/bin/foo：

$ /usr/bin/foo --version
foo 1.0

可以使用以下两种方法打印并获取version字符串：

OptionParser.print_version(file=None)¶: 将当前程序的版本消息（self.version）打印到文件（默认stdout）。与print_usage()一样，self.version中的任何%prog会替换为当前程序的名称。如果self.version为空或未定义，则不执行任何操作。

OptionParser.get_version()¶: 与print_version()相同，但返回版本字符串，而不是打印。

36.1.2.8. How `optparse` handles errors¶

有两种类型的错误，optparse需要担心：程序员错误和用户错误。程序员错误通常是对OptionParser.add_option()的错误调用，例如无效的选项字符串，未知的选项属性，缺少的选项属性等。这些以通常的方式处理：引发异常（optparse.OptionError或TypeError），并让程序崩溃。

处理用户错误是更重要的，因为无论你的代码是多么稳定，它们都能保证发生。optparse can automatically detect some user errors, such as bad option arguments (passing -n 4x where -n takes an integer argument), missing arguments (-n at the end of the command line, where -n takes an argument of any type). 此外，您可以调用OptionParser.error()来通知应用程序定义的错误条件：

(options, args) = parser.parse_args()
...
if options.a and options.b:
    parser.error("options -a and -b are mutually exclusive")

在任一情况下，optparse以相同的方式处理错误：它将程序的使用消息和错误消息打印到标准错误，并退出，错误状态为2。

考虑上面的第一个示例，其中用户将4x传递到接受整数的选项：

$ /usr/bin/foo -n 4x
Usage: foo [options]

foo: error: option -n: invalid integer value: '4x'

或者，用户未能传递值：

$ /usr/bin/foo -n
Usage: foo [options]

foo: error: -n option requires an argument

optparse - 生成的错误消息一定要提及错误中涉及的选项；确保在从应用程序代码调用OptionParser.error()时执行相同操作。

如果optparse的默认错误处理行为不符合您的需要，您需要将OptionParser子类化并覆盖其exit()和/或error()方法。

36.1.2.9. Putting it all together¶

基于optparse的脚本通常如下所示：

from optparse import OptionParser
...
def main():
    usage = "usage: %prog [options] arg"
    parser = OptionParser(usage)
    parser.add_option("-f", "--file", dest="filename",
                      help="read data from FILENAME")
    parser.add_option("-v", "--verbose",
                      action="store_true", dest="verbose")
    parser.add_option("-q", "--quiet",
                      action="store_false", dest="verbose")
    ...
    (options, args) = parser.parse_args()
    if len(args) != 1:
        parser.error("incorrect number of arguments")
    if options.verbose:
        print("reading %s..." % options.filename)
    ...

if __name__ == "__main__":
    main()

36.1.3. Reference Guide¶

36.1.3.1. Creating the parser¶

使用optparse的第一步是创建一个OptionParser实例。

class optparse.OptionParser(...)¶

OptionParser构造函数没有必需的参数，但有一些可选的关键字参数。您应该始终将它们作为关键字参数传递，即不要依赖于声明参数的顺序。

usage（默认值：“％prog [options]”）: 当程序运行不正确或使用帮助选项时打印的使用摘要。When optparse prints the usage string, it expands %prog to os.path.basename(sys.argv[0]) (or to prog if you passed that keyword argument). 要抑制使用消息，请传递特殊值optparse.SUPPRESS_USAGE。
option_list（默认值：[]）: 用于用解析器填充的Option对象列表。standard_option_list（可以由OptionParser子类设置的类属性）中的任何选项之后，但在任何版本或帮助选项之前添加option_list中的选项。已弃用；在创建解析器后使用add_option()。
option_class（默认值：optparse.Option）: 向add_option()中的解析器添加选项时使用的类。
version（默认值：None）: 当用户提供版本选项时要打印的版本字符串。如果您为version提供真实值，optparse会自动使用单个选项字符串--version添加版本选项。子串%prog的扩展方法与usage相同。
conflict_handler（默认值："error"）: 指定在将具有冲突选项字符串的选项添加到解析器时应执行的操作；请参阅Conflicts between options部分。
description（默认值：None）: 一个文本段，简要概述您的程序。optparse重新格式化此段落以适合当前终端宽度，并在用户请求帮助时（在usage之后，但在选项列表之前）打印。
formatter（默认值：a IndentedHelpFormatter）: 一个用于打印帮助文本的optparse.HelpFormatter的实例。optparse为此提供了两个具体类：IndentedHelpFormatter和TitledHelpFormatter。
add_help_option（默认值：True）: 如果为true，则optparse将向解析器添加帮助选项（带有选项字符串-h和--help）。
prog: The string to use when expanding %prog in usage and version instead of os.path.basename(sys.argv[0]).
epilog（默认值：None）: 在选项帮助后打印的帮助文本的一个段落。

36.1.3.2. Populating the parser¶

首选方法是使用OptionParser.add_option()，如Tutorial中所示。add_option()可以通过以下两种方式之一调用：

传递一个选项实例（由make_option()返回）
传递make_option()可接受的位置和关键字参数的任何组合（即到Option构造函数），它将为您创建Option实例

另一种方法是将一个预构建的Option实例列表传递给OptionParser构造函数，如：

option_list = [
    make_option("-f", "--filename",
                action="store", type="string", dest="filename"),
    make_option("-q", "--quiet",
                action="store_false", dest="verbose"),
    ]
parser = OptionParser(option_list=option_list)

（make_option()是用于创建Option实例的工厂函数；目前它是Option构造函数的别名。未来版本的optparse可能会将Option拆分成几个类，而make_option()会选择正确的类来实例化。不要直接实例化Option）。

36.1.3.3. Defining options¶

每个选项实例表示一组同义命令行选项字符串，例如，-f和--file。您可以指定任意数量的短期或长期期权字符串，但必须至少指定一个总期权字符串。

创建Option实例的规范方法是使用OptionParser的add_option()方法。

OptionParser.add_option(option)¶

OptionParser。 add_option （ * opt_str，attr = value，。 .. ）

要定义只有一个短选项字符串的选项：

parser.add_option("-f", attr=value, ...)

并定义一个只有一个长选项字符串的选项：

parser.add_option("--foo", attr=value, ...)

关键字参数定义新Option对象的属性。最重要的选项属性是action，它在很大程度上决定了哪些其他属性相关或需要。如果您传递不相关的选项属性，或无法传递所需的属性，则optparse引发OptionError例外，说明您的错误。

选项的操作确定在命令行遇到此选项时，optparse的作用。硬编码到optparse中的标准选项操作包括：

"store": 存储此选项的参数（默认）
"store_const": 存储恒定值
"store_true": 存储真值
"store_false": 存储假值
"append": 将此选项的参数附加到列表
"append_const": 将常量值附加到列表
"count": 将计数器递增1
"callback": 调用指定的函数
"help": 打印包含所有选项和文档的使用消息

（如果您不提供操作，默认值为"store"。对于此操作，您还可以提供type和dest选项属性；请参阅Standard option actions。）

如你所见，大多数操作涉及在某处存储或更新值。optparse始终为此创建一个特殊对象，通常称为options（它恰好是optparse.Values的实例）。根据dest（destination）选项属性，将选项参数（和各种其他值）存储为此对象的属性。

例如，当你打电话

parser.parse_args()

第一件事optparse之一是创建options对象：

options = Values()

如果使用定义了此解析器中的某个选项

parser.add_option("-f", "--file", action="store", type="string", dest="filename")

并且正在解析的命令行包括以下任一项：

-ffoo
-f foo
--file=foo
--file foo

那么optparse会在看到此选项时执行相同的操作

options.filename = "foo"

type和dest选项属性与action几乎一样重要，但action 所有选项。

36.1.3.4. Option attributes¶

以下选项属性可以作为关键字参数传递给OptionParser.add_option()。如果您传递与特定选项不相关的选项属性，或未能传递所需的选项属性，optparse引发OptionError。

Option.action¶

（默认值："store"）

当在命令行上看到此选项时，确定optparse的行为；可用选项在here中记录。

Option.type¶

（默认值："string"）

此选项所期望的参数类型（例如，"string"或"int"）；可用的选项类型在here中记录。

Option.dest¶

（默认：派生自选项字符串）

如果选项的操作意味着在某处写入或修改值，则会告诉optparse在哪里写入：dest命名options对象的属性optparse在解析命令行时构建。

Option.default¶: 如果在命令行中未显示该选项，则用于此选项目标的值。另请参见OptionParser.set_defaults()。

Option.nargs¶

（默认值：1）

当看到此选项时，应该使用type类型的参数数。如果> 1，则optparse将存储值的元组到dest。

Option.const¶: 对于存储常量值的操作，要存储的常量值。

Option.choices¶: 对于类型"choice"的选项，用户可以选择的字符串列表。

Option.callback¶: 对于具有操作"callback"的选项，显示此选项时调用callable。有关传递给可调用对象的参数的详细信息，请参见Option Callbacks一节。

Option.callback_args¶
Option.callback_kwargs¶: 在四个标准回调参数后传递给callback的附加位置和关键字参数。

Option.help¶: 在用户提供help选项（例如--help）之后列出所有可用选项时，此选项的帮助文字将打印。如果没有提供帮助文本，则将列出没有帮助文本的选项。要隐藏此选项，请使用特殊值optparse.SUPPRESS_HELP。

Option.metavar¶

（默认：派生自选项字符串）

打印帮助文本时要使用的选项参数。有关示例，请参阅Tutorial一节。

36.1.3.5. Standard option actions¶

各种选项操作都有不同的要求和效果。大多数操作都有几个相关的选项属性，您可以指定它们来指导optparse的行为；一些有必需属性，您必须为使用该操作的任何选项指定属性。

"store" [relevant：type，dest，nargs，choices]
该选项必须后跟一个参数，该参数将根据type转换为值，并存储在dest中。如果nargs> 1，将从命令行使用多个参数；所有将根据type进行转换并存储为dest作为元组。请参阅Standard option types部分。
如果提供choices（字符串的列表或元组），则类型默认为"choice"。
如果未提供type，则默认为"string"。
如果未提供dest，则optparse从第一个长选项字符串派生目标（例如，--foo-bar表示foo_bar）。如果没有长选项字符串，则optparse从第一个短选项字符串中导出目标（例如，-f暗示f）。
例：
```
parser.add_option("-f")
parser.add_option("-p", type="float", nargs=3, dest="point")
```
解析命令行
```
-f foo.txt -p 1 -3.5 4 -fbar.txt
```
optparse将设置
```
options.f = "foo.txt"
options.point = (1.0, -3.5, 4.0)
options.f = "bar.txt"
```

"store_const" [必需：const；相关：dest]

值const存储在dest中。

例：

parser.add_option("-q", "--quiet",
                  action="store_const", const=0, dest="verbose")
parser.add_option("-v", "--verbose",
                  action="store_const", const=1, dest="verbose")
parser.add_option("--noisy",
                  action="store_const", const=2, dest="verbose")

如果看到--noisy，则optparse将置位

options.verbose = 2

"store_true" [相关：dest]
"store_const"的特殊情况，它将真实值存储到dest。

"store_false" [相关：dest]

像"store_true"，但存储假值。

例：

parser.add_option("--clobber", action="store_true", dest="clobber")
parser.add_option("--no-clobber", action="store_false", dest="clobber")

"append" [relevant：type，dest，nargs，choices]
该选项必须后跟一个参数，该参数附加到dest中的列表。如果没有提供dest的默认值，当optparse在命令行首次遇到此选项时，会自动创建一个空列表。如果nargs> 1，则会消耗多个参数，并将长度nargs的元组附加到dest。
type和dest的默认值与"store"操作相同。
例：
```
parser.add_option("-t", "--tracks", action="append", type="int")
```
如果在命令行上看到-t3，则optparse等效于：
```
options.tracks = []
options.tracks.append(int("3"))
```
如果稍后，看到--tracks=4，它会：
```
options.tracks.append(int("4"))
```
append操作会对选项的当前值调用append方法。这意味着指定的任何默认值必须具有append方法。这也意味着如果默认值不为空，默认元素将存在于该选项的解析值中，来自命令行的任何值都附加在这些默认值之后：
```
>>> parser.add_option("--files", action="append", default=['~/.mypkg/defaults'])
>>> opts, args = parser.parse_args(['--files', 'overrides.mypkg'])
>>> opts.files
['~/.mypkg/defaults', 'overrides.mypkg']
```
"append_const" [必需：const；相关：dest]
像"store_const"，但值const附加到dest；与"append"，dest默认为None一样，第一次遇到此选项时会自动创建一个空列表。
"count" [relevant：dest]
递增存储在dest的整数。如果未提供默认值，则在第一次递增之前将dest设置为零。
例：
```
parser.add_option("-v", action="count", dest="verbosity")
```
在命令行上第一次看到-v，optparse等效于：
```
options.verbosity = 0
options.verbosity += 1
```
每次后续发生的-v结果
```
options.verbosity += 1
```
"callback" [必需：callback；相关：type，nargs，callback_args，callback_kwargs]
调用callback指定的函数，它被调用
```
func(option, opt_str, value, parser, *args, **kwargs)
```
有关详细信息，请参阅Option Callbacks一节。

"help"

打印当前选项解析器中所有选项的完整帮助消息。帮助消息由传递给OptionParser构造函数的usage字符串和传递给每个选项的help字符串构成。

如果没有为选项提供help字符串，它仍会在帮助消息中列出。要完全省略某个选项，请使用特殊值optparse.SUPPRESS_HELP。

optparse会自动向所有OptionParsers添加help选项，因此通常不需要创建一个。

例：

from optparse import OptionParser, SUPPRESS_HELP

# usually, a help option is added automatically, but that can
# be suppressed using the add_help_option argument
parser = OptionParser(add_help_option=False)

parser.add_option("-h", "--help", action="help")
parser.add_option("-v", action="store_true", dest="verbose",
                  help="Be moderately verbose")
parser.add_option("--file", dest="filename",
                  help="Input file to read data from")
parser.add_option("--secret", help=SUPPRESS_HELP)

If optparse sees either -h or --help on the command line, it will print something like the following help message to stdout (assuming sys.argv[0] is "foo.py"):

Usage: foo.py [options]

Options:
  -h, --help        Show this help message and exit
  -v                Be moderately verbose
  --file=FILENAME   Input file to read data from

打印帮助消息后，optparse会使用sys.exit(0)终止进程。

"version"
将提供给OptionParser的版本号打印到stdout并退出。版本号实际上是由OptionParser的print_version()方法格式化和打印的。通常只有当version参数提供给OptionParser构造函数时才相关。与help选项一样，您很少会创建version选项，因为optparse会在需要时自动添加。

36.1.3.6. Standard option types¶

optparse有五种内建选项类型："string"，"int"，"choice"，"float"和"complex"。如果您需要添加新的选项类型，请参阅Extending optparse一节。

字符串选项的参数不以任何方式进行检查或转换：命令行上的文本将按原样存储在目标中（或传递到回调）。

整数参数（类型"int"）解析如下：

如果数字以0x开头，则将其解析为十六进制数
如果数字以0开头，则将其解析为八进制数
如果数字以0b开头，则将其解析为二进制数
否则，该数字将解析为十进制数

通过使用适当的基数（2,8,10或16）调用int()来完成转换。如果这失败，optparse，尽管有一个更有用的错误消息。

使用float()和complex()直接转换"float"和"complex"

"choice"选项是"string"选项的子类型。choices选项属性（字符串序列）定义允许的选项参数集。optparse.check_choice()将用户提供的选项参数与此主列表进行比较，如果给定的字符串无效，则引用OptionValueError。

36.1.3.7. Parsing arguments¶

创建和填充OptionParser的整个要点是调用其parse_args()方法：

(options, args) = parser.parse_args(args=None, values=None)

其中输入参数为

args: 要处理的参数列表（默认值：sys.argv[1:]）
values: 用于存储选项参数的optparse.Values对象（默认：Values的新实例） - 如果给定现有对象，则不会初始化选项默认值

和返回值是

options: 与values中传递的相同对象或由optparse创建的optparse.Values实例
args: 所有选项后的剩余位置参数已处理

最常见的用法是不提供关键字参数。如果您提供values，它将被重复的setattr()调用（大约一个用于存储到选项目标的每个选项参数）修改，并由parse_args()。

如果parse_args()在参数列表中遇到任何错误，它会调用OptionParser的error()方法，并显示相应的最终用户错误消息。这将最终终止您的进程，退出状态为2（命令行错误的传统Unix退出状态）。

36.1.3.8. Querying and manipulating your option parser¶

选项解析器的默认行为可以稍微自定义，你也可以勾选你的选项解析器，看看有什么。OptionParser提供了几种方法来帮助您：

OptionParser.disable_interspersed_args()¶

将解析设置为在第一个非选项上停止。例如，如果-a和-b都是不带参数的简单选项，则optparse通常接受此语法：

prog -a arg1 -b arg2

并将其视为等效

prog -a -b arg1 arg2

要禁用此功能，请调用disable_interspersed_args()。这将恢复传统的Unix语法，其中选项解析使用第一个非选项参数停止。

如果你有一个命令处理器运行另一个命令，它有自己的选项，并且你想确保这些选项不被混淆使用这个。例如，每个命令可能有不同的选项集。

OptionParser.enable_interspersed_args()¶: 将解析设置为在第一个非选项上不停止，允许具有命令参数的散列开关。这是默认行为。

OptionParser.get_option(opt_str)¶: 如果没有选项具有该选项字符串，则返回选项字符串opt_str或None的Option实例。

OptionParser.has_option(opt_str)¶: 如果OptionParser具有选项字符串opt_str（例如，-q或--verbose），则返回true。

OptionParser.remove_option(opt_str)¶: 如果OptionParser具有对应于opt_str的选项，则该选项将被删除。如果该选项提供任何其他选项字符串，那么所有这些选项字符串都将无效。如果属于此OptionParser的任何选项中未发生opt_str，则引发ValueError。

36.1.3.9. Conflicts between options¶

如果你不小心，很容易定义具有冲突选项字符串的选项：

parser.add_option("-n", "--dry-run", ...)
...
parser.add_option("-n", "--noisy", ...)

（如果你已经使用一些标准选项定义了自己的OptionParser子类，这一点尤其如此。）

每次添加选项时，optparse都会检查与现有选项的冲突。如果它发现任何，它调用当前的冲突处理机制。您可以在构造函数中设置冲突处理机制：

parser = OptionParser(..., conflict_handler=handler)

或单独调用：

parser.set_conflict_handler(handler)

可用的冲突处理程序是：

"error" (default)

assume option conflicts are a programming error and raise OptionConflictError

"resolve"

resolve option conflicts intelligently (see below)

例如，让我们定义一个OptionParser，可以智能解决冲突，并向其添加冲突选项：

parser = OptionParser(conflict_handler="resolve")
parser.add_option("-n", "--dry-run", ..., help="do no harm")
parser.add_option("-n", "--noisy", ..., help="be noisy")

此时，optparse检测到之前添加的选项已在使用-n选项字符串。由于conflict_handler是"resolve"，它通过从早期选项的选项字符串列表中删除-n来解决此问题。现在--dry-run是用户激活该选项的唯一方法。如果用户请求帮助，帮助消息将反映：

Options:
  --dry-run     do no harm
  ...
  -n, --noisy   be noisy

可以删除先前添加的选项的选项字符串，直到没有剩余，并且用户无法从命令行调用该选项。在这种情况下，optparse会完全移除该选项，因此它不会显示在帮助文本或其他位置。继承我们现有的OptionParser：

parser.add_option("--dry-run", ..., help="new dry-run option")

此时，原始的-n / --dry-run选项不再可访问，因此optparse删除它，留下此帮助文本：

Options:
  ...
  -n, --noisy   be noisy
  --dry-run     new dry-run option

36.1.3.10. Cleanup¶

OptionParser实例具有多个循环引用。这不应该是Python的垃圾收集器的问题，但你可能希望打破循环引用显式地通过调用destroy()在你的OptionParser一旦你完成它。这在长期运行的应用程序中特别有用，其中可以从OptionParser访问大型对象图。

36.1.3.11. Other methods¶

OptionParser支持几种其他公共方法：

OptionParser.set_usage(usage)¶: 根据上述usage构造函数关键字参数的规则设置用法字符串。传递None设置默认使用字符串；请使用optparse.SUPPRESS_USAGE抑制使用消息。

OptionParser.print_usage(file=None)¶: 将当前程序的使用消息（self.usage）打印到文件（默认stdout）。在self.usage中的任何出现的字符串%prog将替换为当前程序的名称。如果self.usage为空或未定义，则不执行任何操作。

OptionParser.get_usage()¶: 与print_usage()相同，但返回使用字符串，而不是打印。

OptionParser.set_defaults(dest=value, ...)¶

一次为多个选项目的地设置默认值。使用set_defaults()是设置选项的默认值的首选方法，因为多个选项可以共享同一个目标。例如，如果几个“模式”选项都设置了相同的目标，任何一个都可以设置默认值，最后一个获胜：

parser.add_option("--advanced", action="store_const",
                  dest="mode", const="advanced",
                  default="novice")    # overridden below
parser.add_option("--novice", action="store_const",
                  dest="mode", const="novice",
                  default="advanced")  # overrides above setting

为了避免这种混淆，使用set_defaults()：

parser.set_defaults(mode="advanced")
parser.add_option("--advanced", action="store_const",
                  dest="mode", const="advanced")
parser.add_option("--novice", action="store_const",
                  dest="mode", const="novice")

36.1.4. Option Callbacks¶

当optparse的内建动作和类型不足以满足您的需要时，您有两种选择：extend optparse或定义回调选项。扩展optparse是更通用的，但对于很多简单的情况来说是过度的。通常一个简单的回调是所有你需要的。

定义回调选项有两个步骤：

使用"callback"操作定义选项本身
写回调；这是一个至少需要四个参数的函数（或方法），如下所述

36.1.4.1. Defining a callback option¶

和往常一样，定义回调选项的最简单方法是使用OptionParser.add_option()方法。除了action，您必须指定的唯一选项属性是callback，该函数调用：

parser.add_option("-c", action="callback", callback=my_callback)

callback是一个函数（或其他可调用对象），因此，在创建此回调选项时，必须已经定义my_callback()。在这个简单的情况下，optparse甚至不知道-c是否接受任何参数，这通常意味着该选项没有参数 - 只存在-c在命令行上是所有需要知道的。但在某些情况下，您可能希望回调消耗任意数量的命令行参数。这是写回调变得棘手；本节稍后将介绍。

optparse始终将四个特定参数传递给回调，并且只有通过callback_args和callback_kwargs指定的参数才会传递额外的参数。因此，最小回调函数声明是：

def my_callback(option, opt, value, parser):

回调的四个参数描述如下。

在定义回调选项时，您可以提供其他几个选项属性：

type: has its usual meaning: as with the "store" or "append" actions, it instructs optparse to consume one argument and convert it to type. 但是，optparse不会将转换值存储在任何位置，而是将其传递给回调函数。
nargs: 也具有其通常的含义：如果提供并且> 1，则optparse将消耗nargs自变量，每个自变量必须可转换为type。然后将一个转换值的元组传递给您的回调。
callback_args: 一个额外的位置参数传递给回调的元组
callback_kwargs: 传递给回调的额外关键字参数的字典

36.1.4.2. How callbacks are called¶

所有回调的调用如下：

func(option, opt_str, value, parser, *args, **kwargs)

哪里

option

是调用回调的选项实例

opt_str

是在触发回调的命令行上看到的选项字符串。（如果使用缩写长选项，则opt_str将是完整的，规范的选项字符串（例如）。如果用户将--foo放在命令行上作为--foobar的缩写，则opt_str将为"--foobar"。）

value

是在命令行上看到的此选项的参数。optparse只有在设置type时才需要参数； value的类型将是选项类型所隐含的类型。如果此选项的type为None（不需要参数），则value将为None。如果nargs> 1，则value将是适当类型的值的元组。

parser

是OptionParser实例驱动整个事情，主要有用，因为您可以通过其实例属性访问一些其他有趣的数据：

parser.largs: 当前剩余参数列表，即。已被消耗但既不是选项也不是选项参数的参数。随意修改parser.largs，例如通过添加更多的参数。（此列表将变为args，parse_args()的第二个返回值。）
parser.rargs: 剩余参数的当前列表，即。其中opt_str和value（如果适用）已删除，只有后面的参数仍然存在。随意修改parser.rargs，例如通过消耗更多的参数。
parser.values: 缺省存储选项值的对象（optparse.OptionValues的实例）。这使回调使用与optparse的其余部分相同的机制来存储选项值；你不需要搞砸全局或闭包。您还可以访问或修改命令行中已遇到的任何选项的值。

args

是通过callback_args选项属性提供的任意位置参数的元组。

kwargs

是通过callback_kwargs提供的任意关键字参数的字典。

36.1.4.3. Raising errors in a callback¶

如果选项或其参数有任何问题，回调函数应引用OptionValueError。optparse捕获并终止程序，打印您提供给stderr的错误消息。您的信息应该清晰，简洁，准确，并提及错误的选项。否则，用户将很难知道他做错了什么。

36.1.4.4. Callback example 1: trivial callback¶

下面是一个没有参数的回调选项的例子，只记录选项被看到：

def record_foo_seen(option, opt_str, value, parser):
    parser.values.saw_foo = True

parser.add_option("--foo", action="callback", callback=record_foo_seen)

当然，您可以使用"store_true"操作来执行此操作。

36.1.4.5. Callback example 2: check option order¶

这里有一个稍微有趣的例子：记录看到-a的事实，但是如果它在命令行中-b之后发生，就会爆炸。

def check_order(option, opt_str, value, parser):
    if parser.values.b:
        raise OptionValueError("can't use -a after -b")
    parser.values.a = 1
...
parser.add_option("-a", action="callback", callback=check_order)
parser.add_option("-b", action="store_true", dest="b")

36.1.4.6. Callback example 3: check option order (generalized)¶

如果你想对几个类似的选项重新使用这个回调（设置一个标志，但是如果-b已经被看到了，就会爆炸），它需要一些工作：错误消息和标志它必须被推广。

def check_order(option, opt_str, value, parser):
    if parser.values.b:
        raise OptionValueError("can't use %s after -b" % opt_str)
    setattr(parser.values, option.dest, 1)
...
parser.add_option("-a", action="callback", callback=check_order, dest='a')
parser.add_option("-b", action="store_true", dest="b")
parser.add_option("-c", action="callback", callback=check_order, dest='c')

36.1.4.7. Callback example 4: check arbitrary condition¶

当然，你可以放任何条件，你不限于检查已经定义的选项的值。例如，如果你有一些选项，当月亮满了不应该被调用，你所要做的是这样的：

def check_moon(option, opt_str, value, parser):
    if is_moon_full():
        raise OptionValueError("%s option invalid when moon is full"
                               % opt_str)
    setattr(parser.values, option.dest, 1)
...
parser.add_option("--foo",
                  action="callback", callback=check_moon, dest="foo")

（is_moon_full()的定义留作读者的练习。）

36.1.4.8. Callback example 5: fixed arguments¶

事情得到稍微更有趣，当你定义回调选项，需要固定数量的参数。指定回调选项接受参数与定义"store"或"append"选项类似：如果定义type需要一个必须可转换为该类型的参数；如果进一步定义nargs，则该选项会使用nargs参数。

以下是一个仅模拟标准"store"操作的示例：

def store_value(option, opt_str, value, parser):
    setattr(parser.values, option.dest, value)
...
parser.add_option("--foo",
                  action="callback", callback=store_value,
                  type="int", nargs=3, dest="foo")

注意，optparse负责消耗3个参数，并将它们转换为整数；所有你需要做的是存储他们。（或者什么；显然你不需要回调这个例子。）

36.1.4.9. Callback example 6: variable arguments¶

当你想要一个选项采用可变数量的参数时，事情变得毛茸茸。对于这种情况，您必须写回调，因为optparse不会为其提供任何内建功能。你必须处理传统的Unix命令行解析的某些复杂性，optparse通常为你处理。特别是，回调应该实现裸--和-参数的常规规则：

--或-可以是选项参数
裸机--（如果不是某个选项的参数）：halt命令行处理并丢弃--
bare -（如果不是某个选项的参数）：halt命令行处理，但保留-（将它附加到parser.largs）

如果你想要一个包含可变数量参数的选项，有几个微妙，棘手的问题需要担心。您选择的确切实施方式将基于您愿意为您的应用程序做出的权衡取舍（这是为什么optparse不直接支持此类事件）。

不过，这里有一个刺激回调一个选项与可变参数：

def vararg_callback(option, opt_str, value, parser):
    assert value is None
    value = []

    def floatable(str):
        try:
            float(str)
            return True
        except ValueError:
            return False

    for arg in parser.rargs:
        # stop on --foo like options
        if arg[:2] == "--" and len(arg) > 2:
            break
        # stop on -a, but not on -3 or -3.0
        if arg[:1] == "-" and len(arg) > 1 and not floatable(arg):
            break
        value.append(arg)

    del parser.rargs[:len(value)]
    setattr(parser.values, option.dest, value)

...
parser.add_option("-c", "--callback", dest="vararg_attr",
                  action="callback", callback=vararg_callback)

36.1.5. Extending `optparse`¶

由于optparse如何解释命令行选项的两个主要控制因素是每个选项的操作和类型，因此最可能的扩展方向是添加新操作和新类型。

36.1.5.1. Adding new types¶

要添加新类型，您需要定义optparse的Option类的自己的子类。此类有两个属性，定义optparse的类型：TYPES和TYPE_CHECKER。

Option.TYPES¶: 一个类型名称的元组；在你的子类中，简单地定义一个基于标准的tuple TYPES。

Option.TYPE_CHECKER¶

字典映射类型名称到类型检查函数。类型检查功能具有以下声明：

def check_mytype(option, opt, value)

其中option是Option实例，opt是选项字符串（例如，-f）和value是必须检查并转换为所需类型的命令行字符串。check_mytype()应返回假设类型mytype的对象。类型检查函数返回的值将在由OptionParser.parse_args()返回的OptionValues实例中结束，或作为value参数传递到回调。

如果遇到任何问题，您的类型检查函数应引发OptionValueError。OptionValueError采用单个字符串参数，它按原样传递到OptionParser的error()方法，和字符串"error:"，并在终止进程之前将所有内容打印到stderr。

这里有一个蠢的示例，演示了添加"complex"选项类型以在命令行上解析Python样式的复数。（这比以前更奇怪，因为optparse 1.3添加了内建对复数的支持，但不介意）。

一，必要进口：

from copy import copy
from optparse import Option, OptionValueError

您需要首先定义类型检查器，因为稍后（在您的Option子类的TYPE_CHECKER类属性中）将引用它：

def check_complex(option, opt, value):
    try:
        return complex(value)
    except ValueError:
        raise OptionValueError(
            "option %s: invalid complex value: %r" % (opt, value))

最后，Option子类：

class MyOption (Option):
    TYPES = Option.TYPES + ("complex",)
    TYPE_CHECKER = copy(Option.TYPE_CHECKER)
    TYPE_CHECKER["complex"] = check_complex

(If we didn’t make a copy() of Option.TYPE_CHECKER, we would end up modifying the TYPE_CHECKER attribute of optparse‘s Option class. 这是Python，没有什么阻止你这样做，除了良好的礼貌和常识。）

而已！现在，您可以像使用任何其他optparse的脚本一样编写一个使用新选项类型的脚本，但必须指示您的OptionParser使用MyOption而不是Option：

parser = OptionParser(option_class=MyOption)
parser.add_option("-c", type="complex")

或者，您可以构建您自己的选项列表，并将其传递给OptionParser；如果您不以上述方式使用add_option()，则不需要告诉OptionParser要使用哪个选项类：

option_list = [MyOption("-c", action="store", type="complex", dest="c")]
parser = OptionParser(option_list=option_list)

36.1.5.2. Adding new actions¶

添加新操作有点棘手，因为您必须理解optparse对操作有几个分类：

“存储”操作: 导致optparse存储值到当前OptionValues实例的属性的操作；这些选项需要将dest属性提供给Option构造函数。
“打字”动作: 从命令行获取值并期望它是某种类型的动作；或者，可以转换为某种类型的字符串。这些选项需要一个type属性到Option构造函数。

这些是重叠的集合：一些默认“存储”动作是"store"，"store_const"，"append"和"count"，而默认的”输入“操作是"store"，"append"和"callback"。

添加操作时，您需要通过将其列入Option的以下类属性（都是字符串列表）中的至少一个来对其进行分类：

Option.ACTIONS¶: 所有操作必须在ACTIONS中列出。

Option.STORE_ACTIONS¶: “存储”操作在此处另外列出。

Option.TYPED_ACTIONS¶: “typed”动作在这里另外列出。

Option.ALWAYS_TYPED_ACTIONS¶: 始终采用类型（即其选项总是取一个值）在这里另外列出。其唯一的效果是optparse将默认类型"string"分配给没有显式类型的选项，其操作列在ALWAYS_TYPED_ACTIONS 。

为了实际实现您的新操作，您必须覆盖Option的take_action()方法，并添加一个识别您的操作的案例。

例如，让我们添加一个"extend"操作。这与标准的"append"操作类似，但是不是从命令行获取单个值并将其附加到现有列表，"extend"也就是说，如果--names是类型"string"的"extend"选项，

--names=foo,bar --names blah --names ding,dong

将导致列表

["foo", "bar", "blah", "ding", "dong"]

我们再次定义Option的子类：

class MyOption(Option):

    ACTIONS = Option.ACTIONS + ("extend",)
    STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
    TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
    ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + ("extend",)

    def take_action(self, action, dest, opt, value, values, parser):
        if action == "extend":
            lvalue = value.split(",")
            values.ensure_value(dest, []).extend(lvalue)
        else:
            Option.take_action(
                self, action, dest, opt, value, values, parser)

特点：

"extend"都预期在命令行上的值，并将该值存储在某处，因此它会同时在STORE_ACTIONS和TYPED_ACTIONS中。
to ensure that optparse assigns the default type of "string" to "extend" actions, we put the "extend" action in ALWAYS_TYPED_ACTIONS as well.
MyOption.take_action()实现了这一个新动作，并将标准optparse动作的控制权返回到Option.take_action()。
values是optparse_parser.Values类的实例，它提供了非常有用的ensure_value()方法。ensure_value()本质上是具有安全阀的getattr()；它被称为
```
values.ensure_value(attr, value)
```
如果values的attr属性不存在或为无，则ensure_value()首先将其设置为value，然后返回'value 。这对于"extend"，"append"和"count"的操作非常方便，所有这些操作都会在变量中累积数据，期望变量为某种类型（前两个的列表，后者的整数）。使用ensure_value()意味着使用您的操作的脚本不必担心为有问题的选项目标设置默认值；他们可以只保留默认值为None和ensure_value()将会照顾到它需要的时候。

36.1. optparse — 命令行参数解析¶