argparse模块

该模块是python用于解析命令行参数和选项的标准模块。经常在命令行窗口跑脚本程序的应该知道，这些程序通常没有图形界面，一般都是输入形如：sqlmap -u url 这样的方式来运行，arpparse模块就可以很方便让我们编写这样在命令行窗口运行的脚本，它可以帮你处理参数输入判断等颇为麻烦的问题，而且可以自动生成-h，--help帮助命令。

常见使用步骤：

1.import argparse  #导入模块

2.parser = argparse.ArgumentParser()  #创建解析对象

3.parser.add_argument()  #向对象添加监听的命令行参数

4.parser.parse_args()  #进行解释，默认是从输入命令行中读取参数和对应的值

函数参数解释

ArgumentParser(prog=sys.argv[0], 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 , version=None)
- prog：默认值为程序的名字，可以使用%(prog)s打印程序的名字
- usage：可以传入一个字符串，通常用于描述程序的使用方法，在使用-h/--help打印帮助信息的时候输出
- description：使用-h/--help打印帮助信息时开头的文字
- epilog ：使用-h/--help打印帮助信息时结尾的文字
- parents ：用于实现继承，默认值为一个空列表，需要继承时可以把多个父类放在一个列表中，继承后子类会拥有父类的全部参数
- formatter_class：自定义帮助信息的格式的类（使用-h/--help打印）。默认情况下会将帮助信息自动换行和消除多个连续空白
- prefix_chars ：参数的前缀，默认是'-'，例如-f/--file。可以自己指定前缀，例如prefix_chars='+'，这样就指定了输入参数的前缀是+，变为+f/++file；可以选择多个前缀，如prefix_chars='-+/'，这样这些前缀都是合法的
- fromfile_prefix_chars：用于在文件中读取命令行参数。例如：fromfile_prefix_chars='@',如果命令行参数中有一个"@args.txt"，args.txt文件里的内容会作为命令行参数输入
- argument_default：所有参数的默认值
- conflict_handler：定义添加的参数名字发生重复时怎么处理，默认处理是抛出异常。如果设置为'resolve'，则会根据加入的顺序覆盖前面的选项。冲突常在继承后发生。
- add_help ：增加-h/-help参数的开关，默认添加，需要关闭的时候可以设置为False
- version：添加后就会默认添加-v/--version参数，使用-v/--version就会打印传入的值
ArgumentParser.add_argument(name or flags... [, action] [, nargs] [, const] [, default][, type] [, choices] [, required] [, help] [, metavar] [, dest])
- name or flags：指定参数的形式，至少写一个，这些参数的意义在命令行输入时是相同的，只是形式不同，但一般写两个就够了，一个短参数，一个长参数。参数有两种类型，写法不同
  - 可选的参数(optional arguments)，位置不固定，添加了默认前缀符号的参数都是这类，在命令行输入时需要先写这个选项，后面跟着这个选项的参数，常见定义如下：
    parser.add_argument("-t", "--test", help="test test test")
  - 位置固定的参数(positional arguments)，不带前缀符号的都认为是这类参数，该参数的数据在命令行必须要填（前面不用带特定的开始符号，如'-'），输入位置参数时在命令行对应的位置(取决于添加的顺序)直接输入值而不用输入参数名称，常见定义如下：
    parser.add_argument("test", help="test test test")
- nargs：指定这个参数后面的值有多少个，直接写n为固定n个参数，*为任意个，?为0或1个，+为至少1个
- default：如果命令行没有出现这个选项，那么使用default指定的默认值，显然固定位置参数是没有默认值的，因为必须输入
- type：默认传入的参数均为字符串类型，如果希望传进来的参数是指定的类型（例如 float, int，file等可以从字符串转化过来的类型），则可以使用这个参数来指定，如果是文件参数的话，更多是使用argparse.FileType('rt/wt')，此时可以直接指定读或写模式，用完之后均要自己关闭文件资源
- choices：设置参数值的范围，可以传入一个列表，数据的范围就是列表的所有值
- required：默认为False，如果设置为True则表示该项参数是必须的
- metavar：参数的名字，在显示帮助信息时用到
- help：设置这个选项的帮助信息，即在-h/--help输出的帮助信息中该参数后面的说明内容
- dest：传入一个字符串，这个字符串就是后面需要访问这个参数的值时对应的属性的名称，默认值是参数的名称，这个值不允许重复
- action：动作选项，默认为store，有六种选项
  1.store：保存参数值
  2.store_const：参数设置为固定值，即参数只能是或者不是某个值，当输入的命令中有这个参数，那么这个参数的值就固定了，否则这个参数就没有值，参数设置为这个动作后我们就不能对参数指定值了
  3.store_ture/store_false：保存相应的布尔值。这两个动作被用于实现布尔开关
  4.append：将值保存到一个列表中。若参数重复出现，则保存多个值
  5.append_const：将一个定义在参数规格中的值保存到一个列表中
  6.version：打印关于程序的版本信息，然后退出
