optparse —- 命令行選項(xiàng)的解析器

源代碼： Lib/optparse.py

3.2 版后已移除: optparse 模塊已被棄用并且將不再繼續(xù)開發(fā)；開發(fā)將轉(zhuǎn)至 argparse 模塊進(jìn)行。

optparse 是一個(gè)相比原有 getopt 模塊更為方便、靈活和強(qiáng)大的命令行選項(xiàng)解析庫(kù)。 optparse 使用更為顯明的命令行解析風(fēng)格：創(chuàng)建一個(gè) OptionParser 的實(shí)例，向其中填充選項(xiàng)，然后解析命令行。 optparse 允許用戶以傳統(tǒng)的 GNU/POSIX 語法來指定選項(xiàng)，并為你生成額外的用法和幫助消息。

下面是在一個(gè)簡(jiǎn)單腳本中使用 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()
 
 
 
 

通過這幾行代碼，你的腳本的用戶可以在命令行上完成“常見任務(wù)”，例如:

 
 
 
 

  
  
  
  
 --file=outfile -q
 
 
 
 

在它解析命令行時(shí)，optparse 會(huì)根據(jù)用戶提供的命令行值設(shè)置 parse_args() 所返回的 options 對(duì)象的屬性。 當(dāng) parse_args() 從解析此命令行返回時(shí)，options.filename 將為 "outfile" 而 options.verbose 將為 False。 optparse 支持長(zhǎng)短兩種形式的選項(xiàng)，允許多個(gè)短選項(xiàng)合并到一起，并允許選項(xiàng)以多種方式與其參數(shù)相關(guān)聯(lián)。 因此，以下命令行均等價(jià)于以上示例:

 
 
 
 

  
  
  
  
 -f outfile --quiet
  
  
  
  
 --quiet --file outfile
  
  
  
  
 -q -foutfile
  
  
  
  
 -qfoutfile
 
 
 
 

此外，用戶還可以運(yùn)行以下命令之一

 
 
 
 

  
  
  
  
 -h
  
  
  
  
 --help
 
 
 
 

這樣 optparse 將打印出你的腳本的選項(xiàng)概要:

 
 
 
 

  
  
  
  
