Question

我有点问题。

我使用argparse来解析我的论点，并且它运作良好。

为了得到args，我这样做：

p_args = parser.parse_args(argv)
args = dict(p_args._get_kwargs())

但是p_args的问题是我不知道如何通过它们在命令行中的位置来排序这些参数，因为它是一个字典。

那么有没有可能在命令行中按顺序在元组/列表/有序字典中包含参数？

Answer 1

为了保持参数的排序，我使用这样的自定义动作：

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)

Answer 2

如果您需要知道参数在解析器中出现的顺序，可以像这样设置解析器：

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 documentation。

Answer 3

这有点脆弱，因为它依赖于理解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()不包含列表中任何参数的病态案例）

Answer 4

有专门用来处理这个问题的模块：

https://github.com/claylabs/ordered-keyword-args

不使用orderedkwargs模块

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

使用orderedkwargs模块

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

注意：在函数上方使用带有装饰器的模块时需要单个星号。

Answer 5

我需要这个，因为为了记录目的，我喜欢在解析后打印参数。问题是参数没有按顺序打印，这真的很烦人。

自定义动作类只是对我不起作用。我有其他使用不同操作的参数，例如'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和parse_args，所以这很符合我的目的。如果您想使用父ArgumentParser s。

，您还需要做更多工作

Answer 6

这是基于现有解决方案的简单解决方案：

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（）中的动作，这对于自定义动作类解决方案来说比较困难。

argparse参数顺序

6 个答案:

不使用orderedkwargs模块

使用orderedkwargs模块