Python 命令行工具 argparse 模塊使用詳解

先來介紹一把最基本的用法

import argparse


parser = argparse.ArgumentParser()
parser.parse_args()

在執行 parse_args() 之前，所有追加到命令行的參數都不會生效，生效了之后的默認情況類似於這樣：

 

設置默認參數函數：

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("echo")
args = parser.parse_args()
print args.echo

當我們需要設置一個默認參數使用的時候，我們可以這么做達到的效果是這樣的：

 第二行是我直接打印 print args 的效果。可以看到是一個 Namespace 對象。

當我直接輸入 -h 參數的時候可以看到命令行會提示我們 positional arguments 是 echo 是必填。

 

下面繼續來定義可選參數

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbosity", help="increase output verbosity")
args = parser.parse_args()
if args.verbosity:
    print "verbosity turned on"

我們看到的效果是這樣的：

可見，如果用省略方法 -v 賦值的方法，最終會到達 --verbosity 值會傳遞到這個完整的參數中去。這里值得一提的是，如果沒有后面的 --verbosity 只有 -v 的話，那么值會可以通過 args.v 得到。

 

當然也有可以不指定值的方法，可以讓此值直接默認設置為 bool 值，而使用 action='store_true' 可以做到

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbosity", help="increase output verbosity", action="store_true")
args = parser.parse_args()
print args.verbosity

獲得的效果如下。

 

常規用法大致介紹了一把。下面我們來看下具體的函數都做了哪些工作。

可以注意到我們每次都會去初始化一把 ArgumentParser類，他的初始化定義如下：

class ArgumentParser(_AttributeHolder, _ActionsContainer):
    """Object for parsing command line strings into Python objects.

    Keyword Arguments:
        - prog -- The name of the program (default: sys.argv[0])
        - usage -- A usage message (default: auto-generated from arguments)
        - description -- A description of what the program does
        - epilog -- Text following the argument descriptions
        - parents -- Parsers whose arguments should be copied into this one
        - formatter_class -- HelpFormatter class for printing help messages
        - prefix_chars -- Characters that prefix optional arguments
        - fromfile_prefix_chars -- Characters that prefix files containing
            additional arguments
        - argument_default -- The default value for all arguments
        - conflict_handler -- String indicating how to handle conflicts
        - add_help -- Add a -h/-help option
    """

    def __init__(self,
                 prog=None,
                 usage=None,
                 description=None,
                 epilog=None,
                 version=None,
                 parents=[],
                 formatter_class=HelpFormatter,
                 prefix_chars='-',
                 fromfile_prefix_chars=None,
                 argument_default=None,
                 conflict_handler='error',
                 add_help=True):

• prog - 程序的名字（默認：sys.argv[0]）
• usage - 描述程序用法的字符串（默認：從解析器的參數生成）
• description - 參數幫助信息之前的文本（默認：空）
• epilog - 參數幫助信息之后的文本（默認：空）
• parents - ArgumentParser 對象的一個列表，這些對象的參數應該包括進去
• formatter_class - 定制化幫助信息的類
• prefix_chars - 可選參數的前綴字符集（默認：‘-‘）
• fromfile_prefix_chars - 額外的參數應該讀取的文件的前綴字符集（默認：None）
• argument_default - 參數的全局默認值（默認：None）
• conflict_handler - 解決沖突的可選參數的策略（通常沒有必要）
• add_help - 給解析器添加-h/–help 選項（默認：True）

 

我們可以來看下常用必填參數都加上的效果

# coding: utf-8
import argparse

x = argparse.ArgumentParser(prog='It\'s a cool job!',
                            usage='正常使用我就可以了',
                            description='那你說個毛',
                            epilog='我是 EPILOG')
x.add_argument('-v', help='gg 斯密達')
x.parse_args()

值得注意的一點是，當我使用了 usage 的參數之后，他似乎在同樣的位置覆蓋了 prog 參數里面的值。

其他幾個設置比較少用到，如果要使用可以查詢 refrence 1 里面的文檔。也可直接訪問官方文檔查看用法。

 

