Python argparse dict arg

Voici une autre solution à l'aide d'un action personnalisée, si vous souhaitez spécifier dict ensemble des paires de clés séparés par des virgules --

import argparse
import sys
parser = argparse.ArgumentParser(description='parse key pairs into a dictionary')

class StoreDictKeyPair(argparse.Action):
     def __call__(self, parser, namespace, values, option_string=None):
         my_dict = {}
         for kv in values.split(","):
             k,v = kv.split("=")
             my_dict[k] = v
         setattr(namespace, self.dest, my_dict)

parser.add_argument("--key_pairs", dest="my_dict", action=StoreDictKeyPair, metavar="KEY1=VAL1,KEY2=VAL2...")

args = parser.parse_args(sys.argv[1:])
print args

En cours d'exécution:

python parse_kv.py --key_pairs 1=2,a=bbb,c=4 --key_pairs test=7,foo=bar

De sortie:

Namespace(my_dict={'1': '2', 'a': 'bbb', 'c': '4', 'test': '7', 'foo': 'bar'})

Si vous souhaitez utiliser nargs au lieu d'séparées par des virgules:

class StoreDictKeyPair(argparse.Action):
     def __init__(self, option_strings, dest, nargs=None, **kwargs):
         self._nargs = nargs
         super(StoreDictKeyPair, self).__init__(option_strings, dest, nargs=nargs, **kwargs)
     def __call__(self, parser, namespace, values, option_string=None):
         my_dict = {}
         print "values: {}".format(values)
         for kv in values:
             k,v = kv.split("=")
             my_dict[k] = v
         setattr(namespace, self.dest, my_dict)

parser.add_argument("--key_pairs", dest="my_dict", action=StoreDictKeyPair, nargs="+", metavar="KEY=VAL)

args = parser.parse_args(sys.argv[1:])
print args

De course

python arg_test4.py --key_pairs 1=2 a=bbb c=4 test=7 foo=bar

Sorties:

values: ['1=2', 'a=bbb', 'c=4', 'test=7', 'foo=bar']
Namespace(my_dict={'1': '2', 'a': 'bbb', 'c': '4', 'test': '7', 'foo': 'bar'})

OriginalL'auteur

Python reçoit des arguments sous la forme d'un tableau argv. Vous pouvez l'utiliser pour créer le dictionnaire dans le programme lui-même.

import sys
my_dict = {}
for arg in sys.argv[1:]:
    key, val=arg.split(':')[0], arg.split(':')[1]
    my_dict[key]=val

print my_dict

Pour la ligne de commande:

python program.py key1:val1 key2:val2 key3:val3

De sortie:

my_dict = {'key3': 'val3', 'key2': 'val2', 'key1': 'val1'}

Remarque: args sera en chaîne, de sorte que vous aurez à les convertir pour stocker des valeurs numériques.

J'espère que cela aide.

OriginalL'auteur

Directement de l'analyse d'une entrée comme:

program.py --dict d --key key1 --value val1 --key key2 --value val2

est:

parser=argparse.ArgumentParser()
parser.add_argument('--dict')
parser.add_argument('--key', action='append')
parser.add_argument('--value', action='append')
args = parser.parse_args()

qui devrait produire (si mon mental de l'analyseur est correct)

args = Namespace(dict='d', key=['key1','key2'], value=['value1','value2'])

Vous devriez être en mesure de construire un dictionnaire de que avec:

adict = {k:v for k, v in zip(args.key, args.value)}

À l'aide de args.dict à assigner à une variable de ce nom nécessite des nations unies-python supercherie. Le mieux serait de créer un élément dans un autre dictionnaire avec ce nom.

another_dict = {args.dict: adict}

Cette solution ne permet plus d'effectuer beaucoup de vérification d'erreur. Par exemple, il n'est pas assurez-vous qu'il y a le même nombre de clés et de valeurs. Elle aussi ne serait pas vous permettre de créer plusieurs dictionnaires (c'est à dire répétées --dict arguments). Il ne nécessite pas une ordonnance spéciale. --dict pourrait se produire après un --key key1 paire. Plusieurs --value arguments pourraient être ensemble.

Liant les key=value ensemble comme chepner ne reçoit autour d'un certain nombre de ces problèmes.

OriginalL'auteur