Usage:  [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 的值是在運(yùn)行時(shí)確定的 (通常來自 sys.argv[0])。

背景

optparse 被顯式設(shè)計(jì)為鼓勵(lì)創(chuàng)建帶有簡(jiǎn)潔直觀、符合慣例的命令行接口的程序。 為了這個(gè)目標(biāo)，它僅支持最常見的命令行語法和在 Unix 下使用的規(guī)范語義。 如果你不熟悉這些慣例，請(qǐng)閱讀本小節(jié)來使自己熟悉它們。

術(shù)語

argument — 參數(shù)

在命令行中輸入的字符串，并會(huì)被 shell 傳給 execl() 或 execv()。 在 python 中，參數(shù)將是 sys.argv[1:] 的元素 (sys.argv[0] 是被執(zhí)行的程序的名稱)。 Unix shell 也使用術(shù)語 “word” 來指代參數(shù)。

有時(shí)替換 sys.argv[1:] 以外的參數(shù)列表也是必要的，所以你應(yīng)當(dāng)將 “參數(shù)” 當(dāng)作是 “sys.argv[1:] 的一個(gè)元素，或者是作為 sys.argv[1:] 的替代的其他列表”。

選項(xiàng)

一個(gè)用來提供額外信息以指導(dǎo)或定制程序的執(zhí)行的參數(shù)。 對(duì)于選項(xiàng)有許多不同的語法；傳統(tǒng)的 Unix 語法是一個(gè)連字符 (“-“) 后面跟單個(gè)字母，例如 -x 或 -F。 此外，傳統(tǒng)的 Unix 語法允許將多個(gè)選項(xiàng)合并為一個(gè)參數(shù)，例如 -x -F 就等價(jià)于 -xF。 GNU 項(xiàng)目引入了 -- 后面跟一串以連字符分隔的單詞，例如 --file 或 --dry-run。 它們是 optparse 所提供的僅有的兩種選項(xiàng)語法。

存在于世上的其他一些選項(xiàng)語法包括:

• 一個(gè)連字符后面跟幾個(gè)字母，例如 -pf (這與多個(gè)選項(xiàng)合并成單個(gè)參數(shù) 并不 一樣)

• 一個(gè)連字符后面跟一個(gè)完整單詞，例如 -file (這在技術(shù)上等同于前面的語法，但它們通常不在同一個(gè)程序中出現(xiàn))

• 一個(gè)加號(hào)后面跟一個(gè)字母，或幾個(gè)字母，或一個(gè)單詞，例如 +f, +rgb

• 一個(gè)斜杠后面跟一個(gè)字母，或幾個(gè)字母，或一個(gè)單詞，例如 /f, /file

這些選項(xiàng)語法都不被 optparse 所支持，也永遠(yuǎn)不會(huì)支持。 這是有意為之的：前三種在任何環(huán)境下都是非標(biāo)準(zhǔn)的，而最后一種只在你專門針對(duì) Windows 或某些舊平臺(tái)（例如 VMS, MS-DOS）時(shí)才有意義。

可選參數(shù):

一個(gè)跟在某個(gè)選項(xiàng)之后的參數(shù)，與該選項(xiàng)緊密相關(guān)，并會(huì)在該選項(xiàng)被消耗時(shí)從參數(shù)列表中被消耗。 使用 optparse，選項(xiàng)參數(shù)可以是其對(duì)應(yīng)選項(xiàng)以外的一個(gè)單獨(dú)參數(shù):

 
 
 
 

  
  
  
  
-f foo
  
  
  
  
--file foo
 
 
 
 

或是包括在同一個(gè)參數(shù)中:

 
 
 
 

  
  
  
  
-ffoo
  
  
  
  
--file=foo
 
 
 
 

Typically, a given option either takes an argument or it doesn’t. Lots of people want an “optional option arguments” feature, meaning that some options will take an argument if they see it, and won’t if they don’t. This is somewhat controversial, because it makes parsing ambiguous: if -a takes an optional argument and -b is another option entirely, how do we interpret -ab? Because of this ambiguity, optparse does not support this feature.

positional argument — 位置參數(shù)

something leftover in the argument list after options have been parsed, i.e. after options and their arguments have been parsed and removed from the argument list.

必選選項(xiàng)

an option that must be supplied on the command-line; note that the phrase “required option” is self-contradictory in English. optparse doesn’t prevent you from implementing required options, but doesn’t give you much help at it either.

For example, consider this hypothetical command-line:

 
 
 
 

  
  
  
  
prog -v --report report.txt foo bar
 
 
 
 

-v and --report are both options. Assuming that --report takes one argument, report.txt is an option argument. foo and bar are positional arguments.

What are options for?

Options are used to provide extra information to tune or customize the execution of a program. In case it wasn’t clear, options are usually optional. A program should be able to run just fine with no options whatsoever. (Pick a random program from the Unix or GNU toolsets. Can it run without any options at all and still make sense? The main exceptions are find, tar, and dd-—all of which are mutant oddballs that have been rightly criticized for their non-standard syntax and confusing interfaces.)

Lots of people want their programs to have “required options”. Think about it. If it’s required, then it’s not optional! If there is a piece of information that your program absolutely requires in order to run successfully, that’s what positional arguments are for.

As an example of good command-line interface design, consider the humble cp utility, for copying files. It doesn’t make much sense to try to copy files without supplying a destination and at least one source. Hence, cp fails if you run it with no arguments. However, it has a flexible, useful syntax that does not require any options at all:

 
 
 
 

  
  
  
  
cp SOURCE DEST
  
  
  
  
cp SOURCE ... DEST-DIR
 
 
 
 

You can get pretty far with just that. Most cp implementations provide a bunch of options to tweak exactly how the files are copied: you can preserve mode and modification time, avoid following symlinks, ask before clobbering existing files, etc. But none of this distracts from the core mission of cp, which is to copy either one file to another, or several files to another directory.

位置參數(shù)有什么用？

Positional arguments are for those pieces of information that your program absolutely, positively requires to run.

A good user interface should have as few absolute requirements as possible. If your program requires 17 distinct pieces of information in order to run successfully, it doesn’t much matter how you get that information from the user—-most people will give up and walk away before they successfully run the program. This applies whether the user interface is a command-line, a configuration file, or a GUI: if you make that many demands on your users, most of them will simply give up.

In short, try to minimize the amount of information that users are absolutely required to supply—-use sensible defaults whenever possible. Of course, you also want to make your programs reasonably flexible. That’s what options are for. Again, it doesn’t matter if they are entries in a config file, widgets in the “Preferences” dialog of a GUI, or command-line options—-the more options you implement, the more flexible your program is, and the more complicated its implementation becomes. Too much flexibility has drawbacks as well, of course; too many options can overwhelm users and make your code much harder to maintain.

教程

While optparse is quite flexible and powerful, it’s also straightforward to use in most cases. This section covers the code patterns that are common to any optparse-based program.

First, you need to import the OptionParser class; then, early in the main program, create an OptionParser instance:

 
 
 
 

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

Then you can start defining options. The basic syntax is:

 
 
 
 

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

Each option has one or more option strings, such as -f or --file, and several option attributes that tell optparse what to expect and what to do when it encounters that option on the command line.

Typically, each option will have one short option string and one long option string, e.g.:

 
 
 
 

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

You’re free to define as many short option strings and as many long option strings as you like (including zero), as long as there is at least one option string overall.

The option strings passed to OptionParser.add_option() are effectively labels for the option defined by that call. For brevity, we will frequently refer to encountering an option on the command line; in reality, optparse encounters option strings and looks up options from them.

Once all of your options are defined, instruct optparse to parse your program’s command line:

 
 
 
 

  
  
  
  
(options, args) = parser.parse_args()
 
 
 
 

(If you like, you can pass a custom argument list to parse_args(), but that’s rarely necessary: by default it uses sys.argv[1:].)

parse_args() 返回兩個(gè)值：

• options, an object containing values for all of your options—-e.g. if --file takes a single string argument, then options.file will be the filename supplied by the user, or None if the user did not supply that option

• args, the list of positional arguments leftover after parsing options

This tutorial section only covers the four most important option attributes: action, type, dest (destination), and help. Of these, action is the most fundamental.

Understanding option actions

Actions tell optparse what to do when it encounters an option on the command line. There is a fixed set of actions hard-coded into optparse; adding new actions is an advanced topic covered in section Extending optparse. Most actions tell optparse to store a value in some variable—-for example, take a string from the command line and store it in an attribute of options.

If you don’t specify an option action, optparse defaults to store.

The store action

The most common option action is store, which tells optparse to take the next argument (or the remainder of the current argument), ensure that it is of the correct type, and store it to your chosen destination.

例如：

 
 
 
 

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

Now let’s make up a fake command line and ask optparse to parse it:

 
 
 
 

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

When optparse sees the option string -f, it consumes the next argument, foo.txt, and stores it in options.filename. So, after this call to parse_args(), options.filename is "foo.txt".

Some other option types supported by optparse are int and float. Here’s an option that expects an integer argument:

 
 
 
 

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

Note that this option has no long option string, which is perfectly acceptable. Also, there’s no explicit action, since the default is store.

Let’s parse another fake command-line. This time, we’ll jam the option argument right up against the option: since -n42 (one argument) is equivalent to -n 42 (two arguments), the code

 
 
 
 

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

will print 42.

If you don’t specify a type, optparse assumes string. Combined with the fact that the default action is store, that means our first example can be a lot shorter:

 
 
 
 

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

If you don’t supply a destination, optparse figures out a sensible default from the option strings: if the first long option string is --foo-bar, then the default destination is foo_bar. If there are no long option strings, optparse looks at the first short option string: the default destination for -f is f.

optparse also includes the built-in complex type. Adding types is covered in section Extending optparse.

Handling boolean (flag) options

Flag options—-set a variable to true or false when a particular option is seen—-are quite common. optparse supports them with two separate actions, store_true and store_false. For example, you might have a verbose flag that is turned on with -v and off with -q:

 
 
 
 

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

Here we have two different options with the same destination, which is perfectly OK. (It just means you have to be a bit careful when setting default values—-see below.)

When optparse encounters -v on the command line, it sets options.verbose to True; when it encounters -q, options.verbose is set to False.

Other actions

Some other actions supported by optparse are:

"store_const"

store a constant value

"append"

append this option’s argument to a list

"count"

increment a counter by one

"callback"

調(diào)用指定函數(shù)

These are covered in section 參考指南, and section Option Callbacks.

默認(rèn)值

All of the above examples involve setting some variable (the “destination”) when certain command-line options are seen. What happens if those options are never seen? Since we didn’t supply any defaults, they are all set to None. This is usually fine, but sometimes you want more control. optparse lets you supply a default value for each destination, which is assigned before the command line is parsed.

First, consider the verbose/quiet example. If we want optparse to set verbose to True unless -q is seen, then we can do this:

 
 
 
 

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

Since default values apply to the destination rather than to any particular option, and these two options happen to have the same destination, this is exactly equivalent:

 
 
 
 

  
  
  
  
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)
 
 
 
 