下面重點說下 ArgumentParser.add_argument。不知道在 python 的哪個版本，標准庫調整了這個地方。目前在標准庫里面看到的情況是這樣的：

def add_argument(self, *args, **kwargs):
    """
    add_argument(dest, ..., name=value, ...)
    add_argument(option_string, option_string, ..., name=value, ...)
    """

    # if no positional args are supplied or only one is supplied and
    # it doesn't look like an option string, parse a positional
    # argument

查閱之前的文檔應該是這樣：

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])
定義應該如何解析一個命令行參數。下面每個參數有它們自己詳細的描述，簡單地講它們是：

name or flags - 選項字符串的名字或者列表，例如foo 或者-f, --foo。
action - 在命令行遇到該參數時采取的基本動作類型。
nargs - 應該讀取的命令行參數數目。
const - 某些action和nargs選項要求的常數值。
default - 如果命令行中沒有出現該參數時的默認值。
type - 命令行參數應該被轉換成的類型。
choices - 參數可允許的值的一個容器。
required - 該命令行選項是否可以省略（只針對可選參數）。
help - 參數的簡短描述。
metavar - 參數在幫助信息中的名字。
dest - 給parse_args()返回的對象要添加的屬性名稱。

我們按照以前的參數來介紹一下，因為我測試了一把用法上都沒有改變。我目前的 python 版本是2.7.13。 add_argument 方法也被放進了父類 _ActionsContainer 中。

 

name or flags: 這個就是我們可以直接寫名字，如果直接寫名字這就是一個必填參數，例子可以參考上面的例子。如果是 flags 就要帶上 - 或者 -- 。這個 argparse 模塊會幫我們自動解析。

action: 這個參數算是一個重頭戲而且可以繼承 argparse.Action 定制自己的 action 。先介紹幾個這個參數常用的變量

'store' - 只是保存參數的值。這是默認的動作。例如：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.parse_args('--foo 1'.split())
Namespace(foo='1')
'store_const' - 保存由const關鍵字參數指出的值。（注意const關鍵字參數默認是幾乎沒有幫助的None。）'store_const'動作最常用於指定某種標記的可選參數。例如：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='store_const', const=42)
>>> parser.parse_args('--foo'.split())
Namespace(foo=42)
'store_true'和'store_false' - 它們是'store_const' 的特殊情形，分別用於保存值True和False。另外，它們分別會創建默認值False 和True。例如：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='store_true')
>>> parser.add_argument('--bar', action='store_false')
>>> parser.add_argument('--baz', action='store_false')
>>> parser.parse_args('--foo --bar'.split())
Namespace(bar=False, baz=True, foo=True)
'append' - 保存一個列表，並將每個參數值附加在列表的后面。這對於允許指定多次的選項很有幫助。示例用法：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action='append')
>>> parser.parse_args('--foo 1 --foo 2'.split())
Namespace(foo=['1', '2'])
'append_const' - 保存一個列表，並將const關鍵字參數指出的值附加在列表的后面。（注意const關鍵字參數默認是None。）'append_const' 動作在多個參數需要保存常量到相同的列表時特別有用。例如：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--str', dest='types', action='append_const', const=str)
>>> parser.add_argument('--int', dest='types', action='append_const', const=int)
>>> parser.parse_args('--str --int'.split())
Namespace(types=[<type 'str'>, <type 'int'>])
'count' - 計算關鍵字參數出現的次數。例如，這可用於增加詳細的級別：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--verbose', '-v', action='count')
>>> parser.parse_args('-vvv'.split())
Namespace(verbose=3)
'help' - 打印當前解析器中所有選項的完整的幫助信息然后退出。默認情況下，help動作會自動添加到解析器中。參見ArgumentParser以得到如何生成輸出信息。

'version' - 它期待version=參數出現在add_argument()調用中，在調用時打印出版本信息並退出：

>>>
>>> import argparse
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')
>>> parser.parse_args(['--version'])
PROG 2.0

 

自定義 action 的實現：

