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

 

 

原文連接：https://www.cnblogs.com/piperck/p/8446580.html

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

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)
  
  

  parser = argparse.ArgumentParser()
  aa=parser.add_argument('--foo', action='store_const', const=42)
  bb=parser.parse_args('--foo'.split())
  print(aa)
  print('----------------------------')
  print(bb)

  _StoreConstAction(option_strings=['--foo'], dest='foo', nargs=0, const=42, default=None, type=None, choices=None, help=None, metavar=None)
  ----------------------------
  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 的實現。自定義 action 方法須要繼承自 argparse.Action 類 而且實現一個 __call__ 方法。 __call__ 方法須要定義四個參數變量:

• parser - 包含該動做的ArgumentParser對象。
• namespace - parse_args()返回的Namespace對象。大部分動做會給該對象添加一個屬性。
• values - 相關聯的命令行參數於類型轉換以後的值。（類型轉換方式經過add_argument()的type關鍵字參數指定。）
• option_string - 調用該動做的選項字符串。option_string參數是可選的，若是動做關聯的位置參數將不會出現。

 這裏有個事例簡單的易懂我直接上代碼了：

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

 

 

若是咱們不想輸入某些參數怎麼辦呀？

簡單！直接在他們名字前添加--就好啦~ 咱們對剛剛的程序作個小修改

import argparse
parser = argparse.ArgumentParser()
parser.description='餵我兩個數字，我就吐出他們的積' parser.add_argument("--ParA", help="我是A",type=int) parser.add_argument("--ParB", help="我是B",type=int) args = parser.parse_args() if args.ParA: print("我只吃到了A，它是",args.ParA) if args.ParB: print("我只吃到了B，它是",args.ParB) if args.ParA and args.ParB: print("啊，兩個都吃到啦！積是",args.ParA*args.ParB) 

不過此次因爲有些參數不肯定是否輸入，因此在輸入參數的時候咱們須要告訴程序咱們想要對哪一個參數賦值~

 

 

每次都要輸入或者好累啊有木有.... 好懶的 T^T，因此咱們再作些修改吧，儘量的偷個懶=-=

import argparse
parser = argparse.ArgumentParser()
parser.description='餵我兩個數字，我就吐出他們的積' parser.add_argument("-a","--ParA", help="我是A",type=int) parser.add_argument("-b","--ParB", help="我是B",type=int) args = parser.parse_args() if args.ParA: print("我只吃到了A，它是",args.ParA) if args.ParB: print("我只吃到了B，它是",args.ParB) if args.ParA and args.ParB: print("啊，兩個都吃到啦！積是",args.ParA*args.ParB) 

如今，咱們就能夠用或者輸入參數啦~彷佛也沒有輕鬆多少....都是騙人的T^T

 

連接：https://www.jianshu.com/p/00425f6c0936

 

Reference:

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

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

 

經過Python的argparse模塊解析命令行選項

目錄

做者：楊冬 歡迎轉載，也請保留這段聲明。謝謝！
出處：https://andyyoung01.github.io/ 或 http://andyyoung01.16mb.com/

若是想要經過Python寫出一個基於命令行的程序，若是程序的命令行參數較多，可使用Python內置的argparse模塊來處理命令行參數。

能夠經過一個實例程序來探索argparse的用法：

search.py

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

import argparse   parser = argparse.ArgumentParser(description= 'Search some files')   parser.add_argument(dest= 'filenames',metavar='filename', nargs='*')   parser.add_argument( '-p', '--pat',metavar='pattern', required=True, dest= 'patterns', action='append', help= 'text pattern to search for')   parser.add_argument( '-v', dest='verbose', action='store_true', help= 'verbose mode')   parser.add_argument( '-o', dest='outfile', action='store', help= 'output file')   parser.add_argument( '--speed', dest='speed', action='store', choices={ 'slow','fast'}, default='slow', help= 'search speed')   args = parser.parse_args()   # Output the collected arguments print(args.filenames) print(args.patterns) print(args.verbose) print(args.outfile) print(args.speed)

 

#python3 argtest.py -p a -v 4 -o /mcw/abc/ --speed fast
Namespace(filenames=['4'], outfile='/mcw/abc/', patterns=['a'], speed='fast', verbose=True)
['4']
['a']
True
/mcw/abc/
fast

 

能夠經過以下的方式使用上面定義的腳本文件：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

[yangdong@centos7 ~]$ python3 search.py -h usage: search.py [-h] [-p pattern] [-v] [-o OUTFILE] [--speed {slow,fast}] [filename [filename ...]]   Search some files   positional arguments: filename   optional arguments: -h, --help show this help message and exit -p pattern, --pat pattern text pattern to search for -v verbose mode -o OUTFILE output file --speed {slow,fast} search speed   [yangdong@centos7 ~]$ python3 search.py foo.txt bar.txt usage: search.py [-h] -p pattern [-v] [-o OUTFILE] [--speed {fast,slow}] [filename [filename ...]] search.py: error: the following arguments are required: -p/--pat   [yangdong@centos7 ~]$ python3 search.py -v -p spam --pat=eggs foo.txt bar.txt filenames = ['foo.txt', 'bar.txt'] patterns = ['spam', 'eggs'] verbose = True outfile = None speed = slow   [yangdong@centos7 ~]$ python3 search.py -v -p spam --pat=eggs foo.txt bar.txt -o results filenames = ['foo.txt', 'bar.txt'] patterns = ['spam', 'eggs'] verbose = True outfile = results speed = slow   [yangdong@centos7 ~]$ python3 search.py -v -p spam --pat=eggs foo.txt bar.txt -o results \ --speed=fast filenames = ['foo.txt', 'bar.txt'] patterns = ['spam', 'eggs'] verbose = True outfile = results speed = fast   Namespace(filenames=['foo.txt', 'bar.txt'], outfile='results', patterns=['spam', 'eggs'], speed='fast', verbose=True) 點鍵取值。有choices的就是能夠=賦值  。鍵是dest目標

 

爲了解析命令行選項，你首先要建立一個ArgumentParser實例， 並使用add_argument()方法聲明你想要支持的選項。 在每一個add_argument()調用中，dest參數指定將解析結果存入以該參數命名的屬性中。metavar參數被用來生成幫助信息。action參數指定跟屬性對應的處理邏輯，一般的值爲store ,被用來存儲某個值或將多個參數值收集到一個列表中。 更詳細的add_argument()的參數解釋請參考官網（或中文翻譯）。
在設置完參數後，即可以執行parser.parse()方法了。它會處理sys.argv的值並返回一個結果實例。每一個參數值都會被設置成該實例中add_argument()方法的dest參數指定的屬性值。

還不少種其餘方法解析命令行選項。 例如，你可能會手動的處理 sys.argv 或者使用 getopt 模塊。 可是，若是你採用本節的方式，將會減小不少冗餘代碼，底層細節 argparse 模塊已經幫你處理了。 你可能還會碰到使用 optparse 庫解析選項的代碼。 儘管 optparse 和 argparse 很像，可是後者更先進，所以在新的程序中你應該使用它。