我有一个小问题。
我argparse
用来解析我的论点,而且效果很好。
要获得参数,我会:
p_args = parser.parse_args(argv)
args = dict(p_args._get_kwargs())
但问题p_args
是我不知道如何让这些参数按它们在命令行中的位置排序,因为它是一个字典。
那么有没有可能按照命令行中的顺序将参数放在元组/列表/有序字典中?
我有一个小问题。
我argparse
用来解析我的论点,而且效果很好。
要获得参数,我会:
p_args = parser.parse_args(argv)
args = dict(p_args._get_kwargs())
但问题p_args
是我不知道如何让这些参数按它们在命令行中的位置排序,因为它是一个字典。
那么有没有可能按照命令行中的顺序将参数放在元组/列表/有序字典中?
为了保持参数有序,我使用了这样的自定义操作:
import argparse
class CustomAction(argparse.Action):
def __call__(self, parser, namespace, values, option_string=None):
if not 'ordered_args' in namespace:
setattr(namespace, 'ordered_args', [])
previous = namespace.ordered_args
previous.append((self.dest, values))
setattr(namespace, 'ordered_args', previous)
parser = argparse.ArgumentParser()
parser.add_argument('--test1', action=CustomAction)
parser.add_argument('--test2', action=CustomAction)
要使用它,例如:
>>> parser.parse_args(['--test2', '2', '--test1', '1'])
Namespace(ordered_args=[('test2', '2'), ('test1', '1')], test1=None, test2=None)
如果您需要知道参数在解析器中出现的顺序,您可以像这样设置解析器:
import argparse
parser = argparse.ArgumentParser(description = "A cool application.")
parser.add_argument('--optional1')
parser.add_argument('positionals', nargs='+')
parser.add_argument('--optional2')
args = parser.parse_args()
print args.positionals
这是运行此代码的快速示例:
$ python s.py --optional1 X --optional2 Y 1 2 3 4 5
['1', '2', '3', '4', '5']
请注意,这args.positionals
是一个按顺序排列位置参数的列表。有关详细信息,请参阅argparse 文档。
这有点脆弱,因为它依赖于对内部的理解argparse.ArgumentParser
,但是代替重写argparse.ArgumentParser.parse_known_args
,这是我使用的:
class OrderedNamespace(argparse.Namespace):
def __init__(self, **kwargs):
self.__dict__["_arg_order"] = []
self.__dict__["_arg_order_first_time_through"] = True
argparse.Namespace.__init__(self, **kwargs)
def __setattr__(self, name, value):
#print("Setting %s -> %s" % (name, value))
self.__dict__[name] = value
if name in self._arg_order and hasattr(self, "_arg_order_first_time_through"):
self.__dict__["_arg_order"] = []
delattr(self, "_arg_order_first_time_through")
self.__dict__["_arg_order"].append(name)
def _finalize(self):
if hasattr(self, "_arg_order_first_time_through"):
self.__dict__["_arg_order"] = []
delattr(self, "_arg_order_first_time_through")
def _latest_of(self, k1, k2):
try:
print self._arg_order
if self._arg_order.index(k1) > self._arg_order.index(k2):
return k1
except ValueError:
if k1 in self._arg_order:
return k1
return k2
argparse.ArgumentParser.parse_known_args
一旦为每个参数设置默认值,这通过贯穿整个选项列表的知识来工作。这意味着用户指定的参数第一次开始时会__setattr__
遇到以前见过的参数。
用法:
options, extra_args = parser.parse_known_args(sys.argv, namespace=OrderedNamespace())
您可以检查options._arg_order
用户指定的命令行参数的顺序,或用于options._latest_of("arg1", "arg2")
查看稍后在命令行上指定的--arg1
或--arg2
指定的(出于我的目的,这是我需要的:查看两个选项中的哪一个是最重要的)。
更新:必须添加方法来处理列表中不包含任何参数的_finalize
病理情况)sys.argv()
有专门用于处理此问题的模块:
https://github.com/claylabs/ordered-keyword-args
def multiple_kwarguments(first , **lotsofothers):
print first
for i,other in lotsofothers:
print other
return True
multiple_kwarguments("first", second="second", third="third" ,fourth="fourth" ,fifth="fifth")
输出:
first
second
fifth
fourth
third
from orderedkwargs import ordered kwargs
@orderedkwargs
def mutliple_kwarguments(first , *lotsofothers):
print first
for i, other in lotsofothers:
print other
return True
mutliple_kwarguments("first", second="second", third="third" ,fourth="fourth" ,fifth="fifth")
输出:
first
second
third
fourth
fifth
注意:在函数上方使用带有装饰器的此模块时,需要单个星号。
我需要这个,因为出于日志记录的目的,我喜欢在参数被解析后打印出来。问题是参数没有按顺序打印,这真的很烦人。
自定义操作类完全不适合我。我有其他使用不同操作的参数,例如'store_true'
和default
参数也不起作用,因为如果在命令行中没有给出参数,则不会调用自定义操作类。对我有用的是创建一个像这样的包装类:
import collections
from argparse import ArgumentParser
class SortedArgumentParser():
def __init__(self, *args, **kwargs):
self.ap = ArgumentParser(*args, **kwargs)
self.args_dict = collections.OrderedDict()
def add_argument(self, *args, **kwargs):
self.ap.add_argument(*args, **kwargs)
# Also store dest kwarg
self.args_dict[kwargs['dest']] = None
def parse_args(self):
# Returns a sorted dictionary
unsorted_dict = self.ap.parse_args().__dict__
for unsorted_entry in unsorted_dict:
self.args_dict[unsorted_entry] = unsorted_dict[unsorted_entry]
return self.args_dict
优点是该add_argument
方法应该具有与原始方法完全相同的功能ArgumentParser
。缺点是,如果您想要其他方法,则必须为所有方法编写包装。幸运的是,我曾经使用过的只是add_argument
and parse_args
,所以这很好地满足了我的目的。如果您想使用 parent ,您还需要做更多ArgumentParser
的工作。
这是我基于现有解决方案的简单解决方案:
class OrderedNamespace(argparse.Namespace):
def __init__(self, **kwargs):
self.__dict__["_order"] = [None]
super().__init__(**kwargs)
def __setattr__(self, attr, value):
super().__setattr__(attr, value)
if attr in self._order:
self.__dict__["_order"].clear()
self.__dict__["_order"].append(attr)
def ordered(self):
if self._order and self._order[0] is None:
self._order.clear()
return ((attr, getattr(self, attr)) for attr in self._order)
parser = argparse.ArgumentParser()
parser.add_argument('--test1', default=1)
parser.add_argument('--test2')
parser.add_argument('-s', '--slong', action='store_false')
parser.add_argument('--test3', default=3)
args = parser.parse_args(['--test2', '2', '--test1', '1', '-s'], namespace=OrderedNamespace())
print(args)
print(args.test1)
for a, v in args.ordered():
print(a, v)
输出:
OrderedNamespace(_order=['test2', 'test1', 'slong'], slong=False, test1='1', test2='2', test3=3)
1
test2 2
test1 1
slong False
它允许 add_argument() 中的操作,这对于自定义操作类解决方案来说更难。