Terminology

argument

在命令行输入的字符串，并通过shell传递到execl()或execv()。在Python中，参数是sys.argv[1:]（sys.argv[0]是正在执行的程序的名称）。Unix shell也使用术语“单词”.

偶尔需要替换sys.argv[1:]所以你应该把“论证”看成是“sys.argv[1:]，或作为的替代品提供的其他一些清单sys.argv[1:]” .

选项

用于提供额外信息以指导或自定义程序执行的参数。选项有许多不同的语法;传统的Unix语法是一个连字符（“ – ”）后跟一个字母，例如。-x要么 -F。此外，传统的Unix语法允许将多个选项合并为单个参数，例如，-x -F相当于-xF。GNU项目介绍--然后是一系列连字符分隔的单词，例如--file 要么 --dry-run。这些只是optparse.

提供的两种选项语法。世界上见过的其他一些选项语法包括：

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

optparse不支持这些选项语法，它们永远不会。这是故意的：前三个在任何环境中都是非标准的，如果你专门针对VMS，MS-DOS和/或Windows，那么最后一个才有意义.

选项参数

跟随选项的参数与该选项紧密关联，并在该选项为时从参数列表中使用。使用optparse，选项参数可以与其选项的单独参数：

-f foo
--file foo

或包含在同一参数中：

-ffoo
--file=foo

通常，给定选项要么是参数，要么不是。很多人都想要一个“可选的选项参数”功能，这意味着如果他们看到一些选项将会引发争论，如果他们不这样做则不会。这有点争议，因为它使解析变得模棱两可：如果-a可选参数和-b完全是另一种选择，我们如何解释-ab？由于这种歧义，optparse不支持这个功能.

positional argument

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

需要选项

必须在命令行上提供的选项;请注意，短语“必需选项”在英语中是自相矛盾的。optparse不会阻止你实现所需的选项，但也不会给你太多的帮助.

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

prog -v --report report.txt foo bar

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

选项是什么？

选项用于提供额外的信息来调整或自定义程序的执行。如果不清楚，选项通常是optional。Aprogram应该能够运行得很好，没有任何选择。（从Unix或GNU工具集中选择一个随机程序。它可以在没有任何选项的情况下运行并且仍然有意义吗？主要的例外是find, tar和dd – 所有这些都是突变的怪球因为他们的非标准语法和令人困惑的界面而受到批评。）

很多人希望他们的程序有“必需的选项”。想一想。如果需要，那就是not optional！如果有一条信息是你的程序为了成功运行而绝对需要的那些信息，那就是它们的定位参数.

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

cp SOURCE DEST
cp SOURCE ... DEST-DIR

你可以得到相当的远。大多数cp实现提供了大量选项，可以精确调整文件的复制方式：你可以保存模式和修改时间，避免使用符号链接，在clobberingexisting文件之前询问等等。但这些都不会分散cp，将一个文件复制到另一个文件，或将几个文件复制到另一个目录.

什么是位置参数？

位置论证适用于您的程序必须运行的那些信息.

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

简而言之，尽可能减少用户绝对需要提供合理默认值的信息量。当然，您也希望使您的程序具有相当的灵活性。这就是选择的目的。同样，如果它们是配置文件中的条目，GUI的“首选项”对话框中的窗口小部件或命令行选项也无关紧要 – 您实现的选项越多，程序就越灵活，其实现就越复杂。当然，太多的灵活性也有缺点;太多选项可能会压倒用户并使代码更难维护.

理解选项动作

动作告诉optparse当它在命令行遇到一个选项时该怎么做。有一组固定的动作硬编码到optparse;添加新动作是一个高级主题，包括扩展optparse 。大多数操作告诉optparse将值存储在某个变量中 – 例如，从命令行获取一个字符串并将其存储在options.

的属性中如果没有指定选项操作，optparse默认为store.

存储操作

最常见的选项操作是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中。所以，在此调用之后parse_args(), options.filename是"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。如果有nolong选项字符串，optparse查看第一个短选项字符串：-f的默认目标是f.