>>> class FooAction(argparse.Action):
...     def __call__(self, parser, namespace, values, option_string=None):
...         print '%r %r %r' % (namespace, values, option_string)
...         setattr(namespace, self.dest, values)
...
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', action=FooAction)
>>> parser.add_argument('bar', action=FooAction)
>>> args = parser.parse_args('1 --foo 2'.split())
Namespace(bar=None, foo=None) '1' None
Namespace(bar='1', foo=None) '2' '--foo'
>>> args
Namespace(bar='1', foo='2')

可以直接看到打印的那一行，當我們在執行完 parse_args 的時候，執行到了 print '%r %r %r' % (namespace, values, option_string) 所以打印了出來。

可以看到 namespace 參數是一個 namespace 對象，values 就是給定的值， option_string  如果有可選參數就會加入進這個，如果沒有則為 None。

 那么有人會問， 那 parser 這個參數呢，這個參數經過我的測試就是 .add_argument 之前的那個對象，一模一樣，會被傳遞進去。知道了這些，就可以基於這些知識對 action 這個方法做一些魔改了。這里就不展開了，根據需求定制即可。

 

nargs：這個入參可以設置一個 參數后面可以接收幾個值，而且提供了類似於正則的符號來通配一些行為。

ArgumentParser對象通常將一個動作與一個命令行參數關聯。nargs關鍵字參數將一個動作與不同數目的命令行參數關聯在一起。它支持的值有：

N（一個整數）。命令行中的N個參數將被一起收集在一個列表中。例如：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', nargs=2)
>>> parser.add_argument('bar', nargs=1)
>>> parser.parse_args('c --foo a b'.split())
Namespace(bar=['c'], foo=['a', 'b'])
注意nargs=1生成一個只有一個元素的列表。這和默認的行為是不一樣的，默認情況下生成的是元素自己。

'?'。如果有的話就從命令行讀取一個參數並生成一個元素。如果沒有對應的命令行參數，則產生一個來自default的值。注意，對於可選參數，有另外一種情況 - 有選項字符串但是后面沒有跟隨命令行參數。在這種情況下，將生成一個來自const的值。用一些例子加以解釋：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', nargs='?', const='c', default='d')
>>> parser.add_argument('bar', nargs='?', default='d')
>>> parser.parse_args('XX --foo YY'.split())
Namespace(bar='XX', foo='YY')
>>> parser.parse_args('XX --foo'.split())
Namespace(bar='XX', foo='c')
>>> parser.parse_args(''.split())
Namespace(bar='d', foo='d')
nargs='?'的一種更常見的用法是允許可選的輸入和輸出文件：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
...                     default=sys.stdin)
>>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'),
...                     default=sys.stdout)
>>> parser.parse_args(['input.txt', 'output.txt'])
Namespace(infile=<open file 'input.txt', mode 'r' at 0x...>,
          outfile=<open file 'output.txt', mode 'w' at 0x...>)
>>> parser.parse_args([])
Namespace(infile=<open file '<stdin>', mode 'r' at 0x...>,
          outfile=<open file '<stdout>', mode 'w' at 0x...>)
'*'。出現的所有命令行參數都被收集到一個列表中。注意，一般情況下具有多個帶有nargs='*'的位置參數是不合理的，但是多個帶有nargs='*'的可選參數是可能的。例如：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', nargs='*')
>>> parser.add_argument('--bar', nargs='*')
>>> parser.add_argument('baz', nargs='*')
>>> parser.parse_args('a b --foo x y --bar 1 2'.split())
Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])
'+'。和'*'一樣，出現的所有命令行參數都被收集到一個列表中。除此之外，如果沒有至少出現一個命令行參數將會產生一個錯誤信息。例如：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('foo', nargs='+')
>>> parser.parse_args('a b'.split())
Namespace(foo=['a', 'b'])
>>> parser.parse_args(''.split())
usage: PROG [-h] foo [foo ...]
PROG: error: too few arguments
argparse.REMAINDER.所有剩余的命令行參數都被收集到一個列表中。這通常用於命令行工具分發命令到其它命令行工具：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('--foo')
>>> parser.add_argument('command')
>>> parser.add_argument('args', nargs=argparse.REMAINDER)
>>> print parser.parse_args('--foo B cmd --arg1 XX ZZ'.split())
Namespace(args=['--arg1', 'XX', 'ZZ'], command='cmd', foo='B')
如果沒有提供nargs關鍵字參數，讀取的參數個數取決於action。通常這意味着將讀取一個命令行參數並產生一個元素（不是一個列表）。