- const：仅在action为store_const或append_const时使用，用于设定上面所说的特定的值
parser.parse_args()：默认会从命令行中读取参数（即不输入任何参数，仅仅调用这个函数时），当然也可以直接从代码中输入，此时只需要输入一个包含了参数及其值的列表即可，返回值是一个Namespace（名字空间）对象，命名空间主要作用是是解决重名现象，用来组织和重用代码，同一个命名空间内不允许重名。

简单使用

可选参数

    import argparse
    parser = argparse.ArgumentParser(description='This is start of parser',epilog = 'This is end of parser',version=True)   #先创建解析对象
    parser.add_argument('-a','--A',default="default_a",metavar="name_a",dest='a',help='The help of a') #用上面创建的对象添加普通的可选参数-a，带有前缀的参数都认为是可选参数，这里设置默认值为default_a
    arg = parser.parse_args()
    print arg    #输出一个Namespace对象，包含了所有参数的值
    print 'a = ' + arg.a #这里使用arg.name方式访问，name的值就是上面传入的dest

解释：由第一段输入可知，模块帮我们自动添加了-h选项输入帮助信息(--help也是等价的)，而且 parser.parse_args()函数自动帮我们从命令行中解释参数，a参数打印的帮助信息就是我们指定的帮助信息，第二段直接运行了程序，可选参数a是我们设置的默认值，第三段输入中指定了a的值

指定范围的可选参数

    import argparse
    parser = argparse.ArgumentParser(description='This is start of parser',epilog = 'This is end of parser',version=True)
    parser.add_argument('-a','--A',default="default_a",metavar="name_a",dest='a',help='The help of a')
    parser.add_argument('-b','--B',default="1",metavar="name_b",dest='b',choices =[1,2,3],type = int)   #指定输入为1,2或3，并指定类型为int整形（默认为字符串）
    arg = parser.parse_args()
    print arg
    print 'a = ' + arg.a
    print 'b = ' + str(arg.b)  #上面指定了b为整形，这里转为字符串

解释：设置了可选参数b的范围为1,2,3，当赋值为4时不在范围内，因此出错

指定必须输入的可选参数

    import argparse
    parser = argparse.ArgumentParser(description='This is start of parser',epilog = 'This is end of parser',version=True)
    parser.add_argument('-a','--A',default="default_a",metavar="name_a",dest='a',help='The help of a')
    parser.add_argument('-b','--B',default="1",metavar="name_b",dest='b',choices =[1,2,3],type = int)
    parser.add_argument('-c','--C',metavar="name_c",dest='c',required=True)   #当required设置为True时，可选参数必须输入
    arg = parser.parse_args()
    print arg
    print 'a = ' + arg.a
    print 'b = ' + str(arg.b)
    print 'c = ' + arg.c

解释：a和b实际上可以不输入，但c不输入就会报错

位置固定参数

    import argparse
    parser = argparse.ArgumentParser(description='This is start of parser',epilog = 'This is end of parser',version=True)
    parser.add_argument('-a','--A',default="default_a",metavar="name_a",dest='a',help='The help of a')
    parser.add_argument('-b','--B',default="1",metavar="name_b",dest='b',choices =[1,2,3],type = int)
    parser.add_argument('-c','--C',metavar="name_c",dest='c',required=True) 
    parser.add_argument('must',metavar="name_must",help='This argument must be entered')  #前面不加默认的前缀符号即为位置固定参数
    arg = parser.parse_args()
    print arg
    print 'a = ' + arg.a
    print 'b = ' + str(arg.b)
    print 'c = ' + arg.c
    print 'must = ' + arg.must

解释：位置固定参数和之前的可选参数在帮助信息中可以看出属于不同的分组

解释：可以看出位置固定参数的值也是必须输入的，但其在输入前不用先输入参数的名称，而是直接输入值，如果有多个位置固定参数，会按照位置固定参数的定义按顺序来赋值

