blocks|key|1672300|text|如果你发现argparse太难入门了，因为它太复杂了，那么你可能会喜欢PyPi上的plac。它是一个围绕argparse的包装器，它隐藏了复杂性，并为您处理了大量样板参数检查。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1672301|它适用于Python2和Python3，并且有一个装饰器，允许Python2用户访问Python3函数参数的一个很好的特性。您甚至可以将命令相互嵌套，这样就可以在一个命令行上使用-arguments+(以破折号开头)和.arguments+(以点开头)。|1672302|这里是文档http://plac.googlecode.com/hg/doc/plac.html|1672303|entityMap|0|LINK|mutability|MUTABLE|url|http://plac.googlecode.com/hg/doc/plac.html^0|5|8|15|4|0|0|5|17|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|J|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

If you found <code>argparse</code> to be too hard to get started with because of the complexity, then you would probably like <code>plac</code> which is available on PyPi. It is a wrapper around argparse which hides the complexity, and it takes care of a lot of boilerplate argument checking for you.

It works for both Python 2 and 3, and has a decorator that allows Python 2 users to get access to a nice Python 3 feature for function parameters. And you can even nest commands in one another so that you could have -arguments (beginning with dash) and .arguments (beginning with dot) on one command line.

Here are the docs <a href="http://plac.googlecode.com/hg/doc/plac.html" rel="nofollow">http://plac.googlecode.com/hg/doc/plac.html</a>

blocks|key|68760|text|我认为argparse是最好的选择。它做了很好的工作，它很容易使用，并且是从2.7开始的标准库。看一看nargs的论点。从docs|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|68761|要消耗的固定元素|68762|68763|解析器=+argparse.ArgumentParser()+parser.add_argument('+--foo+'，nargs=2)+parser.add_argument('bar'，nargs=1)+parser.parse_args('c+--foo+a+b'.split())命名空间(bar=‘c’，foo='a'，'b')|blockquote|68764|68765|如果可能，将从命令行使用一个arg，并将其作为单个项目生成。如果不存在命令行arg，则将生成默认值|68766|68767|解析器=+argparse.ArgumentParser()+parser.add_argument('+--foo+'，nargs='?'，const='c'，default='d')+parser.add_argument('bar'，nargs='?'，default='d')+parser.parse_args('XX+--foo+YY'.split())命名空间(bar=‘XX’，foo='YY')+parser.parse_args('XX+--foo'.split())命名空间(bar=‘XX’，foo='c')+parser.parse_args(''.split())命名空间(bar=‘d’，foo='d')|68768|68769|存在的所有命令行参数都被收集到一个列表中。|68770|68771|解析器=+argparse.ArgumentParser()+parser.add_argument('+--foo+'，nargs='*')+parser.add_argument('+--bar+'，nargs='*')+parser.add_argument('baz'，nargs='*')+parser.parse_args('a+b--foo+x+y--bar+1+2‘..split())命名空间(bar=’1‘，'2'，baz='a'，'b'，foo='x'，'y')|68772|68773|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/argparse.html^0|1P|4|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|19|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|1A|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]|$1|N|3|O|5|I|7|1E|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1G|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]|$1|T|3|U|5|I|7|1I|8|@]|9|@]|C|$]]|$1|V|3|-4|5|6|7|1J|8|@]|9|@]|C|$]]|$1|W|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]]]

I think that argparse is the way to go. It does a great job, it is easy to use and in the standard library since 2.7. Take a look a the nargs argument. From the <a href="http://docs.python.org/library/argparse.html" rel="nofollow">docs</a>

Fixed elements to consume

<blockquote>
 <blockquote>
 <blockquote>
 parser = argparse.ArgumentParser()
 parser.add_argument('--foo', nargs=2)
 parser.add_argument('bar', nargs=1)
 parser.parse_args('c --foo a b'.split())
 Namespace(bar=['c'], foo=['a', 'b'])
 </blockquote>
 </blockquote>
</blockquote>

One arg will be consumed from the command line if possible, and produced as a single item. If no command-line arg is present, the value from default will be produced

<blockquote>
 <blockquote>
 <blockquote>
 parser = argparse.ArgumentParser()
 parser.add_argument('--foo', nargs='?', const='c', default='d')
 parser.add_argument('bar', nargs='?', default='d')
 parser.parse_args('XX --foo YY'.split())
 Namespace(bar='XX', foo='YY')
 parser.parse_args('XX --foo'.split())
 Namespace(bar='XX', foo='c')
 parser.parse_args(''.split())
 Namespace(bar='d', foo='d')
 </blockquote>
 </blockquote>
</blockquote>

All command-line args present are gathered into a list.

<blockquote>
 <blockquote>
 <blockquote>
 parser = argparse.ArgumentParser()
 parser.add_argument('--foo', nargs='*')
 parser.add_argument('--bar', nargs='*')
 parser.add_argument('baz', nargs='*')
 parser.parse_args('a b --foo x y --bar 1 2'.split())
 Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])
 </blockquote>
 </blockquote>