optparse还包括内置的complex类型。添加类型在中进行了介绍扩展optparse .

处理布尔（标志）选项

标记选项 – 当一个特定选项被设置为变量为真或假时 – 很常见。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")

这里我们有两个不同的选项，同样的目的地，这是完美的。（这只是意味着你在设置defaultvalues时必须要小心一点 – 见下文。）

当optparse在命令行遇到-v时，它会设置options.verbose至 True;当遇到-q,options.verbose设置为False.

其他动作

optparse支持的其他动作是：

"store_const"

存储一个常量值

"append"

将此选项的参数附加到列表

"count"

将计数器递增一个

"callback"

调用指定函数

这些都在中介绍参考指南，参考指南和部分选项回调.

默认值

所有上述示例都涉及设置一些变量（“目的地”）不确定可以看到命令行选项。如果这些选项是相反的，会发生什么？由于我们没有提供任何默认值，因此它们都设置为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：为任何特定目的地提供的最后一个默认值是重要的值

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

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

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

生成帮助

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使用一个平淡但敏感的默认："Usage: %prog [options]"，这很好，如果你的脚本没有任何位置参数.

• every选项定义了一个帮助字符串，并且不用担心换行 – optparse负责包裹行并使帮助输出看起来不错.

• 采用值的选项在其自动生成的帮助消息中指示此事实，例如对于“模式”选项：

  -m MODE, --mode=MODE

  这里，“MODE”被称为元变量：它代表用户应该提供给-m/--mode的论据。默认情况下，optparse将目标变量名称转换为大写，并将其用于元变量。有时，这不是你想要的 – 例如，--filename选项显式设置metavar="FILE"，导致这个自动生成的选项描述：

  -f FILE, --filename=FILE

  这不仅仅是保存但是：手写的帮助文本使用元变量FILE来提示用户，因为半正式语法-f FILE和非正式语义描述“写输出到FILE”之间存在联系。这是一个简单但有效的方法，可以使您的帮助文本更清晰，更有用的最终用户.

• 具有默认值的选项可以在帮助字符串中包含%default – optparse将替换为str()的option’sdefault值。如果选项没有默认值（或默认值为None），则%default扩展为none.

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

打印版本字符串

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

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）打印到file（默认标准输出）。和print_usage()，%prog在self.version被替换为currentprogram的名称。如果self.version是空的还是未定义的

OptionParser.get_version（）

与…一样 print_version()但是返回版本字符串而不是打印它.

optparse处理错误

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

处理用户错误更为重要，因为无论代码的稳定性如何，都可以保证它们的发生。optparse可以自动检测一些用户错误，例如错误的选项参数（传递-n 4x，其中-n采用整数参数），缺少参数（-n在命令行的末尾，其中-n采取任何类型的论点）。此外，您可以调用OptionParser.error()来表示应用程序定义的错误条件：

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

在任何一种情况下，optparse以相同的方式处理错误：它打印程序的用法消息和错误消息到标准错误并退出witherror状态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() methods.

把它们全部放在一起

这是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()

创建解析器

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

class optparse.OptionParser（…）

OptionParser构造函数没有必需的参数，但有许多可选的关键字参数。你应该总是将它们作为keywordarguments传递，即不要依赖于声明参数的顺序.

usage（默认值："%prog [options]"）

打印时的用法摘要您的程序运行不正确或使用ahelp选项。当optparse打印用法字符串时，它会将%prog扩展为os.path.basename(sys.argv[0])（如果你通过了该关键字参数，则扩展到prog）。要禁止使用消息，请传递特殊值optparse.SUPPRESS_USAGE.

option_list（默认值：[]）

用于填充解析器的Option对象列表。option_list中的选项在standard_option_list中的任何选项（可由OptionParser子类设置的aclass属性）之后添加，但在任何版本或帮助选项之前添加。不推荐使用;使用add_option()代替后创建解析器.