Again, the default value for verbose will be True: the last default value supplied for any particular destination is the one that counts.

A clearer way to specify default values is the set_defaults() method of OptionParser, which you can call at any time before calling parse_args():

 
 
 
 

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

As before, the last value specified for a given option destination is the one that counts. For clarity, try to use one method or the other of setting default values, not both.

Generating help

optparse‘s ability to generate help and usage text automatically is useful for creating user-friendly command-line interfaces. All you have to do is supply a help value for each option, and optionally a short usage message for your whole program. Here’s an OptionParser populated with user-friendly (documented) options:

 
 
 
 

  
  
  
  
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]")
 
 
 
 

If optparse encounters either -h or --help on the command-line, or if you just call parser.print_help(), it prints the following to standard output:

 
 
 
 

  
  
  
  
Usage:  [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]
 
 
 
 

(If the help output is triggered by a help option, optparse exits after printing the help text.)

There’s a lot going on here to help optparse generate the best possible help message:

• the script defines its own usage message:

     
     
     
     
  
      
      
      
      
  usage = "usage: %prog [options] arg1 arg2"
     
     
     
     

  optparse expands %prog in the usage string to the name of the current program, i.e. os.path.basename(sys.argv[0]). The expanded string is then printed before the detailed option help.

  If you don’t supply a usage string, optparse uses a bland but sensible default: "Usage: %prog [options]", which is fine if your script doesn’t take any positional arguments.