</blockquote>

blocks|key|68794|text|自2012年以来，Python有了一个简单、强大且非常酷的参数解析模块，称为docopt。它可以在2.5到3.3版本的Python上运行，不需要安装。以下是针对您的特定情况的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|68795|'''app.py

Usage:
++app.py+-a+ARG+...+-b+FILE+...
++app.py+(-h+%7C+-v)+

'''
from+docopt+import+docopt
args+=+docopt(__doc__,+version='1.0')
#+now+do+something+based+on+the+value+of+args+dict+|code-block|syntax|javascript|68796|这就是它:一行代码加上您的文档字符串，这是必不可少的。我告诉过你这很酷--不是吗;-)|68797|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/docopt/docopt^0|12|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Since 2012 Python has an easy, powerful and very cool module for argument parsing called <a href="https://github.com/docopt/docopt" rel="nofollow">docopt</a>. It works with Python from 2.5 to 3.3 and needs no installation. Here is the code for your particular case:

<pre><code>'''app.py

Usage:
 app.py -a ARG ... -b FILE ...
 app.py (-h | -v) 

'''
from docopt import docopt
args = docopt(__doc__, version='1.0')
# now do something based on the value of args dict 
</code></pre>

So this is it: one line of code plus your doc string which is essential. I told you it's cool -- didn't I ;-)

I've a Python app like this:

<pre><code>$ app.py -a arg1 -a arg2 -b file1.b -b file2.b
</code></pre>

Depending on the option, in app.py, I use two different functions to process the input files. As each option can have several file arguments, I would like something like this:

<pre><code>$ app.py -a arg1 arg2 -b *.b
</code></pre>

After searching on the net, I find these three modules: getopt, argparse, optparse

And I wrote a simple one for my app:

<pre><code>optionDict= {'-a':aFunction, '-b':bFunction}
for arg in sys.argv[1:]:
 if arg in optionDict: # arg is an option here.
 funcName = optionDict[arg]
 else: # arg is not an option, then it's a fileName. Deal with this file with the function found according to previous arg.
 funcName(arg)
</code></pre>

My quesion: Are there any other modules or better ways to do this?

In Python, is there a better way to deal with command line options when each option could have several arguments

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个Python应用程序，如下所示：$ app.py -a arg1 -a arg2 -b file1.b -b file2.b根据选项的不同，在app.py中，我使用两个不同的函数来处理输入文件。因为每个选项可以有几个文件参数，所以我希望是这样的：$ app.py -a arg1 arg2 -b *.b在网上搜索...

问在Python中，当每个选项可以有多个参数时，有没有更好的方法来处理命令行选项
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Python中，当每个选项可以有多个参数时，有没有更好的方法来处理命令行选项EN