option_class（默认值：optparse.Option）

在add_option().

version中向解析器添加选项时使用的类（默认值：None）

用户提供版本选项时要打印的版本字符串。如果为version, optparse提供了一个真值，则自动添加带有单个选项字符串--version的aversion选项。子串%prog的扩展与usage.

conflict_handler相同（默认值："error"）

指定当具有冲突选项字符串的选项添加到解析器时要执行的操作;请参阅选项之间的冲突.

description（默认值：None）

一段文字，简要介绍你的程序.optparse重新格式化此段落以适合当前终端widthand并在用户请求帮助时打印它（在usage之后，但在选项列表之前）.

formatter（默认值：新的IndentedHelpFormatter）

将用于打印helptext的optparse.HelpFormatter实例。optparse为此提供了两个具体的类：IndentedHelpFormatter和TitledHelpFormatter.

add_help_option（默认值：True）

如果为true，optparse将添加一个帮助选项（带选项字符串-h和--help）到解析器.

prog

扩展%prog在usage和version而不是os.path.basename(sys.argv[0]).

epilog时使用的字符串（默认值：None）

选项帮助后打印一段帮助文本

填写解析器

有几种方法可以使用选项填充解析器。使用OptionParser.add_option()的首选方法，如教程. add_option()所示，可以通过以下两种方式之一调用：

• 传递一个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。）

定义选项

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

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

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异常解释你的错误.

选项的action确定optparse在命令行遇到这个选项时会做什么。标准选项操作硬编码到optparse是：

"store"

存储此选项的参数（默认）

"store_const"

存储一个常量值

"store_true"

存储一个真值

"store_false"

存储一个错误的值

"append"

将这个选项的参数附加到一个列表

"append_const"

将一个常量值附加到一个列表

"count"

将一个计数器递增一个

"callback"

调用指定的函数

"help"

打印包含所有选项及其文档的用法消息

（如果你不是提供一个动作，默认为"store"。对于这个动作，你也可以提供type和dest optionattributes;参见标准选项动作.)

正如你所看到的，大多数动作都涉及在某处存储或更新一个值.optparse总是为此创建一个特殊的对象，通常称为options（它恰好是optparse.Values的一个实例。根据dest（目的地）选项属性，将Optionarguments（和其他各种值）存储为该对象的属性.

例如，当你调用

parser.parse_args()

之一时optparse所做的第一件事就是创建options object：

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是唯一对all选项有意义的

选择属性

以下选项属性可以作为OptionParser.add_option()的关键字参数传递。如果传递的选项属性与特定选项无关，或者无法传递必需的选项属性，则optparse引发OptionError.

Option.action

（默认值："store"）

确定在命令行上看到此选项时optparse的行为;记录可用的选项这里.

Option.type

（默认值："string"）

这个选项所期望的参数类型（例如"string"或"int"）;可用的选项类型记录在这里.

Option.dest

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

如果选项的动作意味着写或修改在某个地方有一个价值，这就是optparse在哪里写的：dest命名options对象optparse在解析命令行时构建.

Option.default

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

Option.nargs

（默认值：1）

有多少类型的参数type当看到这个选项时应该消耗。如果＆gt;1，optparse将存储一个值元组dest.

Option.const

对于存储常量值的动作，存储的常量值

Option.choices

对于类型"choice"，用户可以选择的字符串列表.

Option.callback

对于有操作的选项"callback"，当看到此选项时调用的可调用。参见选项回调有关传递给callable的参数的详细信息.

Option.callback_args

Option.callback_kwargs

在四个标准回调参数之后传递给callback的附加位置和关键字参数.

Option.help

在用户提供help选项后列出所有可用选项时帮助文本打印此选项（例如--help）。如果没有提供帮助文本，则会列出没有帮助文本的选项。取消隐藏此选项，使用特殊值optparse.SUPPRESS_HELP.

Option.metavar

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

