python argparse庫的解釋與應用_ZenDei技術網路在線

argparse 是一個用於解析命令行選項，參數以及子命令的庫源碼來自 Lib/argparse.py 主要功能： 1、使得用戶編寫命令行變得簡單 2、針對程式需要的參數，argparse知道如何從sys.argv中解析這些參數 3、針對用戶給程式無效的參數，argparse可以自動生成幫助u ...

argparse 是一個用於解析命令行選項，參數以及子命令的庫

源碼來自 Lib/argparse.py

主要功能：

　　1、使得用戶編寫命令行變得簡單

　　2、針對程式需要的參數，argparse知道如何從sys.argv中解析這些參數

　　3、針對用戶給程式無效的參數，argparse可以自動生成幫助usage

　　　範例1: 寫一個python文件或者函數，這個python程式接受一個整數列表，並生成它們的和或者是它們之中最大的一個數

$ cat prog.py

#coding:utf-8
import argparse

parser = argparse.ArgumentParser(description='some integers')

parser.add_argument('integers', metavar='N', type=int, nargs='+',help='an integer for accumulator')
parser.add_argument('--sum', dest='accumulate', action= 'store_const', const=sum, default=max,help='sum the integers (default: find the max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

　　然後針對這個文件提供參數，或者是提供選項 -h

$ python prog.py 2 3 4 5
5
$ python prog.py --sum 1 5 67
73

$ python prog.py --help
usage: prog.py [-h] [--sum] N [N ...]

some integers

positional arguments:
  N           an integer for accumulator

optional arguments:
  -h, --help  show this help message and exit
  --sum       sum the integers (default: find the max)

$ python prog.py -h
usage: prog.py [-h] [--sum] N [N ...]

some integers

positional arguments:
  N           an integer for accumulator

optional arguments:
  -h, --help  show this help message and exit
  --sum       sum the integers (default: find the max)

　　當試圖傳入一個字元給程式時，會報錯

$ python prog.py a vb c
usage: prog.py [-h] [--sum] N [N ...]
prog.py: error: argument N: invalid int value: 'a'

1、創建一個命令行選項等的解析器

argparse.ArgumentParser會創建一個對象，這個對象包含了將命令行解析為 python數據類型所需的所有信息

argparse

方法一: add_argument()

　　　　用這個方法來填充ArgumentParser生成的對象，這個包含了程式參數的信息, 一般來說，這些調用可讓ArgumentParser如何在cmd命令行接受字元串

　　並把它們變成對象，當調用parse_args()時候，將存儲並使用該信息.

例如:

parser.add_argument('integers', metavar='N', type=int, nargs='+',help='an integer for accumulator')
parser.add_argument('--sum', dest='accumulate', action= 'store_const', const=sum, default=max,help='sum the integers (default: find the max)')

　　　　當調用parse_args()時，就會返回兩個屬性，integers 和 accumulater 屬性, integers 屬性接受一個數字或者是多個數字，

　　而accumulater屬性可以接受一個 --sum選項，當命令行中帶有 --sum選項以後，它代表的是系統的sum()函數的功能，若不帶--sum選項，就是代表max()函數功能

　　解析命令行參數:

　　　　ArgumentParser 通過parse_args()方法來解析這些參數, 它會檢測命令行，把不同的參數轉換成合適的格式從而調用不同的處理方式, 大多情況下，當從命令行解析參數時，會構建一個簡單的命名空間.

In [7]: parser.parse_args(['--sum','7','10','99'])
Out[7]: Namespace(accumulate=<built-in function sum>, integers=[7, 10, 99])

　　　　在腳本中，parse_args()通常不加參數的情況被調用, ArgumentParser 會從sys.argv自動匹配命令行裡面的參數

　　ArgumentParser方法分析

class argparse.ArgumentParser(prog=None, usage=None, 
description=None, epilog=None, parents=[], formatter_class=argparse.HelpFormatter, 
prefix_chars='-', fromfile_prefix_chars=None, argument_default=None, conflict_handler='error', add_help=True, allow_abbrev=True)

　　所有參數都需要以關鍵字參數來傳遞。

　　下麵是每個參數的詳細解釋:

- - prog => sys.argv[0] 這個腳本(程式）自身
  - usage => 來描述腳本(程式)的詳細信息(預設會從創建ArgumentParser的usage讀取)
  - description => 參數前顯示的幫助信息(預設為None)
  - epilog => 參數後顯示的幫助信息(預設為None)
  - parents => ArgumentParser方法包含的參數列表
  - formatter_class => 可定製的類來幫助輸出信息
  - prefix_chars => 可選參數的首碼(預設是'-')
  - fromfile_prefix_chars => 首碼文件的字元(預設是None）
  - argument_default => 全局預設的值(預設是None)
  - conflict_handler => 解決有衝突的選項(通常不需要)
  - add_help => 預設解析器會添加 -h 或者 --help選項(預設就含有)
  - allow_abbrev => 允許長選項使用縮寫

　　下麵是示例:

　　　prog:

　　　　預設情況下,ArgumentParser這個對象使用sys.argv[0]決定展示幫助頁面,當你在命令行調用這個程式自身，它會顯示幫助信息

　　例如，假如一個叫myprog.py的腳本

$ vim myprog.py
#!/usr/local/Cellar/pyenv/versions/3.6.1/bin/python3
#coding:utf-8


import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--foo',help='foo help')
args = parser.parse_args()


$ python myprog.py --help
usage: myprog.py [-h] [--foo FOO]

optional arguments:
  -h, --help  show this help message and exit
  --foo FOO   foo help

　　　　另一種方法，ArgumentParser 支持prog=的參數也可以達到同樣效果，代碼如下:　

In [1]: import argparse

In [2]: parser = argparse.ArgumentParser(prog='myprog')

In [3]: parser.print_help()
usage: myprog [-h]

optional arguments:
  -h, --help  show this help message and exit


#這裡要註意，執行當前shell的目錄里要有myprog.py這個文件

　　　　註意這個程式名稱，不管是使用sys.argv[0]還是prog=這種方法，都等價於使用%(prog)s 這個格式化方法

In [3]: parser.add_argument('--foo',help='foo of the %(prog)s program')
Out[3]: _StoreAction(option_strings=['--foo'], dest='foo', nargs=None, const=None, default=None, type=None, choices=None, help='foo of the %(prog)s program', metavar=None)

In [4]: parser.print_help()
usage: myprog [-h] [--foo FOO]

optional arguments:
  -h, --help  show this help message and exit
  --foo FOO   foo of the myprog program

　　　　或者使用usage=這種方法

In [2]: parser = argparse.ArgumentParser(prog='PROG',usage='%(prog)s [options]')

In [3]: parser.add_argument('--foo',nargs='?',help='foo help')
Out[3]: _StoreAction(option_strings=['--foo'], dest='foo', nargs='?', const=None, default=None, type=None, choices=None, help='foo help', metavar=None)

In [4]: parser.add_argument('bar',nargs='+',help='bar help')
Out[4]: _StoreAction(option_strings=[], dest='bar', nargs='+', const=None, default=None, type=None, choices=None, help='bar help', metavar=None)

In [5]: parser.print_help()
usage: PROG [options]

positional arguments:
  bar          bar help

optional arguments:
  -h, --help   show this help message and exit
  --foo [FOO]  foo help

　　description

　　　　　大多ArgumentParser實例在構造的時候都會使用description=這個參數，這個參數會告訴你程式是如何工作的，描述信息會顯示在usage和參數之間

In [1]: import argparse

In [2]: parser = argparse.ArgumentParser(description=' example ')

In [3]: parser.print_help()
usage: ipython [-h]

example

optional arguments:
  -h, --help  show this help message and exit

　　　　　預設情況下，description的就會顯示在這行里，可以通過formatter_class參數來修改

　epilog

　　　　　　主要針對有一些程式會在參數描述附加程式描述, 預設是顯示在optional argument描述以後

In [4]: parser = argparse.ArgumentParser(description=' example ',epilog=' haha that is the end' )

In [5]: parser.print_help()
usage: ipython [-h]

example

optional arguments:
  -h, --help  show this help message and exit

haha that is the end

　　　　　　如果想修改，需要調整formatter_class argument修改　　　　

　　parents

　　　　　有時候，幾個parser需要共用常見的參數。這時候，與其重覆的定義這些參數，不如使用一個包含所有參數的parser,然後再通過parents= 這個參數傳遞這些參數. parets= 參數可以接受一個ArgumentParser對象的列表，收集所有位置的和可選的操作，將這些操作加入一個正在構造的ArgumentParser 中

In [6]: parent_parser = argparse.ArgumentParser(add_help=False)

In [7]: parent_parser.add_argument('--parent',type=int)
Out[7]: _StoreAction(option_strings=['--parent'], dest='parent', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)

In [8]: foo_parser = argparse.ArgumentParser(parents=[parent_parser])

In [9]: foo_parser.add_argument('foo')
Out[9]: _StoreAction(option_strings=[], dest='foo', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)

In [10]: foo_parser.parse_args(['--parent','2','xx'])
Out[10]: Namespace(foo='xx', parent=2)

In [11]: bar_parser = argparse.ArgumentParser(parents=[parent_parser])

In [12]: bar_parser.add_argument('--bar')
Out[12]: _StoreAction(option_strings=['--bar'], dest='bar', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)

In [13]: bar_parser.parse_args(['--bar','yy'])
Out[13]: Namespace(bar='yy', parent=None)

In [14]: parent_parser.print_help()
usage: ipython [--parent PARENT]

optional arguments:
  --parent PARENT

In [15]: foo_parser.print_help()
usage: ipython [-h] [--parent PARENT] foo

positional arguments:
  foo

optional arguments:
  -h, --help       show this help message and exit
  --parent PARENT

In [16]: bar_parser.print_help()
usage: ipython [-h] [--parent PARENT] [--bar BAR]

optional arguments:
  -h, --help       show this help message and exit
  --parent PARENT
  --bar BAR

　　　　　這裡，我定義了一個父類parent_parser 以及兩個子類foo_parser 和bar_parser，這兩個子類明確指定了parents=[parent_parser]

　　　　　註意，這裡很多父類在初始化的時候都指定了 add_help=False, 如果不指定的話,當使用-h,或者--help的時候會看到兩個選項並且引發error　

　　　　　　還要註意，父類parser必須完全初始化才能通過 parents=傳給子類，如果你沒有這樣做的話，後面對於父類parser做的修改都不會反應在子類parser中

　　formatter_class

　　　 ArgumentParser對象允許一個可以定製化的類來被格式化, 目前，支持這4個類　　　

　　　　　　class argparse.RawDescriptionHelpFormatter
　　　　　　class argparse.RawTextHelpFormatter
　　　　　　class argparse.ArgumentDefaultsHelpFormatter
　　　　　　class argparse.MetavarTypeHelpFormatter

　　　　其中，RawDescriptionHelpFormatter and RawTextHelpFormatter 這兩個類會對文本顯示格式有更多的限定,在預設情況下，ArgumentParser會在顯示命令行幫助信息中對description= 和 epilog= 自動換行。

In [1]: import argparse

In [2]: parser = argparse.ArgumentParser(
   ...:     prog='PROG',
   ...:     description=''' that
   ...:         is
   ...:         a description ''',
   ...:     epilog=''' that
   ...:         is
   ...:         a epilog ''')
   ...:

In [3]: parser.print_help()
usage: PROG [-h]

that is a description     #可以看到自動換行

optional arguments:
  -h, --help  show this help message and exit

that is a epilog    　　　　#可以看到自動換行

　　　　通過傳遞formatter_class= 說明 description= 和 epilog= 已經被格式化並且不應該換行了

In [4]: parser = argparse.ArgumentParser(prog='hey!',
   ...:         formatter_class=argparse.RawDescriptionHelpFormatter,
   ...:         description=''' let
   ...:             us
   ...:             do it''')
   ...:

In [5]: parser.print_help()
usage: hey! [-h]

 let
            us
            do it

optional arguments:
  -h, --help  show this help message and exit

　　　　RawTextHelpFormatter 為各種幫助信息保留了空白，包括參數描述信息　　　　　　

　　　　ArgumentDefaultsHelpFormatter這個類會自動為每個參數的幫助信息添加預設值

In [9]: parser = argparse.ArgumentParser(
   ...:     prog='hey',
   ...:     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
   ...:

In [10]: parser.add_argument('--foo',type=int,default=42,help='foo!')
Out[10]: _StoreAction(option_strings=['--foo'], dest='foo', nargs=None, const=None, default=42, type=<class 'int'>, choices=None, help='foo!', metavar=None)

In [11]: parser.add_argument('bar',nargs='*',default=[1,2,3,4],help='bar!')
Out[11]: _StoreAction(option_strings=[], dest='bar', nargs='*', const=None, default=[1, 2, 3, 4], type=None, choices=None, help='bar!', metavar=None)

In [12]: parser.print_help()
usage: hey [-h] [--foo FOO] [bar [bar ...]]

positional arguments:
  bar         bar! (default: [1, 2, 3, 4])

optional arguments:
  -h, --help  show this help message and exit
  --foo FOO   foo! (default: 42)

　　　　MetavarTypeHelpFormatter 為每個參數以參數的類型作為顯示，摒棄了常規使用dest的模式

In [13]: parser = argparse.ArgumentParser(
    ...:     prog='HELP',
    ...:     formatter_class=argparse.MetavarTypeHelpFormatter)
    ...:

In [14]: parser.add_argument('--foo',type=int)
Out[14]: _StoreAction(option_strings=['--foo'], dest='foo', nargs=None, const=None, default=None, type=<class 'int'>, choices=None, help=None, metavar=None)

In [15]: parser.add_argument('bar',type=float)
Out[15]: _StoreAction(option_strings=[], dest='bar', nargs=None, const=None, default=None, type=<class 'float'>, choices=None, help=None, metavar=None)

In [16]: parser.print_help()
usage: HELP [-h] [--foo int] float

positional arguments:
  float

optional arguments:
  -h, --help  show this help message and exit
  --foo int

prefix_chars
　　　　許多命令行選項都用"-" 當首碼，比如 -h 或者 --help,Parser可以通過prefix_chars來設置不同的首碼符號
　　　　你可以用"+" 或者使用"/"

 1 In [1]: import argparse
 2 
 3 In [2]: parser = argparse.ArgumentParser(prog='PROG',prefix_chars="-+")
 4 
 5 In [3]: parser.add_argument('+f')
 6 Out[3]: _StoreAction(option_strings=['+f'], dest='f', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
 7 
 8 In [4]: parser.add_argument('++bar')
 9 Out[4]: _StoreAction(option_strings=['++bar'], dest='bar', nargs=None, const=None, default=None, type=None, choices=None, help=None, metavar=None)
10 In [5]: parser.print_help()
11 
12 
13 
14 In [5]: parser.print_help()
15 usage: PROG [-h] [+f F] [++bar BAR]
16 
17 optional arguments:
18   -h, --help  show this help message and exit
19   +f F
20   ++bar BAR

　　　　prefix_chars= 預設的參數是'-'.

　　fromfile_prefix_chars

　　　　有的情況下，當處理特別長的參數列表，將這個參數列表保存在文件中，也可以支持

　　　　這個需要在構建ArgumentParser的時候加入 fromfile_prefix_chars= 選項

　　argument_default

　　　　一般來說，參數都通過add_argument()來指定或者通過調用setdefaults()傳遞name-value的方法
　　　　有時候，需要為參數指定一個單獨的預設值，通過給ArgumentParser指定argument_default關鍵字參數即可
　　　　比如，可以通過argument_default=SUPPERSS來阻止在parse_args()中全局創建屬性
　　
　conflict_handler

　　　　ArgumentParser 對象不允許使用同一個選項字串來表示兩個操作,若嘗試在 已經使用的選項新建一個參數的話，就說引發異常

1 In [7]: parser = argparse.ArgumentParser(prog='PROG')
2 
3 In [8]: parser.add_argument('-f','--foo',help='old foo help')
4 Out[8]: _StoreAction(option_strings=['-f', '--foo'], dest='foo', nargs=None, const=None, default=None, type=None, choices=None, help='old foo help', metavar=None)
5 
6 In [9]: parser.add_argument('--foo',help='new foo help')
7 ---------------------------------------------------------------------------
8 ArgumentError                             Traceback (most recent call last)

　　　　　可以使用選項 conflict_handler='resolve'

 1 In [10]: parser = argparse.ArgumentParser(prog='PROG',conflict_handler='resolve'
 2     ...: )
 3 
 4 In [11]: parser.add_argument('-f','--foo',help='old foo help')
 5 Out[11]: _StoreAction(option_strings=['-f', '--foo'], dest='foo', nargs=None, const=None, default=None, type=None, choices=None, help='old foo help', metavar=None)
 6 
 7 In [12]: parser.add_argument('--foo',help='new foo help')
 8 Out[12]: _StoreAction(option_strings=['--foo'], dest='foo', nargs=None, const=None, default=None, type=None, choices=None, help='new foo help', metavar=None)
 9 
10 In [13]: parser.print_help()
11 usage: PROG [-h] [-f FOO] [--foo FOO]
12 
13 optional arguments:
14   -h, --help  show this help message and exit
15   -f FOO      old foo help
16   --foo FOO   new foo help

　　　　　　ArgumentParser 僅移除這個動作，假如所有的選項字元串都被覆蓋了

　　add_help
　　　　　　預設情況下，ArgumentParser對象在創建選項會帶著parser的幫助信息
　　　
下一篇介紹ArgumentParser
The add_argument() 方法

python argparse庫的解釋與應用

argparse 是一個用於解析 命令行選項，參數以及 子命令的庫

源碼來自 Lib/argparse.py

主要功能：

1、使得用戶編寫命令行變得簡單

2、針對程式需要的參數，argparse知道如何從sys.argv中解析這些參數

3、針對用戶給程式無效的參數，argparse可以自動生成幫助usage

範例1: 寫一個python文件或者函數，這個python程式接受一個整數列表，並生成它們的和 或者是它們之中最大的一個數

1、創建一個命令行選項等的解析器

argparse

方法一: add_argument()

解析命令行參數:

ArgumentParser方法分析

prog:

description

formatter_class

ArgumentParser對象允許一個可以定製化的類來被格式化, 目前，支持這4個類

argparse 是一個用於解析命令行選項，參數以及子命令的庫

　　1、使得用戶編寫命令行變得簡單

　　2、針對程式需要的參數，argparse知道如何從sys.argv中解析這些參數

　　3、針對用戶給程式無效的參數，argparse可以自動生成幫助usage

　　　範例1: 寫一個python文件或者函數，這個python程式接受一個整數列表，並生成它們的和或者是它們之中最大的一個數

　　解析命令行參數:

　　ArgumentParser方法分析

　　　prog:

　　description

　　formatter_class

　　　 ArgumentParser對象允許一個可以定製化的類來被格式化, 目前，支持這4個類　　　