您现在的位置是：首页 > 其他

当前栏目

Python optparser库详解

程序

2023-03-02 11:11:01 时间

Python 有两个内建的模块用于处理命令行参数：  
  
一个是 getopt只能简单处理 命令行参数 ；另一个是 optparse，它功能强大，而且易于使用，可以方便地生成标准的、符合Unix/Posix 规范的命令行说明。会自动帮你负责-h帮助选项。   
  
optparse模块主要用来为脚本传递命令参数功能.  
  
from optparser import OptionParser  
  
现在可以定义命令行选项，基本语法是：  
  
  
parser.add\_option(opt\_str, ..., attr=value, ...)  
  
每种选项各有一个或多个选项的字符串，比如 -f 或 --file，通常每个选项将有一个短选项和一个长选项 。例如：  
  
parser.add\_option("-f", "--file", ...)  
  
最后，一旦你已经定义好了所有的命令行参数， 调用 parse\_args() 来解析程序的命令行 ：  
  
(options, args) = parser.parse\_args()  
  
注： 你也可以传递一个命令行参数列表到 parse\_args()；否则， 默认使用 sys.argv\[:1\] 。  
  
parse\_args() 返回的两个值：  
  
options，它是一个对象（optpars.Values），保存有命令行参数值。只要知道命令行参数名，如 file，就可以访问其对应的值： options.file  。  
  
args，它是一个由 positional arguments 组成的列表。  
  
  
了解选项操作：  
  
action 是 parse\_args() 方法的参数之一，它指示 optparse 当解析到一个命令行参数时该如何处理。actions 有一组固定的值可供选择， 默认是’store ‘，表示将命令行参数值保存在 options 对象里 。  
示例：  
  
parser.add\_option("-f", "--file", action="store" , type="string", dest="filename")  
  
args = \["-f", "foo.txt"\]  
  
(options, args) = parser.parse\_args(args)  
  
print options.filename  
  
最后将会打印出 “foo.txt”。  
  
当 optparse 解析到’-f’，会继续解析后面的’foo.txt’，然后将’foo.txt’保存到  options.filename 里。当调用 parser.args() 后 ，options.filename 的值就为’foo.txt’。  
  
你也可以指定 add\_option() 方法中 type 参数为其它值，如 int 或者 float 等等：  
  
parser.add\_option("-n",  type="int" , dest="num")  
  
注意：这个选项没有长选项，长选项也是可选的， 如果没有指定dest选项，将用命令行的参数名对options对象的值进行存取 。  
  
 store也有其他的两种形式: stort\_true 和 store\_false， 用于处理带命令行选项后面不带值的情况，例如： -v,-q等命令行参数 。  
  
  
parser.add\_option("-v",  action="store\_true" , dest="verbose")  
  
parser.add\_option("-q",  action="store\_false" , dest="verbose")  
  
这样的话，当解析到 ‘-v’，options.verbose 将被赋予 True 值，反之，解析到 ‘-q’，会被赋予 False 值。  
  
其它的 actions 值还有：  
store\_const 、append 、count 、callback  
默认值  
parse\_args() 方法提供了一个 default 参数用于设置默认值 。如：  
  
  
parser.add\_option("-v", action="store\_true", dest="verbose")  
parser.add\_option("-q", action="store\_false", dest="verbose",  default=True )  
  
又或者使用set\_defaults例如：  
  
  
parser.set\_defaults(verbose=True)  
  
parser.add\_option(...)  
  
(options, args) = parser.parse\_args()  
  
程序生成帮助  
optparse 另一个方便的功能是自动生成程序的帮助信息。你只需要为 add\_option() 方法的 help 选项指定帮助信息文本 ：  
  
  
usage = "usage: %prog \[options\] arg1 arg2"  
  
parser = OptionParser(usage=usage)  
  
parser.add\_option("-v", "--verbose", action="store\_true" , dest="verbose", default=True, help="make lots of noise \[default\]" )  
  
parser.add\_option("-q", "--quiet" , action="store\_false" , dest="verbose", help="be vewwy quiet (I'm hunting wabbits)" )  
  
parser.add\_option("-f", "--filename", metavar="FILE",  help="write output to FILE" )  
  
parser.add\_option("-m", "--mode", default="intermediate" , help="interaction mode: novice, intermediate, " "or expert \[default: %default\]" )  
  
当 optparse 解析到 -h 或者 –help 命令行参数时，会调用 parser.print\_help() 打印程序的帮助信息：  
  
