Explication sur l'utilisation de la bibliothèque python argparse

argparse est une bibliothèque pour analyser les options, paramètres et sous-commandes de ligne de commande

Source le code vient de Lib/argparse.py

Fonctions principales :

1. Faciliter l'écriture des lignes de commande par les utilisateurs

　2. Pour les paramètres requis par le programme, argparse sait comment analyser ces paramètres à partir de sys.argv

　3. Pour les paramètres invalides donnés par l'utilisateur au programme, argparse peut générer automatiquement aide à l'utilisation

Exemple 1 : Écrire un fichier ou une fonction python Ce programme python accepte une liste d'entiers et génère leur somme ou le plus grand nombre parmi eux

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

　

Ensuite, fournissez les paramètres de ce fichier, ou fournissez l'option -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)

 

Lorsque vous essayez de transmettre un caractère dans le programme, une erreur sera signalée

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

1. Créez un analyseur pour les options de ligne de commande, etc.

argparse.ArgumentParser créera un objet contenant toutes les informations nécessaires pour analyser la ligne de commande en types de données Python

argparse

Méthode 1 : add_argument()

Utilisez cette méthode pour remplir l'objet généré par ArgumentParser, qui contient des informations sur les paramètres du programme. Ces appels permettent à ArgumentParser d'accepter des chaînes

sur la ligne de commande cmd et de les transformer en objets Lorsque parse_args() est appelé, les informations seront stockées et utilisées.< 🎜. > Par exemple :

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

　

Lorsque parse_args() est appelé, deux attributs seront renvoyés, les entiers et les attributs d'accumulateur. L'attribut entiers accepte. Un nombre ou plusieurs nombres,

L'attribut accumulateur peut accepter une option --sum Lorsque l'option --sum est incluse dans la ligne de commande, elle représente la somme du système. La fonction de la fonction (), sans l'option --sum, représente la fonction de la fonction max()

　

Analyse des paramètres de ligne de commande :

ArgumentParser analyse ces paramètres via la méthode parse_args(). Il détectera la ligne de commande, convertira différents paramètres dans des formats appropriés et appellera différentes méthodes de traitement. Dans la plupart des cas, lors de l'analyse des paramètres à partir de la ligne de commande, un simple espace de noms.

.

　

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

Dans les scripts, parse_args() est généralement appelé sans paramètres, et ArgumentParser correspondra automatiquement à la ligne de commande de sys.argv Les paramètres à l'intérieur de

Analyse de la méthode ArgumentParser

　　所有参数都需要以关键字参数来传递。

　　下面是每个参数的详细解释:

• 
  

• 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:

　　　　默认情况下,<span class="pre">ArgumentParser这个对象使用sys.argv[0]决定展示帮助页面,当你在命令行 调用这个程序自身，它会显示帮助信息</span>

　　例如，假如一个叫myprog.py的脚本

$ vim myprog.py#!/usr/local/Cellar/pyenv/versions/3.6.1/bin/python3#coding:utf-8import 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 argparseIn [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=[&#39;--parent&#39;], dest=&#39;parent&#39;, nargs=None, const=None, default=None, type=<class &#39;int&#39;>, choices=None, help=None, metavar=None)

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

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

In [10]: foo_parser.parse_args([&#39;--parent&#39;,&#39;2&#39;,&#39;xx&#39;])
Out[10]: Namespace(foo=&#39;xx&#39;, parent=2)

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

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

In [13]: bar_parser.parse_args([&#39;--bar&#39;,&#39;yy&#39;])
Out[13]: Namespace(bar=&#39;yy&#39;, 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 <span class="highlighted">argparse.</span>RawDescriptionHelpFormatter

• 　　　　　　class <span class="highlighted">argparse.</span>RawTextHelpFormatter

• 　　　　　　class <span class="highlighted">argparse.</span>ArgumentDefaultsHelpFormatter

• 　　　　　　class <span class="highlighted">argparse.</span>MetavarTypeHelpFormatter

　　　　<span style="font-size: 12px">其中，<code class="xref py py-class docutils literal"><span class="pre">RawDescriptionHelpFormatter</span> and <span class="pre">RawTextHelpFormatter</span> 这两个类会对文本显示格式有更多的限定,在默认情况下，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

　　　　<span style="font-size: 12px"><code class="xref py py-class docutils literal"><span class="pre">RawTextHelpFormatter 为各种帮助信息保留了空白，包括参数描述信息</span>　　 　　　　

　　　　<span class="pre">ArgumentDefaultsHelpFormatter这个类会自动为每个参数的帮助信息添加默认值</span>

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=[&#39;--foo&#39;], dest=&#39;foo&#39;, nargs=None, const=None, default=42, type=<class &#39;int&#39;>, choices=None, help=&#39;foo!&#39;, metavar=None)

In [11]: parser.add_argument(&#39;bar&#39;,nargs=&#39;*&#39;,default=[1,2,3,4],help=&#39;bar!&#39;)
Out[11]: _StoreAction(option_strings=[], dest=&#39;bar&#39;, nargs=&#39;*&#39;, const=None, default=[1, 2, 3, 4], type=None, choices=None, help=&#39;bar!&#39;, 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)

　　　　<span class="pre">MetavarTypeHelpFormatter 为每个参数以 参数的类型作为显示，摒弃了常规使用dest的模式</span>

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

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

In [15]: parser.add_argument(&#39;bar&#39;,type=float)
Out[15]: _StoreAction(option_strings=[], dest=&#39;bar&#39;, nargs=None, const=None, default=None, type=<class &#39;float&#39;>, 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　

<span class="n">prefix_chars<br/>　　　　许多命令行选项都用"-" 当前缀，比如 -h 或者 --help,Parser可以通过prefix_chars来设置不同的前缀符号<br/>　　　　你可以用"+" 或者使用"/"<br/>　　　　</span>

 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 exit19   +f F20   ++bar BAR

　　　　prefix_chars= 默认的参数是'-'.

　　fromfile_prefix_chars

　　　　有的情况下，当处理特别长的参数列表，将这个参数列表保存在文件中，也可以支持

　　　　 这个需要在构建ArgumentParser的时候加入 fromfile_prefix_chars= 选项

　　argument_default

<span class="n">　　　　一般来说，参数都通过add_argument()来指定或者通过调用setdefaults()传递name-value的方法<br/>　　　　有时候，需要为参数指定一个单独的默认值，通过给ArgumentParser指定argument_default关键字参数即可<br/>　　　　比如，可以通过argument_default=SUPPERSS来阻止在parse_args()中全局创建属性<br/>　　<br/>　conflict_handler<br/><br/>　　　　ArgumentParser 对象不允许使用同一个选项字串来表示两个操作,若尝试在 已经使用的选项新建一个参数的话，就说引发异常<br/></span>

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 exit15   -f FOO      old foo help16   --foo FOO   new foo help

　　　　　　ArgumentParser 仅移除这个动作，假如所有的选项字符串都被覆盖了

<span class="n">　　add_help<br/>　　　　　　默认情况下，ArgumentParser对象在创建选项会带着parser的帮助信息<br/>　　　<br/><span style="font-size: 18px">下一篇介绍ArgumentParser<br/>The add_argument() 方法</span><br/>　　<br/></span>

　　

 

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!