• every option defines a help string, and doesn’t worry about line-wrapping—-optparse takes care of wrapping lines and making the help output look good.

• options that take a value indicate this fact in their automatically generated help message, e.g. for the “mode” option:

     
     
     
     
  
      
      
      
      
  -m MODE, --mode=MODE
     
     
     
     

  Here, “MODE” is called the meta-variable: it stands for the argument that the user is expected to supply to -m/--mode. By default, optparse converts the destination variable name to uppercase and uses that for the meta-variable. Sometimes, that’s not what you want—-for example, the --filename option explicitly sets metavar="FILE", resulting in this automatically generated option description:

     
     
     
     
  
      
      
      
      
  -f FILE, --filename=FILE
     
     
     
     

  This is important for more than just saving space, though: the manually written help text uses the meta-variable FILE to clue the user in that there’s a connection between the semi-formal syntax -f FILE and the informal semantic description “write output to FILE”. This is a simple but effective way to make your help text a lot clearer and more useful for end users.

• options that have a default value can include %default in the help string—-optparse will replace it with str() of the option’s default value. If an option has no default value (or the default value is None), %default expands to none.

Grouping Options

When dealing with many options, it is convenient to group these options for better help output. An OptionParser can contain several option groups, each of which can contain several options.

An option group is obtained using the class OptionGroup:

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