替换打印帮助文本时使用的选项参数。参见章节教程示例.

标准选项操作

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

• "store" [相关：type, dest,nargs, choices]

  该选项必须后跟一个参数，该参数被转换根据type的值并存储在dest中。如果nargs＆gt;1，将从命令行中消耗多个参数;所有都将根据type进行转换并存储为dest作为元组。见标准选项类型 section.

  如果choices提供（字符串列表或元组），类型默认为"choice".

  如果type没有提供，它默认为"string".

  如果没有提供dest，optparse从第一个长选项字符串派生一个目的地（例如，--foo-bar暗示foo_bar）。如果没有长选项字符串，optparse从第一个短选项字符串中获取adestination（例如，-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" [required：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" [相关：type, dest,nargs, choices]

  必须选择后面的选项一个参数，它附加在dest的列表中。如果没有dest如果在命令行上optparse firstencounters此选项，则会自动创建一个空列表。如果nargs＆gt;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"[required：const;相关：dest]

  像"store_const"，但值const附在dest;与"append", dest默认为None，并在第一次遇到选项时自动创建一个空列表.

• "count" [related：dest]

  增加存储在dest的整数。如果没有提供默认值，dest在第一次递增之前设置为零.

  例如：

  parser.add_option("-v", action="count", dest="verbosity")

  第一次在命令行上看到-v，optparse的等价是：

  options.verbosity = 0
  options.verbosity += 1

  随后每次出现-v结果

  options.verbosity += 1

• "callback" [required：callback;相关：type, nargs, callback_args,callback_kwargs]

  调用callback指定的函数，调用为

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

  参见选项回调更多细节.

• "help"

  为当前optionparser中的所有选项打印完整的帮助消息。帮助消息是由传递给OptionParser的构造函数的usage字符串和help字符串传递给everyoption.

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

  optparse自动为allOptionParsers添加一个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)

  如果optparse看到-h或--help在命令行中，它会将以下帮助信息打印到stdout（假设sys.argv[0]是"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会在需要时自动添加它们.

标准选项类型

optparse有五种内置选项类型："string", "int","choice", "float"和"complex"。如果需要添加newoption类型，请参阅扩展optparse .

不以任何方式检查或转换字符串选项的参数：命令行上的文本存储在目标中（或通过回调）as-is.

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

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

通过使用适当的基数（2,8,10或16）调用int()来完成转换。如果失败了，optparse也会失败，虽然有更多使用错误信息.

"float"和"complex"选项参数直接用float()和complex()转换，类似的错误处理.

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

解析参数

创建和填充OptionParser的全部意义就是调用它parse_args()方法：

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

其中输入参数是

args

要处理的参数列表（默认值：sys.argv[1:]）

values

一个optparse.Values用于存储选项参数的对象（默认：Values的新实例） – 如果给出一个现有对象，则不会在其上初始化选项默认值

并且返回值为

options

作为values传入的同一个对象，或optparse

args

创建的optparse.Valuesinstance所有选项处理后的剩余位置参数

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

返回如果parse_args()遇到参数列表中的任何错误，它会使用适当的最终用户错误消息调用OptionParser的error()方法。这最终会以退出状态2（命令行错误的传统Unix退出状态）终止进程.

查询和操作选项解析器

可以稍微自定义选项解析器的默认行为，您还可以查看选项解析器并查看其中的内容。OptionParser提供了几种方法来帮助你：

OptionParser.disable_interspersed_args（）

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

prog -a arg1 -b arg2

并将其视为等效于

prog -a -b arg1 arg2

要禁用此功能，请调用disable_interspersed_args()。这解决了传统的Unix语法，其中选项解析使用firstnon-option参数停止.

如果你有一个命令处理器运行另一个自己的hasoptions并且你想确保这些选项没有困惑了。例如，每个命令可能有一组不同的选项.

OptionParser.enable_interspersed_args()

设置解析不停在第一个非选项上，允许穿插命令带有命令参数。这是默认行为.