Usage: <yourscript> \[options\] arg1 arg2  
                                                         
Options:  
  -h, --help            show this help message and exit  
  -v, --verbose         make lots of noise \[default\]  
  -q, --quiet           be vewwy quiet (I'm hunting wabbits)  
  -f FILE, --filename=FILE  
                        write output to FILE  
  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or  
                        expert \[default: intermediate\]  
（注意：当脚本打印帮助信息后会退出，不会解析其他选项参数）  
  
自定义程序使用方法：  
  
usage = "usage: %prog \[options\] arg1 arg2"  
  
这行信息会优先打印在程序的选项信息前。当中的 %prog，optparse 会以当前程序名的字符串来替代：如 os.path.basename.(sys.argv\[0\])。  
  
如果用户没有提供自定义的使用方法信息，optparse 会默认使用： “usage: %prog \[options\]”。  
  
用户在定义命令行参数的帮助信息时，不用担心换行带来的问题，optparse 会处理好这一切。  
  
设置 add\_option 方法中的  metavar 参数，有助于提醒用户 ，该命令行参数所期待的参数，如 metavar=“mode”：  
  
\-m MODE, --mode=MODE  
  
注意： metavar 参数中的字符串会自动变为大写 。  
  
在 help 参数的帮助信息里使用 %default 可以插入该命令行参数的默认值。  
  
如果程序有很多的命令行参数，你可能想为他们进行 分组，这时可以使用 OptionGroup ：  
  
  
group = OptionGroup(parser, "Dangerous Options",  "Caution: use these options at your own risk.  " "It is believed that some of them bite.")  
  
group.add\_option("-g", action="store\_true", help="Group option.")  
  
parser.add\_option\_group(group)  
  
输出如下：  
  
Usage: <yourscript> \[options\] arg1 arg2  
                            
Options:  
  -h, --help            show this help message and exit  
  -v, --verbose         make lots of noise \[default\]  
  -q, --quiet           be vewwy quiet (I'm hunting wabbits)  
  -f FILE, --filename=FILE  
                        write output to FILE  
  -m MODE, --mode=MODE  interaction mode: novice, intermediate, or  
                        expert \[default: intermediate\]  
                            
  Dangerous Options:  
    Caution: use these options at your own risk.  It is believed that some  
    of them bite.  
                            
    -g                  Group option.  
完整的列子：  
  
  
group = OptionGroup(parser, "Dangerous Options", "Caution: use these options at your own risk.  " "It is believed that some of them bite.")  
group.add\_option("-g", action="store\_true", help="Group option.")  
parser.add\_option\_group(group)  
                       
group = OptionGroup(parser, "Debug Options")  
group.add\_option("-d", "--debug", action="store\_true",  help="Print debug information")  
  
group.add\_option("-s", "--sql", action="store\_true", help="Print all SQL statements executed")  
  
group.add\_option("-e", action="store\_true", help="Print every action done")  
  
parser.add\_option\_group(group)  
  
然后，使用 add\_option 来定义命令行参数：  
  
parser.add\_option(opt\_str, ..., attr=value, ...)  
  
每个命令行参数就是由参数名字符串和参数属性组成的。如 -f 或者 –file 分别是长短参数名：  
  
parse\_args() 方法提供了一个 default 参数用于设置默认值。如：  
  
parser.add\_option("-f","--file", action="store", dest="filename", default="foo.txt")  
parser.add\_option("-v", action="store\_true", dest="verbose", default=True)  
  
又或者使用 set\_defaults()：  
  
parser.set\_defaults(filename="foo.txt",verbose=True)  
parser.add\_option(...)  
(options, args) = parser.parse\_args()  
   
显示程序版本  
  
象 usage message 一样，你可以 在创建 OptionParser 对象时，指定其 version 参数，用于显示当前程序的版本信息：  
  
parser = OptionParser(usage="%prog \[-f\] \[-q\]", version="%prog 1.0")  
  
这样，optparse 就会自动解释 –version 命令行参数：  
  
  
$ /usr/bin/foo --version  
foo 1.0  
   
处理异常  
  
  
包括程序异常和用户异常。这里主要讨论的是用户异常，是指因用户输入无效的、不完整的命令行参数而引发的异常。optparse 可以自动探测并处理一些用户异常：  
  
  
$ /usr/bin/foo -n 4x  
usage: foo \[options\]  
   
foo: error: option -n: invalid integer value: '4x'  
   
$ /usr/bin/foo -n  
usage: foo \[options\]  
   
foo: error: -n option requires an argument  
用户也可以使用 parser.error() 方法来自定义部分异常的处理：  
  
  
(options, args) = parser.parse\_args()  
\[...\]  
if options.a and options.b:  
parser.error("options -a and -b are mutually exclusive")  
上面的例子，当 -b 和 -b 命令行参数同时存在时，会打印出“options -a and -b are mutually exclusive“，以警告用户。  
如果以上的异常处理方法还不能满足要求，你可能需要继承 OptionParser 类，并重载 exit() 和 erro() 方法。  
   
完整的程序例子  
  
from optparse import OptionParser  
\[...\]  
def main():  
usage = "usage: %prog \[options\] arg"  
parser = OptionParser(usage)  
parser.add\_option("-f", "--file", dest="filename",  
help="read data from FILENAME")  
parser.add\_option("-v", "--verbose",  
action="store\_true", dest="verbose")  
parser.add\_option("-q", "--quiet",  
action="store\_false", dest="verbose")  
\[...\]  
(options, args) = parser.parse\_args()  
if len(args) != 1:  
parser.error("incorrect number of arguments")  
if options.verbose:  
print "reading %s..." % options.filename  
\[...\]  
   
if \_\_name\_\_ == "\_\_main\_\_":  
main()  
  
  
\# psutil是一个跨平台库（http://code.google.com/p/psutil/），能够轻松实现获取系统运行的进程和系统利用率（包括CPU、内存、磁盘、网络等）信息 。它主要应用于系统监控，分析和限制系统资源及进程的管理。它实现了同等命令行工具提供的功能，如ps、top、lsof、netstat、ifconfig、who、df、kill、free、nice、ionice、iostat、iotop、uptime、pidof、tty、taskset、pmap等。目前支持32位和64位的Linux、Windows、OS X、FreeBSD和Sun Solaris等操作系统，   
  
  
\#!/usr/bin/env python  
\# coding:utf-8  
import psutil  
import time  
import sys  
from optparse import OptionParser  
from datetime import date,datetime  
import xlwt  
import xlsxwriter  
f = open("D:/1.txt", 'w+')  
parser = OptionParser()  
  
parser.add\_option("-t", "--time", dest="time", help="此参数可查看当前下载占的带宽,-t是测试时间", metavar="10")  
  
parser.add\_option("-d", "--deamon", action="store\_false", dest="deamon", default=True, help="后台运行此脚本")  
   
   
def Sysinfo():  
    Boot\_Start = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(psutil.boot\_time()))  
    type(Boot\_Start)  
    time.sleep(0.5)  
    Cpu\_usage = psutil.cpu\_percent()  
    RAM = int(psutil.virtual\_memory().total / (1027 \* 1024))  
    RAM\_percent = psutil.virtual\_memory().percent  
    Swap = int(psutil.swap\_memory().total / (1027 \* 1024))  
    Swap\_percent = psutil.swap\_memory().percent  
    Net\_sent = psutil.net\_io\_counters().bytes\_sent  
    Net\_recv = psutil.net\_io\_counters().bytes\_recv  
    Net\_spkg = psutil.net\_io\_counters().packets\_sent  
    Net\_rpkg = psutil.net\_io\_counters().packets\_recv  
    BFH = r'%'  
   
    print >> f, " 开机时间：%s" % Boot\_Start  
    print >> f," CPU使用率：%s%s" % (Cpu\_usage, BFH)  
    print >> f,"内存：%dM\\t内存使用率：%s%s" % (RAM, RAM\_percent, BFH)  
    print >> f,"交换分区内存：%dM\\t交换分区使用率：%s%s" % (Swap, Swap\_percent, BFH)  
    print >> f," 发送：%d Byte\\t发送包数：%d个" % (Net\_sent, Net\_spkg)  
    print >>f," 接收：%d Byte\\t接收包数：%d个" % (Net\_recv, Net\_rpkg)  
   
    for i in psutil.disk\_partitions():  
        print >> f," 盘符: %s 挂载点: %s 磁盘使用率: %s%s" % (i\[0\], i\[1\], psutil.disk\_usage(i\[1\])\[3\], BFH)  
   
   
def Net\_io(s):  
    x = 0  
    sum = 0  
    while True:  
        if x >= s:  
            break  
        r1 = psutil.net\_io\_counters().bytes\_recv  
        time.sleep(1)  
        r2 = psutil.net\_io\_counters().bytes\_recv  
        y = r2 - r1  
        print "%.2f Kb/s" % (y / 1024.0)  
        sum += y  
        x += 1  
    result = sum / x  
    print >> f,"1;33m%s秒内平均速度：%.2f Kb/s " % (x, result  /1024.0)  
   
   
if \_\_name\_\_ == "\_\_main\_\_":  
     (options, args) = parser.parse\_args()  
    if options.time:  
        Net\_io(int(options.time))  
    else:  
        Sysinfo()  
  
  
  
  
  
import optparse    
  
  
\#usage 定义的是使用方法，%prog 表示脚本本身，version定义的是脚本名字和版本号    
  
  
parse=optparse.OptionParser(usage='"usage:%prog \[options\] arg1,arg2"',version="%prog 1.2")    
  
  
parse.add\_option('-u','--user',dest='user',action='store',type=str,metavar='user',help='Enter User Name!!')    
parse.add\_option('-p','--port',dest='port',type=int,metavar='xxxxx',default=3306,help='Enter Mysql Port!!')   
   
parse.add\_option('-v',help='Mysql Version!!')    
  
  
\#-u,--user 表示一个是短选项 一个是长选项    
  
  
\#dest='user' 将该用户输入的参数保存到变量user中，可以通过options.user方式来获取该值    
\#type=str，表示这个参数值的类型必须是str字符型，如果是其他类型那么将强制转换为str（可能会报错）    
\#metavar='user'，当用户查看帮助信息，如果metavar没有设值，那么显示的帮助信息的参数后面默认带上dest所定义的变量名    
\#help='Enter..',显示的帮助提示信息    
\#default=3306，表示如果参数后面没有跟值，那么将默认为变量default的值    
  
  
parse.set\_defaults(v=1.2)  \#也可以这样设置默认值    
  
  
options,args=parse.parse\_args()    
  
  
print 'OPTIONS:',options    
print 'ARGS:',args    
     
print '~'\*20    
print 'user:',options.user    
print 'port:',options.port    
print 'version:',options.v    
  
parse\_args() 返回的两个值：  
options，它是一个对象（optpars.Values），保存有命令行参数值。只要知道命令行参数名，如 user，就可以访问其对应的值： options.user  
args:返回一个位置参数的列表  
  
action有三种类型：  
action='store' 默认类型，可以忽略不写。用户必须给出一个明确的参数值，该类型定义了将实际参数值保存到dest指定变量中  
action='store\_true' 用户不需给出参数值，该类型定义了将布尔值true保存到dest指定的变量中  
action='store\_false' 用户不需给出参数值，该类型定义了将布尔值false保存到dest指定的变量中   
  
  
from optparse import OptionParser    
from optparse import OptionGroup    
    
usage = 'Usage: %prog \[options\] arg1 arg2 ...'    
    
parser = OptionParser(usage,version='%prog 1.0')    
  
  
\#通过OptionParser类创建parser实例,初始参数usage中的%prog等同于os.path.basename(sys.argv\[0\]),即    
  
  
\#你当前所运行的脚本的名字，version参数用来显示当前脚本的版本。    
    
'''''   
添加参数，-f、--file是长短options，有一即可。   
   
action用来表示将option后面的值如何处理，比如:   
XXX.py -f test.txt   
  
  
经过parser.parse\_args()处理后,则将test.txt这个值存储进-f所代表的一个对象，即定义-f中的dest   
  
  
即option.filename = 'test.txt'   
  
  
action的常用选项还有store\_true,store\_false等，这两个通常在布尔值的选项中使用。   
   
metavar仅在显示帮助中有用，如在显示帮助时会有：   
\-f FILE, --filename=FILE    write output to FILE   
\-m MODE, --mode=MODE  interaction mode: novice, intermediate, or expert   
                        \[default: intermediate\]   
如果-f这一项没有metavr参数，则在上面会显示为-f FILENAME --filename=FILENAME,即会显示dest的值   
   
defalut是某一选项的默认值，当调用脚本时，参数没有指定值时，即采用default的默认值。   
'''    
    
parser.add\_option('-f','--file',action='store',dest='filename',  metavar='FILE',help='write output to FILE')    
    
parser.add\_option('-m','--mode',  default = 'intermediate',  help='interaction mode:novice,intermediate,or expert \[default:%default\]')    
parser.add\_option('-v','--verbose',  action='store\_true',dest='verbose',default=True,  help='make lots of noise \[default\]')    
    
parser.add\_option('-q','--quiet',  action='store\_false',dest='verbose',  help="be vewwy quiet (I'm hunting wabbits)")    
    
group = OptionGroup(parser,'Dangerous Options',   'Caution: use these options at your own risk.'  'It is believed that some of them bite.')    
  
  
  
  
\#调用OptionGroup类，定制以组显示的option    
    
group.add\_option('-g',action='store\_true',help='Group option.')    
\#添加option    
parser.add\_option\_group(group)    
\#将刚定制的groupoption加入parser中    
    
group = OptionGroup(parser,'Debug Options')    
group.add\_option('-d','--debug',action='store\_true',    
                 help='Print debug information.')    
group.add\_option('-s','--sql',action='store\_true',    
                 help='Print all SQL statements executed')    
group.add\_option('-e',action='store\_true',help='Print every action done')    
parser.add\_option\_group(group)    
    
(options,args) = parser.parse\_args()    
\#解析脚本输入的参数值，options是一个包含了option值的对象    
\#args是一个位置参数的列表</span>     
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
\#!/usr/bin/env python  
  
  
**from optparse import OptionParser**  
  
**parser = OptionParser()**  
  
  
parser.add\_option("-f", "--file", dest="filename",  
                  help="write report to FILE", metavar="FILE")  
  
  
parser.add\_option("-q", "--quiet",  
                  action="store\_false", dest="verbose", default=True,  
                  help="don't print status messages to stdout")

**(options, args) = parser.parse\_args() **

\#!/usr/bin/python

\#-\*- coding:UTF-8 -\*-  
  
  
try:  
    import os,sys  
    import re  
    import datetime  
    import shutil  
    import commands  
  
  
    **from optparse import OptionParser**  
except ImportError,e:  
    print "Error:",e  
    sys.exit()  
  
  
def Get\_And\_ScpLogfile(host,list,tmpdir,yestoday):  
    logdir = '/log/'  
    desdir = '/home/haoren/logdir/'  
    **global dirs;dirs = \[\]**  
    for ip in list:  
        ident = ip.split('.')\[3\]  
        ldir = '%s%s\_%s' % (tmpdir,yestoday,ident)  
        dirs.append(ldir)   
        if not os.path.exists(ldir):  
                os.makedirs(ldir)  
  
  
        s,o = commands.getstatusoutput('ssh %s /bin/ls -ld %s%s ' % (ip,logdir,yestoday))  
        print "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*%s\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*" % ip  
        print "BEGIN:"  
        if s == 0:  
            os.system('/usr/bin/scp -r %s:%s%s/\* %s' % (ip,logdir,yestoday,ldir))   
        else:  
            os.system('/usr/bin/scp -r %s:%s\*%s\* %s' % (ip,logdir,yestoday,ldir))   
  
  
  
  
    for ip in host:  
         print "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*SCP\_To\_%s\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*" % ip  
         print "BEGIN:"  
         os.system('/usr/bin/scp -r %s%s\* %s:%s' % (tmpdir,yestoday,ip,desdir))       
  
  
def CleanLogFile():  
    for d in dirs:  
        shutil.rmtree(d,True)  
  
  
def main():  
    \#\#\#\#option\#\#\#\#  
    parser = OptionParser()  
    parser.add\_option("-t","--time",action="store",dest="filedate",help="appoint the logfile time,use like this '-t 130825'")  
    (options,args) = parser.parse\_args()  
  
  
    \#\#\#\#option\#\#\#\#  
      
    if options.filedate:  
        filedate = options.filedate  
    else:  
        filedate = (datetime.datetime.now() - datetime.timedelta(days=1)).strftime('%y%m%d')  
  
  
    iplist = \[\]  
    host = \[\]  
    tmpdir = '/home/haoren/tempdir/'  
    f = open('/home/haoren/tools/log\_config.ini','r')  
    for line in f:  
        line = line.strip()  
        if re.search(r'^\[0-9\]\{1,2\}=.\*',line):  
            iplist.append(line.split('=')\[1\])  
        elif re.search(r'^host=.\*',line):  
            \#host = line.split('=')\[1\]  
            host.append(line.split('=')\[1\])  
        elif re.search(r'^host2=.\*',line):  
        \#    host2 = line.split('=')\[1\]  
            host.append(line.split('=')\[1\])  
    f.close()  
    Get\_And\_ScpLogfile(host,iplist,tmpdir,filedate)   
    CleanLogFile()  
  
  
if \_\_name\_\_ == "\_\_main\_\_":  
    main()

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

Python optparser库详解

相关文章