where

• parser is the OptionParser instance the group will be inserted in to

• title is the group title

• description, optional, is a long description of the group

OptionGroup inherits from OptionContainer (like OptionParser) and so the add_option() method can be used to add an option to the group.

Once all the options are declared, using the OptionParser method add_option_group() the group is added to the previously defined parser.

Continuing with the parser defined in the previous section, adding an OptionGroup to a parser is easy:

 
 
 
 

  
  
  
  
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)
 
 
 
 

This would result in the following help output:

 
 
 
 

  
  
  
  
Usage:  [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.
 
 
 
 

A bit more complete example might involve using more than one group: still extending the previous example:

 
 
 
 

  
  
  
  
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)
 
 
 
 

that results in the following output:

 
 
 
 

  
  
  
  
Usage:  [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
 
 
 
 

Another interesting method, in particular when working programmatically with option groups is:

OptionParser.get_option_group(opt_str)

Return the OptionGroup to which the short or long option string opt_str (e.g. '-o' or '--option') belongs. If there’s no such OptionGroup, return None.

Printing a version string

Similar to the brief usage string, optparse can also print a version string for your program. You have to supply the string as the version argument to OptionParser:

 
 
 
 

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

%prog is expanded just like it is in usage. Apart from that, version can contain anything you like. When you supply it, optparse automatically adds a --version option to your parser. If it encounters this option on the command line, it expands your version string (by replacing %prog), prints it to stdout, and exits.

For example, if your script is called /usr/bin/foo:

 
 
 
 

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

The following two methods can be used to print and get the version string:

OptionParser.print_version(file=None)

Print the version message for the current program (self.version) to file (default stdout). As with print_usage(), any occurrence of %prog in self.version is replaced with the name of the current program. Does nothing if self.version is empty or undefined.

OptionParser.get_version()

Same as print_version() but returns the version string instead of printing it.

How optparse handles errors

There are two broad classes of errors that optparse has to worry about: programmer errors and user errors. Programmer errors are usually erroneous calls to OptionParser.add_option(), e.g. invalid option strings, unknown option attributes, missing option attributes, etc. These are dealt with in the usual way: raise an exception (either optparse.OptionError or TypeError) and let the program crash.

Handling user errors is much more important, since they are guaranteed to happen no matter how stable your code is. 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). Also, you can call OptionParser.error() to signal an application-defined error condition:

 
 
 
 

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

In either case, optparse handles the error the same way: it prints the program’s usage message and an error message to standard error and exits with error status 2.

Consider the first example above, where the user passes 4x to an option that takes an integer:

 
 
 
 

  
  
  
  
$ /usr/bin/foo -n 4x
  
  
  
  
Usage: foo [options]
  
  
  
  
  
  
  
  
foo: error: option -n: invalid integer value: '4x'
 
 
 
 

Or, where the user fails to pass a value at all:

 
 
 
 

  
  
  
  
$ /usr/bin/foo -n
  
  
  
  
Usage: foo [options]
  
  
  
  
  
  
  
  
foo: error: -n option requires an argument
 
 
 
 

optparse-generated error messages take care always to mention the option involved in the error; be sure to do the same when calling OptionParser.error() from your application code.

If optparse‘s default error-handling behaviour does not suit your needs, you’ll need to subclass OptionParser and override its exit() and/or error() methods.

Putting it all together

Here’s what optparse-based scripts usually look like:

 
 
 
 

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

參考指南

創(chuàng)建解析器

The first step in using optparse is to create an OptionParser instance.

class optparse.OptionParser(…)

The OptionParser constructor has no required arguments, but a number of optional keyword arguments. You should always pass them as keyword arguments, i.e. do not rely on the order in which the arguments are declared.