OptionParser.get_option (opt_str )

返回带有选项字符串opt_str， 要么 Noneifno选项有那个选项string.

OptionParser.has_option（opt_str）

如果OptionParser有一个带选项字符串opt_str的选项，则返回true（例如，-q或--verbose).

OptionParser.remove_option(opt_str)

如果OptionParser有一个对应于opt_str，该选项被删除。如果该选项提供了任何其他选项字符串，则所有选项字符串都将变为无效。如果在opt_str的任何选项中都没有出现OptionParser，则会引发ValueError.

选项之间的冲突

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

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

（如果您已经使用某些标准选项定义了自己的OptionParser子类，则尤其如此。）

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

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

或者单独打电话：

parser.set_conflict_handler(handler)

可用的冲突处理程序是：

"error"（默认值）

假设选项冲突是一个编程错误并且智能地提升OptionConflictError

"resolve"

解决选项冲突（见下文）

作为一个例子，让我们定义一个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

清理

OptionParser实例具有多个循环引用。对于Python的垃圾收集器来说这应该不是问题，但你可能希望通过调用destroy()完成后，在yourOptionParser上。这在长期运行的应用程序中特别有用，在这些应用程序中可以从yourOptionParser获得大对象图.

其他方法

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

OptionParser.set_usage（usage）

根据上述usage构造函数关键字参数的规则设置用法字符串。通过None设置默认的usagestring;使用optparse.SUPPRESS_USAGE来抑制使用信息.

OptionParser.print_usage(file=None)

打印当前程序的使用信息（self.usage）file（默认标准输出）。在%prog中出现的字符串self.usage将替换为当前程序的名称。如果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")

定义一个回调选项

与往常一样，定义回调选项的最简单方法是使用OptionParser.add_option()方法。除了action之外，你必须指定的theonly选项属性是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):

回调的四个参数如下所述.

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

type

有其通常的含义：与"store"或"append"动作，它指示optparse消耗一个参数并将其转换为type。但是，不是将转换后的值存储在任何地方，而是optparse将它传递给你的回调函数.

nargs

也有其通常的含义：如果它是提供的＆gt;1，optparse将消耗nargs参数，每个参数必须可转换为type。然后它将一个转换值的元组传递给你的回调.

callback_args

传递给回调的额外位置参数元组

callback_kwargs

传递给回调的额外关键字参数字典

如何调用回调

所有回调都按如下方式调用：

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＆gt;1，value将是一个适当类型的价值元组.

parser

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

parser.largs

当前的剩余参数列表，即。已经消耗的参数但既不是选项也不是选项参数。随意修改parser.largs，例如通过添加更多参数。（此列表将成为args，parse_args()。）

parser.rargs

剩下的参数的当前列表，即。用opt_str和value（如果适用）删除，只有那里的参数。随意修改parser.rargs，例如通过消耗更多的论据

parser.values

默认情况下存储选项值的对象（ofoptparse.OptionValues实例）。这让回调使用与optparse用于存储选项值;你不需要使用全局变量或闭包。您还可以访问或修改命令行中已遇到的任何选项的值.

args

是callback_args选项属性.

kwargs

是一个通过callback_kwargs.

提高回调中的错误

如果有选项或其参数存在任何问题，则回调函数应该引发OptionValueError。optparse抓住这个并终止程序，打印你提供给stderr的错误信息。你的消息应该清晰，简洁，准确，并提出错误的选项。否则，用户将很难搞清楚他们做错了什么.

回调示例1：琐碎的回调

这是一个不带参数的回调选项的例子，只记录了看到的选项：

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" action.

Callback做到这一点示例2：检查选项顺序

这是一个稍微有趣的例子：记录-a isseen的事实，但是如果在命令行中-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")

回调示例3：检查选项顺序（一般化）

如果你想为几个类似的选项重新使用这个回调（设置一个标志，但如果-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')

回调示例4：检查任意条件

