Asignación de valores en un diccionario de Python

Dado un diccionario { k1: v1, k2: v2 ... }que quiero obtener { k1: f(v1), k2: f(v2) ... }siempre que pase una función f.

¿Existe alguna función incorporada? O tengo que hacer

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

Lo ideal sería escribir

my_dictionary.map_values(f)

o

my_dictionary.mutate_values_with(f)

Es decir, no me importa si el diccionario original está mutado o si se crea una copia.

No hay tal función; La forma más fácil de hacer esto es usar una comprensión dict:

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

En python 2.7, use el .iteritems()método en lugar de .items()guardar memoria. La sintaxis de comprensión dict no se introdujo hasta Python 2.7.

Tenga en cuenta que tampoco existe tal método en las listas; tendrías que usar una lista de comprensión o la map()función.

Como tal, también podría usar la map()función para procesar su dict:

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

pero eso no es tan legible, de verdad.

Estas herramientas son excelentes para este tipo de lógica simple pero repetitiva.

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

Te lleva justo donde quieres estar.

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

toolz.valmap(f, my_list)

Puede hacer esto en el lugar, en lugar de crear un nuevo dict, que puede ser preferible para diccionarios grandes (si no necesita 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)

resulta en my_dictionarycontener:

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

Debido a PEP-0469 que renombró iteritems () a items () y PEP-3113 que eliminó el desempaquetado de parámetros Tuple , en Python 3.x debería escribir Martijn Pieters ♦ responda así:

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

Si bien mi respuesta original perdió el punto (al tratar de resolver este problema con la solución para acceder a la clave en la fábrica de defaultdict ), la modifiqué para proponer una solución real a la presente pregunta.

Aquí está:

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)

La idea es subclasificar el dict original para darle la funcionalidad deseada: "mapear" una función sobre todos los valores.

El punto a favor es que este diccionario se puede usar para almacenar los datos originales como si fuera un dict, mientras se transforma cualquier dato a pedido con una devolución de llamada.

Por supuesto, siéntase libre de nombrar la clase y la función de la manera que desee (el nombre elegido en esta respuesta está inspirado en la array_walk()función de PHP ).

Nota: Ni el bloque try- exceptni las returndeclaraciones son obligatorias para la funcionalidad, están ahí para imitar aún más el comportamiento de los PHP array_walk.

Para evitar la indexación desde el interior de lambda, como:

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

También puedes hacer:

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

Acabo de encontrar este caso de uso. Implementé la respuesta de gens , agregando un enfoque recursivo para manejar valores que también son dictados:

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)

Esto puede ser útil cuando se trata de archivos json o yaml que codifican cadenas como bytes en Python 2