• usage (默認(rèn): "%prog [options]")

  The usage summary to print when your program is run incorrectly or with a help option. 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). To suppress a usage message, pass the special value optparse.SUPPRESS_USAGE.

  option_list (默認(rèn): [])

  A list of Option objects to populate the parser with. The options in option_list are added after any options in standard_option_list (a class attribute that may be set by OptionParser subclasses), but before any version or help options. Deprecated; use add_option() after creating the parser instead.

  option_class (默認(rèn): optparse.Option)

  Class to use when adding options to the parser in add_option().

  version (默認(rèn): None)

  A version string to print when the user supplies a version option. If you supply a true value for version, optparse automatically adds a version option with the single option string --version. The substring %prog is expanded the same as for usage.

  conflict_handler (默認(rèn): "error")

  Specifies what to do when options with conflicting option strings are added to the parser; see section Conflicts between options.

  description (默認(rèn): None)

  A paragraph of text giving a brief overview of your program. optparse reformats this paragraph to fit the current terminal width and prints it when the user requests help (after usage, but before the list of options).

  formatter (default: a new IndentedHelpFormatter)

  An instance of optparse.HelpFormatter that will be used for printing help text. optparse provides two concrete classes for this purpose: IndentedHelpFormatter and TitledHelpFormatter.

  add_help_option (默認(rèn): True)

  If true, optparse will add a help option (with option strings -h and --help) to the parser.

  prog

  The string to use when expanding %prog in usage and version instead of os.path.basename(sys.argv[0]).

  epilog (默認(rèn): None)

  A paragraph of help text to print after the option help.

填充解析器

There are several ways to populate the parser with options. The preferred way is by using OptionParser.add_option(), as shown in section 教程. add_option() can be called in one of two ways:

• pass it an Option instance (as returned by make_option())

• pass it any combination of positional and keyword arguments that are acceptable to make_option() (i.e., to the Option constructor), and it will create the Option instance for you

The other alternative is to pass a list of pre-constructed Option instances to the OptionParser constructor, as in:

 
 
 
 

  
  
  
  
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() is a factory function for creating Option instances; currently it is an alias for the Option constructor. A future version of optparse may split Option into several classes, and make_option() will pick the right class to instantiate. Do not instantiate Option directly.)

定義選項(xiàng)

Each Option instance represents a set of synonymous command-line option strings, e.g. -f and --file. You can specify any number of short or long option strings, but you must specify at least one overall option string.

The canonical way to create an Option instance is with the add_option() method of OptionParser.

OptionParser.add_option(option)

OptionParser.add_option(\opt_str, attr=value, …*)

To define an option with only a short option string:

 
 
 
 

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

And to define an option with only a long option string:

 
 
 
 

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

The keyword arguments define attributes of the new Option object. The most important option attribute is action, and it largely determines which other attributes are relevant or required. If you pass irrelevant option attributes, or fail to pass required ones, optparse raises an OptionError exception explaining your mistake.

An option’s action determines what optparse does when it encounters this option on the command-line. The standard option actions hard-coded into optparse are:

• "store"

  存儲(chǔ)此選項(xiàng)的參數(shù)（默認(rèn)）

  "store_const"

  store a constant value

  "store_true"

  store True

  "store_false"

  store False

  "append"

  append this option’s argument to a list

  "append_const"

  將常量值附加到列表

  "count"

  increment a counter by one

  "callback"

  調(diào)用指定函數(shù)

  "help"

  打印用法消息，包括所有選項(xiàng)和文檔

(If you don’t supply an action, the default is "store". For this action, you may also supply type and dest option attributes; see Standard option actions.)

As you can see, most actions involve storing or updating a value somewhere. optparse always creates a special object for this, conventionally called options (it happens to be an instance of optparse.Values). Option arguments (and various other values) are stored as attributes of this object, according to the dest (destination) option attribute.

For example, when you call

 
 
 
 

  
  
  
  