当然，您可以在其中放置任何条件 – 您不仅限于检查已定义选项的值。例如，如果您有月亮已满时不应调用的选项，您只需要这样做：

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()的定义留给读者练习。）

回调示例5：固定参数

当您定义采用固定数量参数的回调选项时，事情会变得更有趣。指定回调选项接受参数类似于定义"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个参数并将它们转换为整数给你;你所要做的就是存放它们。（或者其他什么;显然你不需要这个例子的回调。）

回调示例6：变量参数

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

• --或-可以是选项参数
• 裸--（如果不是某个选项的参数）：停止命令行处理并丢弃--
• 裸-（如果不是某些参数的话选项）：暂停命令行处理，但保持-（将其附加到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)

添加新类型

到添加新类型，你需要定义自己的optparse的Option类的子类。这个类有几个定义optparse的类型的属性：TYPES和TYPE_CHECKER.

Option.TYPES

一个类型名称的元组;在你的子类中，只需定义一个新的元组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"选项在命令行上键入toparse Python样式的复数。（这甚至比过去简单，因为optparse 1.3增加了对复数的内置支持，但没关系。）

首先，必要的导入：

from copy import copy
from optparse import Option, OptionValueError

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

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

（如果我们没有做copy()对Option.TYPE_CHECKER，我们最终会修改TYPE_CHECKER‘sOption类的optparse属性。这就是Python，除了好人和常识之外，没有什么能阻止你这样做。）

就是这样！现在您可以编写一个使用新选项类型的脚本，就像其他基于optparse的脚本一样，除非您必须指示yourOptionParser使用MyOption而不是Option：

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

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

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

添加新操作

添加新操作有点比较棘手，因为你必须明白optparse有几个动作分类：

“存储”动作

导致optparse存储一个动作value到当前OptionValues实例的属性;这些选项需要dest属性提供给Option构造函数.

\”typed“actions

动作从命令行获取值并期望它是某种类型;或者更确切地说，是一个可以转换为某种类型的字符串。这些选项需要一个type属性为Optionconstructor.

这些是重叠集：一些默认的“存储”动作是"store","store_const", "append"，和"count"，而默认的“打字”动作是"store", "append"，和"callback".

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

Option.ACTIONS

必须在ACTIONS中列出所有动作.

Option.STORE_ACTIONS

此处还列出了“商店”行动.

Option.TYPED_ACTIONS

“这里还列出了”行动.

Option.ALWAYS_TYPED_ACTIONS

始终采用类型（即，其选项始终采用值）的操作通常在此处列出。唯一的影响是optparse指定默认类型，"string"，在ALWAYS_TYPED_ACTIONS.

中列出没有明确类型的操作的选项为了实际执行新操作，您必须覆盖Option的take_action()方法并添加一个识别您的操作的案例.

例如，让我们添加一个"extend"动作。这类似于标准的"append"动作，但不是从命令行中取一个值并将其附加到现有列表，"extend"将在单个逗号分隔的字符串中采用多个值，并使用它们扩展现有列表。那就是，如果--names是"extend"的"string"选项，命令行

--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.

• 为了确保 optparse将"string"的默认类型分配给"extend"动作，我们也将"extend"动作放在ALWAYS_TYPED_ACTIONS中.

• MyOption.take_action()实现这个新行动，并将控制权传回Option.take_action()为标准optparseactions.

• values是optparse_parser.Values类的一个实例，它提供了非常有用的ensure_value()方法。ensure_value() isessentially getattr()带安全阀;它被称为

  values.ensure_value(attr, value)

  如果attr的values属性不存在或者是None，则thenensure_value（）首先将其设置为value，然后返回’value。对于像"extend", "append"和"count"这样的动作来说，这非常方便，它们在变量中累积数据并期望变量属于某种类型（前两个的列表，后者的整数））。使用ensure_value()意味着使用您的操作的脚本不必担心为有问题的选项目标设置默认值;他们可以保留默认值None和ensure_value()会在需要时正确处理它.