Mappatura su valori in un dizionario Python

Dato un dizionario { k1: v1, k2: v2 ... }che desidero ricevere, { k1: f(v1), k2: f(v2) ... }passo una funzione f.

Esiste una tale funzione integrata? O devo farlo

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

Idealmente vorrei solo scrivere

my_dictionary.map_values(f)

o

my_dictionary.mutate_values_with(f)

Cioè, non mi importa se il dizionario originale è mutato o se ne viene creata una copia.

Non esiste una tale funzione; il modo più semplice per farlo è usare una comprensione dettata:

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

In Python 2.7, utilizzare il .iteritems()metodo anziché .items()per risparmiare memoria. La sintassi di comprensione del dict non è stata introdotta fino a Python 2.7.

Si noti che non esiste nemmeno un metodo simile negli elenchi; dovresti usare un elenco di comprensione o la map()funzione.

Pertanto, puoi utilizzare la map()funzione anche per elaborare il tuo dict:

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

ma non è così leggibile, davvero.

Questi toolz sono fantastici per questo tipo di logica semplice ma ripetitiva.

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

Ti porta esattamente dove vuoi essere.

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

toolz.valmap(f, my_list)

Puoi farlo sul posto, piuttosto che creare un nuovo dict, che può essere preferibile per dizionari di grandi dimensioni (se non hai bisogno di una copia).

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)

risulta nel my_dictionarycontenere:

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

A causa di PEP-0469 che ha ribattezzato iteritems () in items () e PEP-3113 che hanno rimosso la decompressione dei parametri Tuple , in Python 3.x dovresti scrivere Martijn Pieters ♦ rispondi in questo modo:

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

Mentre la mia risposta originale ha mancato il punto (cercando di risolvere questo problema con la soluzione di accesso alla chiave in fabbrica di defaultdict ), l'ho rielaborata per proporre una soluzione effettiva alla domanda attuale.

Ecco qui:

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

Uso:

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

L'idea è di sottoclassare il dict originale per dargli la funzionalità desiderata: "mappare" una funzione su tutti i valori.

Il punto positivo è che questo dizionario può essere utilizzato per archiviare i dati originali come se fosse a dict, trasformando al contempo tutti i dati su richiesta con un callback.

Naturalmente, sentiti libero di nominare la classe e la funzione nel modo desiderato (il nome scelto in questa risposta è ispirato alla array_walk()funzione di PHP ).

Nota: Né il blocco try- exceptné le returnistruzioni sono obbligatorie per la funzionalità, sono lì per imitare ulteriormente il comportamento dei PHP array_walk.

Per evitare di indicizzare dall'interno di lambda, come:

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

Puoi anche fare:

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

Sono appena arrivato in questo caso d'uso. Ho implementato la risposta di Gens , aggiungendo un approccio ricorsivo per la gestione di valori che sono anche dicts:

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)

Questo può essere utile quando si ha a che fare con file json o yaml che codificano stringhe come byte in Python 2