argparse argument, um

Ich habe ein kleines problem.

Benutze ich argparse zu analysieren, meine Argumente, und es funktioniert sehr gut.

Haben die args, ich weiß :

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

Aber das problem mit p_args ist, dass ich nicht weiß, wie man diese Argumente in der Reihenfolge Ihrer position in der Befehlszeile, weil es ein dict.

Also gibt es keine Möglichkeit, die Argumente in einem Tupel/Liste/bestellt dict nach Ihrer Reihenfolge in der Kommandozeile?

Es würde helfen, zu sehen, der code zeigt, wie Sie Sie eingerichtet haben-parser.

InformationsquelleAutor flopit | 2012-01-26

Halten Argumente bestellt, ich benutze eine benutzerdefinierte Aktion wie folgt:

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)

Um es zu verwenden, zum Beispiel:

>>> parser.parse_args(['--test2', '2', '--test1', '1'])
Namespace(ordered_args=[('test2', '2'), ('test1', '1')], test1=None, test2=None)

InformationsquelleAutor jterrace

4

Wenn Sie brauchen, um zu wissen, in welcher Reihenfolge die Argumente erscheinen in Ihre parser können Sie den parser so:
```
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
```
Hier ein kurzes Beispiel für diesen code ausführen:
```
$ python s.py --optional1 X --optional2 Y 1 2 3 4 5
['1', '2', '3', '4', '5']
```
Beachten Sie, dass args.positionals ist eine Liste mit den positions-Argumenten in der Reihenfolge. Finden Sie die argparse-Dokumentation für weitere Informationen.
- Ich denke, eine Verzweigung dieser Methode ist, dass argparse nicht/wird nicht jede Validierung 1,2,3,4,5 (ie erzwingen der Benutzer nur geben Sie gültige Werte für optional2). Sie würde führen Sie durch die Werte für optional2 in Ihrem code und validieren Sie.
InformationsquelleAutor srgerg
4

Dies ist ein wenig instabil, da es stützt sich auf das Verständnis der Interna argparse.ArgumentParser, aber statt der Umschreibung argparse.ArgumentParser.parse_known_args, hier ist, was ich verwenden:
```
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
```
Diese Werke durch die Erkenntnis, dass argparse.ArgumentParser.parse_known_args zieht sich durch die gesamte Liste der Optionen einmal, festlegen von Standardwerten für jedes argument. Was bedeutet, dass Benutzer angegebenen Argumenten beginnen, die erste Zeit __setattr__ trifft ein argument, dass es zuvor gesehen.

Verwendung:
```
options, extra_args = parser.parse_known_args(sys.argv, namespace=OrderedNamespace())
```
Können Sie überprüfen options._arg_order für die Bestellung von Benutzer angegebene Befehlszeile Argumente oder verwenden Sie options._latest_of("arg1", "arg2") um zu sehen, welche --arg1 oder --arg2 angegeben wurde später auf der Befehl-Linie (die, für meine Zwecke war das, was ich gebraucht habe: zu sehen, welche der beiden Optionen wäre das überschreiben einer).

UPDATE: hinzufügen musste _finalize Methode, mit der pathologischen Fall von sys.argv() enthält nicht alle Argumente in der Liste)
- Nur gut, nach messing mit meinem refactoring auf dieser und nach dem Durchlaufen eine Reihe von tests, die ich habe weiß ich, dass dies grundsätzlich nicht funktionieren im Fall von action='store_const" oder action='store_true' etc.. irgendwas mit add_argument('-f', action='store_true') wird nicht die Option-f, um die Reihenfolge der Argumente-Liste als argparse nicht fügen Sie einen beliebigen Wert für den namespace, bis das eigentliche argument begegnet, es sei denn, 'const' oder 'default' Parameter übergeben werden add_argument. BAH das hätte so eine elegante Lösung..
InformationsquelleAutor robm
1

Gibt es module, die speziell zum verarbeiten dieser :

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

ohne Verwendung orderedkwargs Modul
```
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")
```
Ausgabe:
```
first
second
fifth
fourth
third
```
Auf mit orderedkwargs Modul
```
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")
```
Ausgabe:
```
first
second
third
fourth
fifth
```
Hinweis: Single-asterik erforderlich ist, während der Verwendung dieses Moduls mit dem Symbol über die Funktion.
- Ich-Gabel-Handhabung kwargs als OrderedDict in der Funktion header und identische syntax in der Funktion Körper, als mit **kwargs Fall. Siehe github.com/zellerede/Ordered-Keyword-Args/tree/OrderedDict.
- Schön, Sie können pull-request auch dann, wenn Sie möchte.
- Dies beantwortet nicht die Frage, die über command-line-argument-parsing mit argparse, nicht über die Funktion Argumente.
InformationsquelleAutor igaurav
1

Ich brauchte das, weil, für logging-Zwecke, ich mochte drucken Sie die Argumente nach wurden Sie analysiert. Das problem war, dass die Argumente nicht in der angegebenen Reihenfolge gedruckt, das war wirklich nervig.

Benutzerdefinierte Aktion Klasse nur flat-out hat nicht funktioniert für mich. Ich hatte andere Argumente, die verwendet eine andere Aktion wie 'store_true' und default Argumente auch nicht funktionieren, da die benutzerdefinierten Aktion Klasse wird nicht aufgerufen, wenn das argument nicht gegeben ist, in der Befehlszeile. Was für mich gearbeitet wurde die Erstellung einer wrapper-Klasse wie folgt aus:
```
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
```
Die Profis sind, dass die add_argument Methode sollte die gleiche Funktionalität wie das original ArgumentParser. Die Nachteile sind, dass, wenn Sie möchten, dass andere Methoden, die Sie haben, um zu schreiben gewickelt für alle von Ihnen. Zum Glück für mich alle, die ich je benutzt wurde add_argument und parse_args, so ist dies diente meine Zwecke ziemlich gut. Sie würden auch brauchen, um mehr Arbeit erledigen, wenn Sie wollte übergeordneten ArgumentParsers.

InformationsquelleAutor Justin

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

ohne Verwendung orderedkwargs Modul

Auf mit orderedkwargs Modul