Mapeando sobre valores em um dicionário python

Dado um dicionário, { k1: v1, k2: v2 ... }eu quero obter { k1: f(v1), k2: f(v2) ... }desde que eu passe uma função f.

Existe alguma função incorporada? Ou eu tenho que fazer

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

Idealmente, eu apenas escreveria

my_dictionary.map_values(f)

ou

my_dictionary.mutate_values_with(f)

Ou seja, não me interessa se o dicionário original está mutado ou se uma cópia é criada.

Não existe essa função; a maneira mais fácil de fazer isso é usar uma compreensão de ditado:

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

No python 2.7, use o .iteritems()método em vez de .items()economizar memória. A sintaxe de compreensão de ditados não foi introduzida até o python 2.7.

Observe que também não existe esse método nas listas; você precisaria usar uma compreensão de lista ou a map()função.

Como tal, você também pode usar a map()função para processar seu dict:

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

mas isso não é legível, na verdade.

Essas ferramentas são ótimas para esse tipo de lógica simples, mas repetitiva.

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

Leva você exatamente onde você quer estar.

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

toolz.valmap(f, my_list)

Você pode fazer isso no local, em vez de criar um novo ditado, que pode ser preferível para dicionários grandes (se você não precisar de uma cópia).

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 em my_dictionaryconter:

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

Devido ao PEP-0469, que renomeou iteritems () para items (), e PEP-3113, que removeu a descompactação do parâmetro Tuple , no Python 3.x, você deve escrever Martijn Pieters .

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

Embora minha resposta original tenha falhado o ponto (tentando resolver esse problema com a solução para acessar a chave na fábrica do padrão ), eu a refiz para propor uma solução real para a presente pergunta.

Aqui 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)

A idéia é subclassificar o ditado original para fornecer a funcionalidade desejada: "mapear" uma função sobre todos os valores.

O ponto positivo é que esse dicionário pode ser usado para armazenar os dados originais como se fossem dict, enquanto transforma qualquer dado sob solicitação com um retorno de chamada.

Obviamente, sinta-se à vontade para nomear a classe e a função da maneira que desejar (o nome escolhido nesta resposta é inspirado na array_walk()função do PHP ).

Nota: Nem o bloco try- exceptnem as returninstruções são obrigatórias para a funcionalidade, elas existem para imitar ainda mais o comportamento do PHP array_walk.

Para evitar a indexação de dentro do lambda, como:

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

Você também pode fazer:

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

Apenas veio através deste caso de uso. Eu implementei a resposta de gens , adicionando uma abordagem recursiva para lidar com valores que também são ditados:

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)

Isso pode ser útil ao lidar com arquivos json ou yaml que codificam cadeias de caracteres como bytes no Python 2