Mappage de valeurs dans un dictionnaire python

Étant donné un dictionnaire que { k1: v1, k2: v2 ... }je veux obtenir, { k1: f(v1), k2: f(v2) ... }je passe une fonction f.

Existe-t-il une telle fonction intégrée? Ou dois-je faire

dict([(k, f(v)) for (k, v) in my_dictionary.iteritems()])

Idéalement, j'écrirais

my_dictionary.map_values(f)

ou

my_dictionary.mutate_values_with(f)

Autrement dit, peu importe que le dictionnaire d'origine soit muté ou qu'une copie soit créée.

Il n'y a pas une telle fonction; la façon la plus simple de le faire est d'utiliser une compréhension dict:

my_dictionary = {k: f(v) for k, v in my_dictionary.items()}

En python 2.7, utilisez la .iteritems()méthode au lieu de .items()pour économiser de la mémoire. La syntaxe de compréhension de dict n'a pas été introduite avant Python 2.7.

Notez qu'il n'y a pas non plus une telle méthode sur les listes; il faudrait utiliser une compréhension de liste ou la map()fonction.

En tant que tel, vous pouvez également utiliser la map()fonction pour traiter votre dict:

my_dictionary = dict(map(lambda kv: (kv[0], f(kv[1])), my_dictionary.iteritems()))

mais ce n'est pas vraiment lisible.

Ces outils sont parfaits pour ce type de logique simple mais répétitive.

http://toolz.readthedocs.org/en/latest/api.html#toolz.dicttoolz.valmap

Vous amène là où vous voulez être.

import toolz
def f(x):
  return x+1

toolz.valmap(f, my_list)

Vous pouvez le faire sur place, plutôt que de créer un nouveau dict, ce qui peut être préférable pour les grands dictionnaires (si vous n'avez pas besoin d'une copie).

def mutate_dict(f,d):
    for k, v in d.iteritems():
        d[k] = f(v)

my_dictionary = {'a':1, 'b':2}
mutate_dict(lambda x: x+1, my_dictionary)

résulte en my_dictionarycontenant:

{'a': 2, 'b': 3}

En raison de PEP-0469 qui a renommé iteritems () en items () et PEP-3113 qui a supprimé le décompactage des paramètres Tuple , dans Python 3.x, vous devriez écrire Martijn Pieters ♦ répondre comme ceci:

my_dictionary = dict(map(lambda item: (item[0], f(item[1])), my_dictionary.items()))

Bien que ma réponse d'origine ait manqué le point (en essayant de résoudre ce problème avec la solution de la clé d'accès dans l'usine de defaultdict ), je l'ai retravaillée pour proposer une solution réelle à la présente question.

C'est ici:

class walkableDict(dict):
  def walk(self, callback):
    try:
      for key in self:
        self[key] = callback(self[key])
    except TypeError:
      return False
    return True

Usage:

>>> d = walkableDict({ k1: v1, k2: v2 ... })
>>> d.walk(f)

L'idée est de sous-classer le dict original pour lui donner la fonctionnalité souhaitée: "mapper" une fonction sur toutes les valeurs.

Le point positif est que ce dictionnaire peut être utilisé pour stocker les données d'origine comme s'il s'agissait d'un dict, tout en transformant toutes les données sur demande avec un rappel.

Bien sûr, n'hésitez pas à nommer la classe et la fonction comme vous le souhaitez (le nom choisi dans cette réponse est inspiré par la array_walk()fonction de PHP ).

Remarque: Ni le bloc try- exceptni les returninstructions ne sont obligatoires pour la fonctionnalité, ils sont là pour imiter davantage le comportement des PHP array_walk.

Pour éviter de faire de l'indexation à l'intérieur de lambda, comme:

rval = dict(map(lambda kv : (kv[0], ' '.join(kv[1])), rval.iteritems()))

Vous pouvez également faire:

rval = dict(map(lambda(k,v) : (k, ' '.join(v)), rval.iteritems()))

Je viens juste de traverser ce cas d'utilisation. J'ai implémenté la réponse de gens , en ajoutant une approche récursive pour gérer les valeurs qui sont également des dict:

def mutate_dict_in_place(f, d):
    for k, v in d.iteritems():
        if isinstance(v, dict):
            mutate_dict_in_place(f, v)
        else:
            d[k] = f(v)

# Exemple handy usage
def utf8_everywhere(d):
    mutate_dict_in_place((
        lambda value:
            value.decode('utf-8')
            if isinstance(value, bytes)
            else value
        ),
        d
    )

my_dict = {'a': b'byte1', 'b': {'c': b'byte2', 'd': b'byte3'}}
utf8_everywhere(my_dict)
print(my_dict)

Cela peut être utile lorsque vous traitez des fichiers json ou yaml qui codent des chaînes en octets dans Python 2