精华内容
下载资源
问答
  • sys模块sys模块代表了Python解释器,主要用于获取和Python解释器相关的信息,其中 sys.argv 可以获取命令行参数Python交互式解释器中可以先导入sys模块 import sys,再输入 dir(sys) 查看sys模块所包含的全部程序...

    sys模块

    sys模块代表了Python解释器,主要用于获取和Python解释器相关的信息,其中 sys.argv 可以获取命令行参数

    在Python交互式解释器中可以先导入sys模块 import sys,再输入 dir(sys) 查看sys模块所包含的全部程序单元(包括变量、函数等),或者 [i for i in dir(sys) if not i.startswith('_')] 过滤掉隐藏的单元

    watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM4NjgyODYw,size_16,color_FFFFFF,t_70

    常用单元

    sys.argv:以列表的方式获取运行 Python 程序的命令行参数存放其中。其中 sys.argv[0] 通常就是指该 Python程序本身,sys.argv[1] 代表第一个参数,sys.argv[2] 代表第二个参数,以此类推。类似于 Shell 中的 $0、$1、$2

    import sys

    print('程序名称为:{},第一个参数为:{},第二个参数为:{}'.format(sys.argv[0], sys.argv[1], sys.argv[2]))

    sys.byteorder:显示本地字节序的指示符。如果本地字节序的大端模式,则该属性返回big,否则返回little

    sys.copyright:该属性返回与 Python 解释器有关的版权信息

    sys.executable:该属性返回 Python 解释器在磁盘上的存储路径

    sys.exit():通过引发SystemExit异常来退出程序,将其放在try块中不能阻止finally块的执行。

    sys.flags:该只读属性返回运行Python命令时指定的旗标

    sys.getfilesystemencodiing():返回在当前系统中保存文件所用的字符集

    sys.getrefcount():返回指定对象的引用计数。

    sys.getrecursionlimit():返回Python解释器当前支持的递归深度。该属性可通过setrecursionlimit()方法重新设置

    sys.getswitchinterval():返回在当前Python解释器中线程切换的时间间隔。该属性可通过setswitchinterval()函数改变

    sys.implementation:返回当前Python解释器的实现

    sys.maxsize:返回Python整数支持的最大值。在32位平台上,该属性值为 2 ×× 31-1;在64位平台上,该属性值为 2 ×× 63-1

    sys.path:该属性指定Python查找模块的路径列表。程序可通过修改该属性来动态增加Python加载模块的路径

    sys.platfrom:返回Python解释器所在的平台的标识符

    sys.stdin:返回系统的标准输入流——一个类文件对象

    sys.stdout:返回系统的标准输出流——一个类文件对象

    sys.stderr:返回系统的错误输出流——一个类文件对象

    sys.version:返回当前Python解释器的版本信息

    sys.winver:返回当前Python解释器的主版本号

    sys.copyright:返回当前Python解释器的版权信息

    getopt模块

    getopt是对sys.argv获取的命令行参数进行二次处理。在运行程序时,可能需要根据不同的条件,输入不同的命令行选项来实现不同的功能,比如 -u 代表后面是用户,-p 代表后面是密码。

    举个例子

    ## fileName: test.py

    import sys, getopt

    opts, args = getopt.getopt(sys.argv[1:], "hu:", ["help", "file="])

    print("opts输出结果为", opts)

    print("args输出结果为", args)

    调用getopt.getopt()会返回两个列表,第一个列表赋值给opts,第二个列表赋值给args:

    opts:是 (选项, 选项值) 的元组为一个元素的列表。如果没有选项值为空字符串

    args:存放没用选项单参数的列表。不属于格式信息的剩余的命令行参数

    使用 sys.argv[1:] 是为过滤第一个参数(第一个参数为Python程序本身)

    "hu:" 为定义短格式选项(-)。这里的h和u为两个选项。"h" 后面没有 ":" 表示h这个选项没有选项值,是作为开关选项(比如:有 -h 为显示帮助信息,没有 -h 为不显示帮助信息)。"u:" 后面有 ":" 为必须有选项值

    ["help", "file="] 为定义长格式选项(--)。这里的 "=" 和上面的短格式选项中的 ":" 一样

    执行的例子

    python test.py -h -u root --help --file=file.py file2.py

    ## 输出结果

    opts输出结果为 [('-h', ''), ('-u', 'root'), ('--help', ''), ('--file', 'file.py')]

    args输出结果为 ['file2.py']

    optparse模块

    optparse模块主要用来为脚本传递命令参数,采用预先定义好的选项来解析命令行参数,自动生成帮助信息,不需要sys.argv

    先简单写个例子

    import optparse

    usage="python %prog -u/--user -p/--password "

    parser=optparse.OptionParser(usage) ## 写入上面定义的帮助信息

    parser.add_option('-u', '--user',dest='User',type='string',help='target user', default='root')

    parser.add_option('-p','--password',dest='Pwd',type='string',help='target password')

    options, args=parser.parse_args()

    print('options为', options)

    print("用户名为", options.User)

    print("密码为", options.Pwd)

    print('args为', args)

    add_option参数:

    可以设置多个选项字符串,比如上面的 '-u', '--user' 这两个,用的时候任选其一

    dest用于定义选项值存放的位置,作为后面的第一个字典(options)的键,值为命令输入的参数

    type用于检测命令行输入参数的数据类型是否符合要求,有 string(字符串)、int(整数)、float(浮点数)等类型

    help用于定义帮助信息

    default设置默认值

    watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM4NjgyODYw,size_16,color_FFFFFF,t_70

    帮助信息里面的选项字符串都在一个组中,我们可以创建不同的组用来给选项字符串分类

    import optparse

    usage="python %prog -u/--user -p/--password "

    parser=optparse.OptionParser(usage) ## 写入上面定义的帮助信息

    parser.add_option('-u', '--user',dest='User',type='string',help='target user', default='root')

    parser.add_option('-p','--password',dest='Pwd',type='string',help='target password')

    group = optparse.OptionGroup(parser, 'Debug Options') ## 创建group分组

    parser.add_option_group(group) ## 把创建的组添加到parser中

    group.add_option('-d', '--debug', action='store_true', help='Print debug information')

    options, args=parser.parse_args()

    action有三种类型:

    action='store' 默认类型,可以忽略不写。用户必须给出一个明确的参数值,该类型定义了将实际参数值保存到dest指定变量中

    action='store_true' 用户不需给出参数值,该类型定义了将布尔值true保存到dest指定的变量中(和上面getopt中不加 ':' 、'=')

    action='store_false' 用户不需给出参数值,该类型定义了将布尔值false保存到dest指定的变量中

    20200811144037360.png

    argparse模块

    optparse模块的升级版,optparse被Python2.7和Python3.2弃用,所有有理由相信未来是属于argparse模块的

    编辑帮助信息

    import argparse

    parser = argparse.ArgumentParser(description='帮助描述信息', prog='程序显示名称', usage='顶部显示信息,会覆盖prog', epilog='底部显示信息') ## 括号里面可以什么都不写,会走默认

    parser.parse_args() ## 命令行参数解析后存放的位置

    还有一些不常用的参数:

    add_help = False 禁止显示帮助界面,只接收参数

    argument_default=argparse.SUPPRESS 限制只能从命令行传递参数,程序中指定无效

    allow_abbrev=False 例如--fooo,输入--foo,则不可以识别参数,默认可以

    conflict_handler='resolve' 若参数重名,则不报错

    2020081114412450.png

    添加命令行参数

    '''

    遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939

    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!

    '''

    import argparse

    parser = argparse.ArgumentParser()

    parser.add_argument('-u', '--user', dest='User', type=str,default='root', help='target User')

    parser.add_argument('-s', '--sex', dest='Sex', type=str, choices=['男', '女'], default='男', help='target Sex')

    parser.add_argument('-n', '--number', dest='Num', nargs=2, required=True,type=int, help='target Two Numbers')

    print(parser.parse_args()) ## 字典的方式接收参数

    参数大多数和上面的optparse相同,不同的有:

    choices:设置参数的范围,如果choice中的类型不是字符串,要指定type

    nargs:设置参数接受的个数:

    ?:表示可有可无

    +:表示至少一个

    *:表示任意个

    数字表示必须是指定数目个

    展开全文
  • Python 命令行参数详解

    千次阅读 多人点赞 2021-08-13 00:02:27
    通常,对于大型项目程序而言,执行程序的一个必要的步骤是正确处理命令行参数,这些参数是提供给包含某种参数化信息的程序或脚本的参数。命令行参数是参数化程序执行的一种常见且简单的方法。本文主要介绍以下三种...

    0. 命令行参数

    通常,对于大型项目程序而言,执行程序的一个必要的步骤是正确处理命令行参数,这些命令行参数是提供给包含某种参数化信息的程序或脚本的参数。例如,在计算机视觉项目中,图像和不同类型的文件通常作为命令行参数传递给脚本,用于使程序可以处理不同图片或者不同类型文件。
    命令行参数是参数化程序执行的一种常见且简单的方法,下面主要介绍三种常见的获取和解析命令行参数的方法。

    1. sys.argv

    为了处理命令行参数,Python 中内置了 sys.argv 模块,通过模块中的 sys.argv 就可以访问到所有的命令行参数,它的返回值是包含所有命令行参数的列表 (list)。当程序执行时,Python 从命令行获取所有值并将它们存储在 sys.argv 列表中。列表的第一个元素 sys.argv[0] 是脚本的完整路径(或脚本名称——取决于具体操作系统)。列表的第二个元素是脚本的第一个命令行参数,即 sys.argv[1],依此类推。这可以通过下图中清晰的看出,其中 script_1.py 脚本使用两个参数执行:

    sys.argv
    接下来,让我们看看 sys.argv 是如何工作的,首先编写 scripy_1.py 脚本:

    import sys
    print("正在运行的脚本名称: '{}'".format(sys.argv[0]))
    print("脚本的参数数量: '{}'".format(len(sys.argv)))
    print("脚本的参数: '{}'".format(str(sys.argv)))
    

    如果我们不使用任何参数执行这个脚本:

    python script_1.py
    

    将会看到如下信息:

    正在运行的脚本名称: 'script_1.py'
    脚本的参数数量: '1'
    脚本的参数: '['script_1.py']'
    

    如果我们使用多个参数执行此脚本:

    python script_1.py OpenCV -i test.png
    

    将得到以下信息:

    正在运行的脚本名称: 'script_1.py'
    脚本的参数数量: '4'
    脚本的参数: '['script_1.py', 'OpenCV', '-i', 'test.png']'
    

    如上所示,列表的第一个元素 script_1.py (sys.argv[0]) 是脚本名称。列表的第二个元素 (sys.argv[1]) OpenCV 是脚本的第一个参数。但同时也可以看到,sys.argv 将命令行选项 -i 也识别为参数,这样并不能方便的满足我们的需求,因此引入 getopt 模块来识别命令行选项。

    2. getopt

    getopt 模块是专门处理命令行参数的模块,用于获取命令行选项和参数。命令行选项使得程序的参数更加灵活,其支持短选项模式(-)和长选项模式(–)。
    该模块提供了两个方法及一个异常处理来解析命令行参数。

    2.1 getopt.getopt 方法

    getopt.getopt 方法用于解析命令行参数列表,其语法格式如下:

    getopt.getopt(args, options[, long_options])
    

    方法参数说明如下表所示:

    参数说明
    args要解析的命令行参数列表,一般是sys.argv[1:],需要过滤掉脚本名(sys.argv[0])
    options以字符串的格式定义,options 后的冒号 “:” 表示如果设置该选项,必须有附加的参数,否则就不附加参数
    long_options以列表的格式定义,long_options 后的等号 “=” 表示该选项必须有附加的参数,不带冒号表示该选项不附加参数

    该方法返回值由两个元素组成: 第一个是 (option, value) 元组的列表。 第二个是参数列表,包含那些没有 - 或 – 的参数。
    下面编写 script_2.py 脚本进行演示:

    import sys
    import getopt
    
    
    def main(argv):
        input_file = ""
        output_file = ""
        # "hi:o:": 短格式分析串, h 后面没有冒号, 表示后面不带参数; i 和 o 后面带有冒号, 表示后面带参数
        # ["help", "input_file=", "output_file="]: 长格式分析串列表, help后面没有等号, 表示后面不带参数; input_file和output_file后面带冒号, 表示后面带参数
        # 返回值包括 `opts` 和 `args`, opts 是以元组为元素的列表, 每个元组的形式为: (选项, 附加参数),如: ('-i', 'test.png');
        # args是个列表,其中的元素是那些不含'-'或'--'的参数
        opts, args = getopt.getopt(argv[1:], "hi:o:", ["help", "input_file=", "output_file="])
    
        for opt, arg in opts:
            if opt in ("-h", "--help"):
                print('script_2.py -i <input_file> -o <output_file>')
                print('or: test_arg.py --input_file=<input_file> --output_file=<output_file>')
                sys.exit()
            elif opt in ("-i", "--input_file"):
                input_file = arg
            elif opt in ("-o", "--output_file"):
                output_file = arg
        print('输入文件为:', input_file)
        print('输出文件为:', output_file)
    
        # 打印不含'-'或'--'的参数
        for i in range(0, len(args)):
            print('不含'-'或'--'的参数 %s 为:%s' % (i + 1, args[i]))
            
    if __name__ == "__main__":
        main(sys.argv)
    

    使用带有命令行选项的命令执行此脚本,以下两种方式是等价的:

    # 方式1
    python scripy_1.py -i test.png -o output.png OpenCV
    # 方式2
    python scripy_1.py --input_file test.png --output_file output.png OpenCV
    

    输出得到以下信息:

    输入文件为: test.png
    输出文件为: output.png
    不含'-''--'的参数 1 为:OpenCV
    

    2.2 Exception getopt.GetoptError

    在参数列表中没有找到所传递参数,或选项的需要的参数为空时会触发该异常。异常的参数是一个字符串,表示错误的原因。属性 msgopt 为相关选项的错误信息。
    在上述代码中添加异常处理,检查此错误信息:

    # ...
    def main(argv):
        input_file = ""
        output_file = ""
        try:
            opts, args = getopt.getopt(argv[1:], "hi:o", ["help", "input_file=", "output_file="])
        except getopt.GetoptError as e:
            print(e.msg)
            print(e.opt)
            sys.exit(2)
    # ...
    

    使用错误的格式选项传递参数执行脚本:

    python scripy_1.py -f
    

    输出以下错误信息:

    option -f not recognized
    f
    

    3. argparse

    当程序中使用采用复杂参数或多个文件名时,推荐使用 Python 的 argparse 库,它以系统的方式处理命令行参数,从而可以编写用户友好的命令行程序。Python 标准库 argparse 同样也是用于解析命令行参数的模块。首先,由程序确定所需的参数,然后, argparse 将这些参数解析为 sys.argv。此外,argparse 会生成帮助和使用信息提示,并在提供无效参数时发出错误。
    为了介绍此模块,编写 script_3.py,如下所示:

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

    不带参数运行此脚本不会向 stdout 显示任何内容。但是,如果使用 --help-h 选项,将得到脚本的使用信息提示:

    usage: scripy_3.py [-h]
    optional arguments:
    -h, --help show this help message and exit
    

    指定其他参数会导致错误,例如使用如下命令:

    scripy_3.py -i
    

    则会报导致错误:

    usage: scripy_3.py [-h]
    argparse_minimal.py: error: unrecognized arguments: -i
    

    由于未定义参数,因此不允许其他参数,接下来就添加一个参数,编写 script_4.py 脚本:

    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("first_argument", help="this is the string text in connection with first_argument")
    args = parser.parse_args()
    print(args.first_argument)
    

    这里添加了 add_argument() 方法。此方法用于指定程序将接受哪些命令行选项,此处添加了 first_argument 参数。此外, argparse 模块存储所有参数,将其名称与每个添加参数的名称相匹配——在此处为 first_argument 。为了获得参数值,需要使用 args.first_argument
    如果此脚本以下示方法执行,则输出为 10:

    python scripy_4.py 10
    

    但如果脚本在没有参数的情况下执行,则将输出以下信息:

    usage: scripy_4.py [-h] first_argument
    scripy_4.py: error: the following arguments are required: first_argument
    

    最后,如果我们使用 -h 选项执行脚本,输出将如下所示:

    usage: scripy_4.py [-h] first_argument
    
    positional arguments:
      first_argument  this is the string text in connection with first_argument
    
    optional arguments:
      -h, --help      show this help message and exit
    

    默认情况下,argparse 将提供的选项视为字符串。因此,如果参数不是字符串,则应使用 type 选项。使用 script_5.py 脚本,其中添加了两个参数,这两个参数是 int 类型:

    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("first_number", help="first number to be added", type=int)
    parser.add_argument("second_number", help="second number to be added", type=int)
    args = parser.parse_args()
    print("args: '{}'".format(args))
    print("the sum is: '{}'".format(args.first_number + args.second_number))
    args_dict = vars(parser.parse_args())
    print("args_dict dictionary: '{}'".format(args_dict))
    print("first argument from the dictionary: '{}'".format(args_dict["first_number"]))
    

    在前面的示例中,通过调用 vars() 函数将参数存储在字典中:

    args_dict = vars(parser.parse_args())
    print("args_dict dictionary: '{}'".format(args_dict))
    print("first argument from the dictionary: '{}'".format(args_dict["first_number"]))
    

    如果不带参数执行脚本:

    python script_5.py
    

    则输出如下:

    usage: scripy_5.py [-h] first_number second_number
    scripy_5.py: error: the following arguments are required: first_number, second_number
    

    此外,如果我们使用 -h 选项执行脚本:

    python script_5.py --help
    

    输出将如下所示:

    usage: scripy_1.py [-h] first_number second_number
    
    positional arguments:
      first_number   first number to be added
      second_number  second number to be added
    
    optional arguments:
      -h, --help     show this help message and exit
    

    如果此脚本以如下方式执行:

    python script_5.py 123 456
    

    则输出如下:

    args: 'Namespace(first_number=123, second_number=456)'
    the sum is: '579'
    args_dict dictionary: '{'first_number': 123, 'second_number': 456}'
    first argument from the dictionary: '123'
    

    更多 argparse 的高级介绍可以在官方文档中看到,其中包括了大量示例

    展开全文
  • 主要介绍了Python命令行参数解析模块getopt使用实例,本文讲解了使用语法格式、短选项参数实例、长选项参数实例等内容,需要的朋友可以参考下
  • Python 命令行参数

    2018-03-06 10:41:22
    记录背景: 16年时候记录的 Python 提供了 getopt 模块来获取命令行参数。 ...sys.argv 是命令行参数列表。 len(sys.argv) 是命令行参数个数。 注:sys.argv[0] 表示脚本名。 实例 test.p...

    记录背景: 16年时候记录的

    Python 提供了 getopt 模块来获取命令行参数。

    $ python test.py arg1 arg2 arg3

    Python 中也可以所用 sys 的 sys.argv 来获取命令行参数:

    • sys.argv 是命令行参数列表。

    • len(sys.argv) 是命令行参数个数。

    注:sys.argv[0] 表示脚本名。

    实例

    test.py 文件代码如下:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    import sys
    
    print '参数个数为:', len(sys.argv), '个参数。'
    print '参数列表:', str(sys.argv)
    

    执行以上代码,输出结果为:

    $ python test.py arg1 arg2 arg3
    参数个数为: 4 个参数。
    参数列表: ['test.py', 'arg1', 'arg2', 'arg3']

    getopt模块

    getopt模块是专门处理命令行参数的模块,用于获取命令行选项和参数,也就是sys.argv。命令行选项使得程序的参数更加灵活。支持短选项模式(-)和长选项模式(–)。

    该模块提供了两个方法及一个异常处理来解析命令行参数。

    getopt.getopt 方法

    getopt.getopt 方法用于解析命令行参数列表,语法格式如下:

    getopt.getopt(args, options[, long_options])

    方法参数说明:

    • args: 要解析的命令行参数列表。

    • options: 以字符串的格式定义,options后的冒号(:)表示该选项必须有附加的参数,不带冒号表示该选项不附加参数。

    • long_options: 以列表的格式定义,long_options 后的等号(=)表示如果设置该选项,必须有附加的参数,否则就不附加参数。

    • 该方法返回值由两个元素组成: 第一个是 (option, value) 元组的列表。 第二个是参数列表,包含那些没有’-‘或’–’的参数。

    另外一个方法是 getopt.gnu_getopt,这里不多做介绍。

    Exception getopt.GetoptError

    在没有找到参数列表,或选项的需要的参数为空时会触发该异常。

    异常的参数是一个字符串,表示错误的原因。属性 msg 和 opt 为相关选项的错误信息。

    实例

    假定我们创建这样一个脚本,可以通过命令行向脚本文件传递两个文件名,同时我们通过另外一个选项查看脚本的使用。脚本使用方法如下:

    usage: test.py -i <inputfile> -o <outputfile>

    test.py 文件代码如下所示:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
    
    import sys, getopt
    
    def main(argv):
      inputfile = ''
      outputfile = ''
      try:
          opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="])
      except getopt.GetoptError:
          print 'test.py -i <inputfile> -o <outputfile>'
          sys.exit(2)
      for opt, arg in opts:
          if opt == '-h':
            print 'test.py -i <inputfile> -o <outputfile>'
            sys.exit()
          elif opt in ("-i", "--ifile"):
            inputfile = arg
          elif opt in ("-o", "--ofile"):
            outputfile = arg
      print '输入的文件为:', inputfile
      print '输出的文件为:', outputfile
    
    if __name__ == "__main__":
      main(sys.argv[1:])

    执行以上代码,输出结果为:

    $ python test.py -h
    usage: test.py -i <inputfile> -o <outputfile>
    
    $ python test.py -i inputfile -o outputfile
    输入的文件为: inputfile
    输出的文件为: outputfile
    展开全文
  • python命令行参数是什么?下面给大家具体介绍一下什么是命令行参数: sys.argv Python 中也可以所用 sys 的 sys.argv 来获取命令行参数: sys.argv 是命令行参数列表。 len(sys.argv) 是命令行参数...

    转载自品略图书馆  http://www.pinlue.com/article/2020/04/1007/5410139993403.html

    python命令行参数是什么?下面给大家具体介绍一下什么是命令行参数:

    sys.argv

    Python 中也可以所用 sys 的 sys.argv 来获取命令行参数:

    sys.argv 是命令行参数列表。

    len(sys.argv) 是命令行参数个数。

    sys.argv[0]是脚本文件的名字,如:test.py

    sys.argv[1:]是以空格分割的参数列表

    getopt

    函数原型:

    1

    getopt(args, shortopts, longopts = [])

    参数:

    args:需要解析的参数,一般是sys.argv[1:]

    shortopts:短格式 (-),有冒号:表示参数后面需要参数值,没有冒号表示后面无需参数值

    longopts:长格式(--) ,有等号表示参数后面需要参数值,没有等号表示后面无需参数值

    返回值:

    options是个包含元祖的列表,每个元祖是分析出来的格式信息,比如 [("-i","127.0.0.1"),("-p","80")] ;

    args 是个列表,包含那些没有‘-’或‘--’的参数,比如:["55","66"]

    相关推荐:《Python视频教程》

    示例:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    import sys

    import getopt

    try:

    options,args = getopt.getopt(sys.argv[1:],"hp:i:", ["help","ip=","port="])

    except getopt.GetoptError:

    sys.exit()

    for name,value in options:

    if name in ("-h","--help"):

    usage()

    if name in ("-i","--ip"):

    print "ip is----",value

    if name in ("-p","--port"):

    print "port is----",value

    python test.py -i 127.0.0.1 -p 80 55 66

    python test.py --ip=127.0.0.1 --port=80 55 66

    “hp:i:”

    短格式 --- h 后面没有冒号:表示后面不带参数,p:和 i:后面有冒号表示后面需要参数

    ["help","ip=","port="]

    长格式 --- help后面没有等号=,表示后面不带参数,其他三个有=,表示后面需要参数

    注意:定义命令行参数时,要先定义带"-"选项的参数,再定义没有‘-’的参数

    optparse

    类OptionParser

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    class optparse.OptionParser(usage=None,

    option_list=None,

    option_class=Option,

    version=None,

    conflict_handler="error",

    description=None,

    formatter=None,

    add_help_option=True,

    prog=None,

    epilog=None)

    参数:

    usage:程序的使用说明,其中"%prog"会替换为文件名(或者prog属性,若指定了prog属性值),"[options]"会替换为各个参数的使用说明

    version:版本号

    函数add_option()

    1

    add_option(short, long, action, type, dest, default, help)

    参数:

    short option string: 为第一个参数,表示option的缩写,例如-f;

    long option string: 为第二个参数,表示option的全拼,例如--file;

    action=: 表示对此option的处理方式,默认值为store,表示存储option的值到解析后的options对象的成员中。

    action还可以有其他的值:对于bool值,使用store_true来默认存储true,使用store_false来默认存储false,store_const用来存储const设置的值到此option,append表示增加option的参数到list中,此时此option是一个list,可能包含多个值,count表示对counter增加一,callback表示调用指定的函数。所有的action值如下:

    store + store_true + store_false + store_const + append + count + callback

    type=:表示此option的值的类型,默认为string,可以指定为string, int, choice, float and complex;

    dest=:表示此option在经过optionparser解析后的options对象中成员的名字,默认使用long option string;

    help=:表示这个参数的使用说明;

    default=:表示比option的默认值;

    metavar=:表示显示到help中option的默认值;

    const=:当action为store_const的时候,需要设置此值;

    choices=:当设置type为choices时,需要设置此值;

    函数parse_args

    1

    (options, args) = parser.parse_args()

    返回值:

    options为是一个directory,它的内容为“参数/值 ”的键值对。

    args是一个list,它的内容是所有参数除去options后,剩余的输入内容。

    简单用法:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    from optparse import OptionParser

    parser = OptionParser(usage="usage:%prog [options] arg1 arg2")

    parser.add_option("-t", "--timeout",

    action = "store",

    type = "int",

    dest = "timeout",

    default = None,

    help="Specify annalysis execution time limit"

    )

    parser.add_option("-u", "--url",

    action = "store_true",

    dest = "url",

    default = False,

    help = "Specify if the target is an URL"

    )

    (options, args) = parser.parse_args()

    if options.url:

    print(args[0])

    复杂用法:参数分组

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    parser = optparse.OptionParser(version="%prog " + config.version)# common_groupcommon_group = optparse.OptionGroup(

    parser, "Common Options",    "Common options for code-coverage.")

    parser.add_option_group(common_group)

    common_group.add_option(    "-l", "--lang", dest="lang", type="string", default="cpp",    help="module language.", metavar="STRING")

    common_group.add_option(    "--module_id", dest="module_id", type="int", default=None,    help="module id.", metavar="INT")

    cpp_group = optparse.OptionGroup(

    parser, "C/C++ Options",    "Special options for C/C++.")# cpp_groupparser.add_option_group(cpp_group)

    cpp_group.add_option(    "--local-compile", action="store_true", dest="local_compile",    help="compile locally, do not use compile cluster.")

    cpp_group.add_option(    "--module_path", dest="module_path", type="string", default=None,    help="module path, like app/ecom/nova/se/se-as.", metavar="STRING")

    options, arguments = parser.parse_args()

    lang = options.lang

    module_id = options.module_id

    local_compile = options.local_compile

    module_path = options.local_compile

    argparse

    类ArgumentParser

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    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)

    参数:

    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)

    函数add_argument()

    1

    2

    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()返回的对象要添加的属性名称。

    简单用法:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    import argparse

    parser = argparse.ArgumentParser(description="progrom description")

    parser.add_argument("key", help="Redis key where items are stored")

    parser.add_argument("--host")

    arser.add_argument("--port")

    parser.add_argument("--timeout", type=int, default=5)

    parser.add_argument("--limit", type=int, default=0)

    parser.add_argument("--progress_every", type=int, default=100)

    parser.add_argument("-v", "--verbose", action="store_true")

    args = parser.parse_args()

    key = args.key

    host = args.host

    port = args.port

    timeout = args.timeout

    limit = args.limit

    progress-every = args.progress_every

    verbose = args.verbose

    以上就是python命令行参数是什么的详细内容

     

     

    展开全文
  • 本文实例讲述了python读取命令行参数的方法。分享给大家供大家参考。具体分析如下:如果想对python脚本传参数,python中对应的argc, argv(c语言的命令行参数)是什么呢?需要模块:sys参数个数:len(sys.argv)脚本名...
  • 您可能感兴趣的文章:python的pytest框架之命令行参数详解(上)python获取命令行输入参数列表的实例代码Python 获得命令行参数的方法(推荐)Python解析命令行读取参数–argparse模块使用方法Python中的命令行参数解析...
  • Python命令行参数处理

    2020-08-11 14:43:05
    sys模块 sys模块代表了Python解释器,主要用于获取和Python解释器相关的信息,其中 sys.argv 可以获取命令行参数 在Python交互式解释器中...sys.argv:以列表的方式获取运行 Python 程序的命令行参数存放其中。其中 sy
  • 1、docopt 是一种 Python 编写的命令行执行脚本的交互语言。 它是一种语言! 它是一种语言! 它是一种语言! 2、使用这种语言可以在自己的脚本中,添加一些规则限制。这样脚本在执行的时候就必须按照这样格式来执行...
  • Python命令行参数设置

    2020-03-29 12:31:00
    Python命令行参数设置(args) 1.sys模块 通过传入sys.argv列表,这里列表元素必须大于等于代码中设定的长度(长了会截断),不然会报错。 import sys def test_for_sys(year, name, body): print('the year is', year...
  • python 命令行参数学习

    2020-05-06 10:14:53
    python命令行参数是在运行时赋予程序/脚本的标志。 它们包含我们程序的其他信息,以便可以执行。但并非所有程序都具有命令行参数,因为并非所有程序都需要它们。 ...
  • 本文实例讲述了python命令行参数用法。分享给大家供大家参考,具体如下: 在命令行下执行某些命令的时候,通常会在一个命令后面带上一些参数,这些参数会传递到程序里,进行处理,然后返回结果,在linux 下很多命令...
  • 本文实例讲述了python命令行参数解析OptionParser类的用法,分享给大家供大家参考。 具体代码如下: from optparse import OptionParser parser = OptionParser(usage="usage:%prog [optinos] filepath") parser....
  • 1.tf.app.flags 用于支持接受命令行传递参数,相当于接受argv。 tf.app.flags ... python **.py --参数名=赋值 4.tf.app.run启动main(argv) import tensorflow as tf   tf.flags.DEFINE_inte...
  • Python命令行参数基础

    千次阅读 2019-02-09 12:46:40
    #关于命令行参数 ##一, ###1.在IDLE下建立新的文件,保存在C:\Users\dell\Desktop\ 1.1.py import sys print( "脚本名:", sys.argv[0]) for i in range(1, len(sys.argv)): print ("参数", i, sys.argv[i]) ...
  • 如果命令行参数没有这个参数的值,那么自动使用默认值,该值可以时任何python对象,比如函数。 type: 设置参数类型。默认传入的参数类型是string,但是可以通过type参数设置类型,比如int,float,甚至设置为open,为...
  • 主要介绍了Python命令行参数解析模块optparse使用实例,本文讲解了增加选项(add_option())、行为(action)、设置默认值(default)、生成帮助提示(help)、设置boolean值、错误处理、选项组(Grouping Options)等内容,需要...
  • python命令行参数 在python开发中,我们经常会遇到在执行代码时,需要给代码传参的情况。 遇到传参的场景,最基础的传参方式为*.py argv1 argv2 ...,然后我们在代码中通过sya.argv来解析入参。 这样使用没有问题,...
  • python 命令行参数解析

    2020-06-02 16:52:17
    参考: https://www.cnblogs.com/xuejiale/p/10344248.html
  • python命令行参数解析库

    千次阅读 2018-07-17 20:13:14
    在开发过程中,如果遇到希望能够增加命令行参数这种需求,python提供了对应的库argparse, 针对这个task做个小总结 官方文档是这样介绍argparse库的。 The argparse module makes it easy to write user-fr...
  • 什么是命令行参数命令行参数是在运行时给予程序/脚本的标志。它们包含我们程序的附加信息,以便它可以执行。 并非所有程序都有命令行参数,因为并非所有程序都需要它们。 为什么我们使用命令行参数? 如上所述,...
  • /bin/env python import sys if len(sys.argv) <> 3: print “Usage: ” + sys.argv[0] + “file1 file2” sys.exit(-1) file1 = sys.argv[1]file2 = sys.argv[2] list1 = {}for line in open(file1): list1...
  • 形式一: 第一个红色框为命令行参数 第二个框为控制台模式(Terminal) 形式二 点击运行:点击红色框 编辑配置 如下图:红色框即为设置的命令行参数 ...
  • python 命令行 参数Python Command line arguments are input parameters passed to the script when executing them. Almost all programming language provide support for command line arguments. Then we also ...
  • Python 命令行参数转换成字典的方法

    千次阅读 2019-01-31 20:38:00
    假设命令行参数为"{'symbol':'kaka'}" 第一种方法: exec("param="+sys.argv[1]) print(param) 执行: python run.py "{'symbol':'kaka'}" 第二种方法: import ast import sys param = ast....
  • Python命令行参数学习

    2017-10-23 19:28:02
    Python命令行参数,提供了很多有用的功能,可以方便调试和运行,通过man python就能查看,以下是一些常用参数使用实例和场景: 1. -B参数,在import时候,不产生pyc或者pyo文件: 比如有a.py,内容如下:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 130,929
精华内容 52,371
关键字:

python命令行参数

python 订阅