parser.parse_args()
 
 
 
 

one of the first things optparse does is create the options object:

 
 
 
 

  
  
  
  
options = Values()
 
 
 
 

If one of the options in this parser is defined with

 
 
 
 

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

and the command-line being parsed includes any of the following:

 
 
 
 

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

then optparse, on seeing this option, will do the equivalent of

 
 
 
 

  
  
  
  
options.filename = "foo"
 
 
 
 

The type and dest option attributes are almost as important as action, but action is the only one that makes sense for all options.

Option attributes

The following option attributes may be passed as keyword arguments to OptionParser.add_option(). If you pass an option attribute that is not relevant to a particular option, or fail to pass a required option attribute, optparse raises OptionError.

Option.action

(默認(rèn): "store")

Determines optparse‘s behaviour when this option is seen on the command line; the available options are documented here.

Option.type

(默認(rèn): "string")

The argument type expected by this option (e.g., "string" or "int"); the available option types are documented here.

Option.dest

(default: derived from option strings)

If the option’s action implies writing or modifying a value somewhere, this tells optparse where to write it: dest names an attribute of the options object that optparse builds as it parses the command line.

Option.default

The value to use for this option’s destination if the option is not seen on the command line. See also OptionParser.set_defaults().

Option.nargs

(默認(rèn): 1)

How many arguments of type type should be consumed when this option is seen. If > 1, optparse will store a tuple of values to dest.

Option.const

For actions that store a constant value, the constant value to store.

Option.choices

For options of type "choice", the list of strings the user may choose from.

Option.callback

For options with action "callback", the callable to call when this option is seen. See section Option Callbacks for detail on the arguments passed to the callable.

Option.callback_args

Option.callback_kwargs

Additional positional and keyword arguments to pass to callback after the four standard callback arguments.

Option.help

Help text to print for this option when listing all available options after the user supplies a help option (such as --help). If no help text is supplied, the option will be listed without help text. To hide this option, use the special value optparse.SUPPRESS_HELP.

Option.metavar

(default: derived from option strings)

Stand-in for the option argument(s) to use when printing help text. See section 教程 for an example.

Standard option actions

The various option actions all have slightly different requirements and effects. Most actions have several relevant option attributes which you may specify to guide optparse‘s behaviour; a few have required attributes, which you must specify for any option using that action.

• "store" [relevant: type, dest, nargs, choices]

  The option must be followed by an argument, which is converted to a value according to type and stored in dest. If nargs > 1, multiple arguments will be consumed from the command line; all will be converted according to type and stored to dest as a tuple. See the Standard option types section.

  If choices is supplied (a list or tuple of strings), the type defaults to "choice".

  If type is not supplied, it defaults to "string".

  If dest is not supplied, optparse derives a destination from the first long option string (e.g., --foo-bar implies foo_bar). If there are no long option strings, optparse derives a destination from the first short option string (e.g., -f implies f).

  示例:

     
     
     
     
  
      
      
      
      
  parser.add_option("-f")
      
      
      
      
  parser.add_option("-p", type="float", nargs=3, dest="point")
     
     
     
     

  As it parses the command line

     
     
     
     
  
      
      
      
      
  -f foo.txt -p 1 -3.5 4 -fbar.txt
     
     
     
     

  optparse will set

     
     
     
     
  
      
      
      
      
  options.f = "foo.txt"
      
      
      
      
  options.point = (1.0, -3.5, 4.0)
      
      
      
      
  options.f = "bar.txt"
     
     
     
     

• "store_const" [required: const; relevant: dest]

  The value const is stored in dest.

  示例:

     
     
     
     
  
      
      
      
      
  parser.add_option("-q", "--quiet",
      
      
      
      
   action="store_const", const=0,                                                 
  
                                                  新聞標(biāo)題：創(chuàng)新互聯(lián)Python教程：optparse—-命令行選項(xiàng)的解析器                                                
  
                                                  文章出自：http://m.5511xx.com/article/cosdcjg.html