共享解析器

我们常常需要实现一套命令行程序，这些程序都带一组参数，只是在某些方面有特殊化。例如，如果所有程序都需要在用户进行任何实际的操作之前对用户进行认证，那么它们就都需要支持--user和--password选项。此时定义一个共享的解析器可以减少重复的代码，等于一个父类，然后使用父类解析器来创建其他所有需要这套参数的解析器。

  import argparse
  super_Parser = argparse.ArgumentParser(add_help=False)   #关闭打印帮助信息，防止和子类冲突
  super_Parser.add_argument('--user', action="store")
  super_Parser.add_argument('--password', action="store")
  parser = argparse.ArgumentParser(parents=[super_Parser])  #指定父类
  parser.add_argument('-c', action="store_true", default=False)   #这里指定了参数c动作为store_true，因此参数的值是布尔值
  print parser.parse_args()

解释：可以看到parser继承了super_Parser的所有参数即--user和--password，而自己添加动作设置为store_true的参数-c则不能手动添加其值，当其出现在命令行是就自动设置为True，否则为默认值False

参数群组

argparse能将参数定义组合成“群组”。群组表示里边的参数是相关的，这对我们对程序输入的理解有很大的帮助，默认情况下是使用两个群组，一个是选项的群组，另一个是固定参数群组。我们可以自定义参数群组，将不同的参数放到不同的群组里面，打印帮助信息的时候会将同一群组的参数打印在一起。

在基础解析器中使用add_argument_group()来创建一个群组，然后逐个添加相关的选项到该群组。

  import argparse
  group_parser = argparse.ArgumentParser()
  group = group_parser.add_argument_group('authentication')  #传入的参数是群组的名称
  group.add_argument('--user', action="store")
  group.add_argument('--password', action="store")   #user和password是一个群组
  group_parser.add_argument('-a')
  group_parser.add_argument('-b')
  print group_parser.parse_args()

解释：又输出的帮助信息可以看到，--user和--password参数属于同一个群组authentication

互斥选项

定义互斥的选项是选项分组特性的一个特例，使用add_mutually_exclusive_group()而不是add_argument_group(),但参数必须是可选参数，不能为固定位置参数。

  import argparse
  group_parser = argparse.ArgumentParser()
  group = group_parser.add_mutually_exclusive_group('authentication')  #这里创建的方法不同
  group.add_argument('-a', action='store_true',help="The help of a")
  group.add_argument('-b', action="store_true",help="The help of b")   #这里a和b就是互斥的

解释：同一个互斥组里面的参数在命令行中至多只能出现一个，因此这里参数-a和-b同时在命令行输入时会出错

嵌套解析器

如果想在同一个文件中实现不同类型的多种操作，例如增加和删除两个操作都在同一个文件中实现，此时可以使用add_parser为不同操作的命令分别创建一套的解析器，每个子解析器也有自己的帮助信息，描述那个操作的参数和选项。

       import argparse
       parser = argparse.ArgumentParser()
       subparsers = parser.add_subparsers(help='commands')      #这个用于创建其他子解析器

       # A list command
       list_parser = subparsers.add_parser('list', help='List contents')      #添加一套'打印'子解析命令
       list_parser.add_argument('dirname', action='store', help='Directory to list')

       # A create command
       create_parser = subparsers.add_parser('create', help='Create a directory')    #添加一套'创建'的子解析命令
       create_parser.add_argument('dirname', action='store', help='New directory to create')
       create_parser.add_argument('--read-only', default=False, action='store_true',
       help='Set permissions to prevent writing to the directory')

       # A delete command
       delete_parser = subparsers.add_parser('delete', help='Remove a directory')   #添加一套'删除'的子解析命令
       delete_parser.add_argument('dirname', action='store', help='The directory to remove')
       delete_parser.add_argument('--recursive', '-r', default=False, action='store_true',
       help='Remove the contents of the directory, too')

       print parser.parse_args()

解释：可以看到list，create和delete都是位置固定参数，但他们各是一个操作集合

解释：list，create和delete是一个独立的操作，输入不同的参数后，可以选择不同的后续参数输入，这里可以看到它们各自有自己的参数集合，可以实现不同的操作时输入不同的参数

解释：当先输入create时才有可选参数--read-only，delete是没有参数--read-only的，当我们编写命令行运行的脚本时，就可以很方便地为不同的操作指定不同的参数