什么是最好的方式来分析命令行的论点?
https://stackoverflow.com/questions/20063
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
什么是的 最简单的, tersest, 和大多数 灵活 法或库，用于分析蟒蛇命令行的论点?
解决方案
这个答案的建议 optparse 这是适当的年龄较大的蟒蛇的版本。Python2.7以上， argparse 替换 optparse.看看 这个答案 更多的信息。
正如其他人指出的那样，你最好去optparse过getopt.getopt是很多一对一的映射的标准getopt(3)C图书馆的功能，并不是很容易使用。
optparse，同时多一点的详细、更好的结构和更简单延长。
这是一个典型的线添加一个选项，你的分析器:
parser.add_option('-q', '--query',
action="store", dest="query",
help="query string", default="spam")
它几乎不言本身；在处理时间，它就会接受问或查询--作为选项，储存的论点在属性查询，并有一个默认的价值，如果你不指定。它也是自的记录在你的声明的帮助的论据(这将可使用当运行-h--帮助)有权利用的选择。
通常你分析你的论点：
options, args = parser.parse_args()
这会默认情况下，分析标准的参数过脚本(sys.argv[1:])
选项。查询，然后将设置到价值传递到脚本。
你创建的一个分析器可简单地通过这样做
parser = optparse.OptionParser()
这些是所有基本需要。这里是一个完整的Python脚本，显示了这一点：
import optparse
parser = optparse.OptionParser()
parser.add_option('-q', '--query',
action="store", dest="query",
help="query string", default="spam")
options, args = parser.parse_args()
print 'Query string:', options.query
5线的蟒蛇，你展示的基础。
它保存在sample.py并运行一次有
python sample.py
和一次
python sample.py --query myquery
除此之外，你会发现optparse是很容易的扩展。在我的一个项目，我创建了一个类命令，允许你窝子命令中命令树容易。它使用optparse重要链，命令在一起。它不是东西，我可以很容易地解释了几行，但感到自由 浏览绕在我的仓库 对于主流，以及 一类使用和选择分析器
其他提示
其他的答案不说 argparse 是的路要走，为新的蟒蛇，但不得使用情况的例子。为完整起见，这里是一个短摘要如何使用argparse:
1)的初始化
import argparse
# Instantiate the parser
parser = argparse.ArgumentParser(description='Optional app description')
2)添加参数
# Required positional argument
parser.add_argument('pos_arg', type=int,
help='A required integer positional argument')
# Optional positional argument
parser.add_argument('opt_pos_arg', type=int, nargs='?',
help='An optional integer positional argument')
# Optional argument
parser.add_argument('--opt_arg', type=int,
help='An optional integer argument')
# Switch
parser.add_argument('--switch', action='store_true',
help='A boolean switch')
3)分析
args = parser.parse_args()
4)访问
print("Argument values:")
print(args.pos_arg)
print(args.opt_pos_arg)
print(args.opt_arg)
print(args.switch)
5)检查的价值观
if args.pos_arg > 10:
parser.error("pos_arg cannot be larger than 10")
使用
正确使用：
$ ./app 1 2 --opt_arg 3 --switch
Argument values:
1
2
3
True
不正确的参数：
$ ./app foo 2 --opt_arg 3 --switch
usage: convert [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
app: error: argument pos_arg: invalid int value: 'foo'
$ ./app 11 2 --opt_arg 3
Argument values:
11
2
3
False
usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
convert: error: pos_arg cannot be larger than 10
完全帮助：
$ ./app -h
usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
Optional app description
positional arguments:
pos_arg A required integer positional argument
opt_pos_arg An optional integer positional argument
optional arguments:
-h, --help show this help message and exit
--opt_arg OPT_ARG An optional integer argument
--switch A boolean switch
使用docopt
由于2012年Python有一个非常简单的、强大和真的 很酷的 模块，用于论证分析所谓 docopt.它的工作与Python2.6到3.5并不需要安装(只要复制它)。这里的一个例子是采取从它的文件：
"""Naval Fate.
Usage:
naval_fate.py ship new <name>...
naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
naval_fate.py ship shoot <x> <y>
naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
naval_fate.py (-h | --help)
naval_fate.py --version
Options:
-h --help Show this screen.
--version Show version.
--speed=<kn> Speed in knots [default: 10].
--moored Moored (anchored) mine.
--drifting Drifting mine.
"""
from docopt import docopt
if __name__ == '__main__':
arguments = docopt(__doc__, version='Naval Fate 2.0')
print(arguments)
因此，这是它：2线的代码，加上你的医生字符串 是 重要的而你得到你的参数的分析，可以在你的论点对象。我告诉过你这很酷，我不;-)
使用python火
由于2017 蟒蛇火 有另一个很酷的模块，该模块可以得到CLI接到你的代码你做的 零 参数的分析。这里有一个简单的例从文件(这个小小的程序功能公开 double 到命令行):
import fire
class Calculator(object):
def double(self, number):
return 2 * number
if __name__ == '__main__':
fire.Fire(Calculator)
从命令行，可以运行：
> calculator.py double 10
20
> calculator.py double --number=15
30
真棒不是吗?
我更喜欢 点击.它摘要，管理选项，并允许"(...)创造美丽的命令行接口组合性的方式用尽可能少代码作为必要的"。
这是实例中的使用情况：
import click
@click.command()
@click.option('--count', default=1, help='Number of greetings.')
@click.option('--name', prompt='Your name',
help='The person to greet.')
def hello(count, name):
"""Simple program that greets NAME for a total of COUNT times."""
for x in range(count):
click.echo('Hello %s!' % name)
if __name__ == '__main__':
hello()
它还能自动产生很好的格式帮助页面：
$ python hello.py --help
Usage: hello.py [OPTIONS]
Simple program that greets NAME for a total of COUNT times.
Options:
--count INTEGER Number of greetings.
--name TEXT The person to greet.
--help Show this message and exit.
几乎每个人都是使用 getopt
这里是例代码文档：
import getopt, sys
def main():
try:
opts, args = getopt.getopt(sys.argv[1:], "ho:v", ["help", "output="])
except getopt.GetoptError:
# print help information and exit:
usage()
sys.exit(2)
output = None
verbose = False
for o, a in opts:
if o == "-v":
verbose = True
if o in ("-h", "--help"):
usage()
sys.exit()
if o in ("-o", "--output"):
output = a
因此，在一个词，这是它是如何工作的。
你已经有了两种类型的选择。那些接受的论点，和那些 就像开关。
sys.argv 是很多你的 char** argv C.就像在你跳过C第一个元素名称的程序和分析仅参数： sys.argv[1:]
Getopt.getopt 将分析它根据规则你放弃的参数。
"ho:v" 这里介绍的短参数： -ONELETTER.的 : 意味着 -o 接受一个参数。
最后 ["help", "output="] 描述了长期参数( --MORETHANONELETTER ).的 = 后输出再次指出接受一个参数。
其结果是一个列表中的几(选项，参数)
如果选择不接受任何论点(喜欢 --help 这里) arg 部分是空的串。然后，您通常要循环这个名单上的和测试的选项名为的例子。
我希望这有助于你。
使用 optparse 其附带的标准图书馆。例如：
#!/usr/bin/env python
import optparse
def main():
p = optparse.OptionParser()
p.add_option('--person', '-p', default="world")
options, arguments = p.parse_args()
print 'Hello %s' % options.person
if __name__ == '__main__':
main()
资料来源： 使用Python创建的UNIX command line工具
但是如Python2.7optparse已被否决，参见： 为什么使用argparse而不是optparse?
只是在情况可能需要,这可以帮助如果你需要 抓住 unicode的论点Win32(2K，XP等):
from ctypes import *
def wmain(argc, argv):
print argc
for i in argv:
print i
return 0
def startup():
size = c_int()
ptr = windll.shell32.CommandLineToArgvW(windll.kernel32.GetCommandLineW(), byref(size))
ref = c_wchar_p * size.value
raw = ref.from_address(ptr)
args = [arg for arg in raw]
windll.kernel32.LocalFree(ptr)
exit(wmain(len(args), args))
startup()
轻量级的命令行争论的默认值
虽然 argparse 是伟大的，是正确的答案对于充分记录的命令线路开关和先进的功能，可以使用函数默认要处理简单位的参数非常简单。
import sys
def get_args(name='default', first='a', second=2):
return first, int(second)
first, second = get_args(*sys.argv)
print first, second
'名称的论点抓住脚本名称而不是使用。检验出是这样的：
> ./test.py
a 2
> ./test.py A
A 2
> ./test.py A 20
A 20
为简单的脚本我只是想要一些缺省值，我找到这个相当充足。你可能还需要包括某些类型的胁迫的返回值或命令行的价值观，将所有被串。
我认为最好的方式为较大的项目是optparse，但是如果你是在寻找一个简单的方法，也许 http://werkzeug.pocoo.org/documentation/script 是你的东西。
from werkzeug import script
# actions go here
def action_foo(name=""):
"""action foo does foo"""
pass
def action_bar(id=0, title="default title"):
"""action bar does bar"""
pass
if __name__ == '__main__':
script.run()
所以基本上每一个功能action_*露出来的命令线路和一个漂亮 帮助消息的产生是免费的。
python foo.py
usage: foo.py <action> [<options>]
foo.py --help
actions:
bar:
action bar does bar
--id integer 0
--title string default title
foo:
action foo does foo
--name string
我更喜欢optparse到getopt.这是非常声明:你告诉它的名称的选择和影响他们应该有(例如，设置一个布尔的领域)，和它的手，你回字典填充，根据你的规格。
consoleargs 值得提到的在这里。这是非常容易使用。检查出来：
from consoleargs import command
@command
def main(url, name=None):
"""
:param url: Remote URL
:param name: File name
"""
print """Downloading url '%r' into file '%r'""" % (url, name)
if __name__ == '__main__':
main()
现在控制台:
% python demo.py --help
Usage: demo.py URL [OPTIONS]
URL: Remote URL
Options:
--name -n File name
% python demo.py http://www.google.com/
Downloading url ''http://www.google.com/'' into file 'None'
% python demo.py http://www.google.com/ --name=index.html
Downloading url ''http://www.google.com/'' into file ''index.html''
Argparse代码可以被长于实际执行代码！
这是一个问题，我找到与最受欢迎的论点分析的选择是，如果你参数仅是适度的，该代码文档它们变得不成比例的巨大利益，他们提供。
一个相对新来的参数分析的场景(I think)是 。.
它使一些公认的贸易平衡与argparse，但使用内联的文件和包裹简单地周围 main() 类型的功能，功能：
def main(excel_file_path: "Path to input training file.",
excel_sheet_name:"Name of the excel sheet containing training data including columns 'Label' and 'Description'.",
existing_model_path: "Path to an existing model to refine."=None,
batch_size_start: "The smallest size of any minibatch."=10.,
batch_size_stop: "The largest size of any minibatch."=250.,
batch_size_step: "The step for increase in minibatch size."=1.002,
batch_test_steps: "Flag. If True, show minibatch steps."=False):
"Train a Spacy (http://spacy.io/) text classification model with gold document and label data until the model nears convergence (LOSS < 0.5)."
pass # Implementation code goes here!
if __name__ == '__main__':
import plac; plac.call(main)
这里有一个方法，不是一个图书馆，它似乎要为我工作。
该目标是以简洁，每个参数分析的一个单一线,args行为的可读性，代码是简单的，并不依赖于任何特殊的模块(唯一的操作系统+系统)，警告有关丢失或未知参数正常，使用一个简单/范围()循环，并可以作跨python2.x和3。x
图中所示的是两个切换标志(d-v)，和两个值控制的参数(-我xxx和-o xxx)。
import os,sys
def HelpAndExit():
print("<<your help output goes here>>")
sys.exit(1)
def Fatal(msg):
sys.stderr.write("%s: %s\n" % (os.path.basename(sys.argv[0]), msg))
sys.exit(1)
def NextArg(i):
'''Return the next command line argument (if there is one)'''
if ((i+1) >= len(sys.argv)):
Fatal("'%s' expected an argument" % sys.argv[i])
return(1, sys.argv[i+1])
### MAIN
if __name__=='__main__':
verbose = 0
debug = 0
infile = "infile"
outfile = "outfile"
# Parse command line
skip = 0
for i in range(1, len(sys.argv)):
if not skip:
if sys.argv[i][:2] == "-d": debug ^= 1
elif sys.argv[i][:2] == "-v": verbose ^= 1
elif sys.argv[i][:2] == "-i": (skip,infile) = NextArg(i)
elif sys.argv[i][:2] == "-o": (skip,outfile) = NextArg(i)
elif sys.argv[i][:2] == "-h": HelpAndExit()
elif sys.argv[i][:1] == "-": Fatal("'%s' unknown argument" % sys.argv[i])
else: Fatal("'%s' unexpected" % sys.argv[i])
else: skip = 0
print("%d,%d,%s,%s" % (debug,verbose,infile,outfile))
我们的目标的NextArg()为返回的下一步论据的同时，检查缺少的数据，而"跳过"跳过的循环当NextArg()用，保持该标志分析的下一个衬垫。
我延长Erco的办法，以允许必要的位置的论点和可选择的论点。这些应该在前面-d-v，等等。参数。
位置和可选择的论点可以检索与PosArg(i)和OptArg(i，默认)。当一个可选择的论点是找到起始位置的搜索选项(如-i)移动1续前进，以避免造成一种'意想不到'致命的。
import os,sys
def HelpAndExit():
print("<<your help output goes here>>")
sys.exit(1)
def Fatal(msg):
sys.stderr.write("%s: %s\n" % (os.path.basename(sys.argv[0]), msg))
sys.exit(1)
def NextArg(i):
'''Return the next command line argument (if there is one)'''
if ((i+1) >= len(sys.argv)):
Fatal("'%s' expected an argument" % sys.argv[i])
return(1, sys.argv[i+1])
def PosArg(i):
'''Return positional argument'''
if i >= len(sys.argv):
Fatal("'%s' expected an argument" % sys.argv[i])
return sys.argv[i]
def OptArg(i, default):
'''Return optional argument (if there is one)'''
if i >= len(sys.argv):
Fatal("'%s' expected an argument" % sys.argv[i])
if sys.argv[i][:1] != '-':
return True, sys.argv[i]
else:
return False, default
### MAIN
if __name__=='__main__':
verbose = 0
debug = 0
infile = "infile"
outfile = "outfile"
options_start = 3
# --- Parse two positional parameters ---
n1 = int(PosArg(1))
n2 = int(PosArg(2))
# --- Parse an optional parameters ---
present, a3 = OptArg(3,50)
n3 = int(a3)
options_start += int(present)
# --- Parse rest of command line ---
skip = 0
for i in range(options_start, len(sys.argv)):
if not skip:
if sys.argv[i][:2] == "-d": debug ^= 1
elif sys.argv[i][:2] == "-v": verbose ^= 1
elif sys.argv[i][:2] == "-i": (skip,infile) = NextArg(i)
elif sys.argv[i][:2] == "-o": (skip,outfile) = NextArg(i)
elif sys.argv[i][:2] == "-h": HelpAndExit()
elif sys.argv[i][:1] == "-": Fatal("'%s' unknown argument" % sys.argv[i])
else: Fatal("'%s' unexpected" % sys.argv[i])
else: skip = 0
print("Number 1 = %d" % n1)
print("Number 2 = %d" % n2)
print("Number 3 = %d" % n3)
print("Debug = %d" % debug)
print("verbose = %d" % verbose)
print("infile = %s" % infile)
print("outfile = %s" % outfile)