const: const 參數在某些特定的 action 上面已經介紹到了會被使用，還有就是 nargs 是 '?' 的時候會優先使用 const 里面的值。

default:  對於參數，default的值用於選項字符串沒有出現在命令行中的時候。

type: 可以設置傳入參數要求的類型。

choices: 可以設置填入的參數在 choices 指定的范圍內。

require: 有此參數，如果傳入的時候沒有將報出一個錯誤。

help: 填寫該參數背后的一些幫助信息。

metavar 和 dst 放在一起說吧：

當ArgumentParser生成幫助信息時，它需要以某種方式引用每一個參數。 默認情況下，ArgumentParser對象使用dest的值作為每個對象的“名字”。默認情況下，對於位置參數直接使用dest的值，對於可選參數則將dest的值變為大寫。所以，位置參數dest='bar'將引用成bar。后面帶有一個命令行參數的可選參數--foo將引用成FOO。一個例子：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo')
>>> parser.add_argument('bar')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage:  [-h] [--foo FOO] bar

positional arguments:
 bar

optional arguments:
 -h, --help  show this help message and exit
 --foo FOO
可以用metavar指定另外一個名字：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', metavar='YYY')
>>> parser.add_argument('bar', metavar='XXX')
>>> parser.parse_args('X --foo Y'.split())
Namespace(bar='X', foo='Y')
>>> parser.print_help()
usage:  [-h] [--foo YYY] XXX

positional arguments:
 XXX

optional arguments:
 -h, --help  show this help message and exit
 --foo YYY
注意metavar只會改變顯示出來的名字 - parse_args() 對象中屬性的名字仍然由dest的值決定。

nargs的不同值可能導致metavar使用多次。傳遞一個列表給metavar將給每個參數指定一個不同的顯示名字：

>>>
>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-x', nargs=2)
>>> parser.add_argument('--foo', nargs=2, metavar=('bar', 'baz'))
>>> parser.print_help()
usage: PROG [-h] [-x X X] [--foo bar baz]

optional arguments:
 -h, --help     show this help message and exit
 -x X X
 --foo bar baz
大部分ArgumentParser動作給parse_args()返回對象的某個屬性添加某些值。該屬性的名字由add_argument()的dest關鍵字參數決定。對於位置參數的動作，dest 通常作為第一個參數提供給add_argument()：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('bar')
>>> parser.parse_args('XXX'.split())
Namespace(bar='XXX')
對於可選參數的動作，dest的動作通常從選項字符串推導出來。ArgumentParser生成的dest的值是將第一長的選項字符串前面的--字符串去掉。如果沒有提供長選項字符串，dest的獲得則是將第一個短選項字符串前面的-字符去掉。任何內部的-將被轉換為_字符以確保字符串是合法的屬性名字。下面的實例解釋了這個行為：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('-f', '--foo-bar', '--foo')
>>> parser.add_argument('-x', '-y')
>>> parser.parse_args('-f 1 -x 2'.split())
Namespace(foo_bar='1', x='2')
>>> parser.parse_args('--foo 1 -y 2'.split())
Namespace(foo_bar='1', x='2')
dest允許提供自定義的屬性名：

>>>
>>> parser = argparse.ArgumentParser()
>>> parser.add_argument('--foo', dest='bar')
>>> parser.parse_args('--foo XXX'.split())
Namespace(bar='XXX')

 

 

Reference:

https://www.jianshu.com/p/fef2d215b91d  python argparse用法總結

http://python.usyiyi.cn/translate/python_278/library/argparse.html  argparse官方文檔翻譯