Mapowanie wartości w słowniku Pythona

Biorąc pod uwagę słownik, { k1: v1, k2: v2 ... }który chcę uzyskać, { k1: f(v1), k2: f(v2) ... }pod warunkiem, że podam funkcję f.

Czy jest taka wbudowana funkcja? Czy muszę to zrobić

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

Idealnie po prostu bym napisał

my_dictionary.map_values(f)

lub

my_dictionary.mutate_values_with(f)

Oznacza to, że nie ma dla mnie znaczenia, czy oryginalny słownik jest zmutowany, czy tworzona jest kopia.

Nie ma takiej funkcji; najłatwiej to zrobić, używając rozumienia dykta:

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

W Pythonie 2.7 użyj .iteritems()metody zamiast .items()oszczędzania pamięci. Składnia rozumienia dict została wprowadzona dopiero w Pythonie 2.7.

Zauważ, że nie ma takiej metody na listach; musiałbyś użyć rozumienia listy lub map()funkcji.

Jako taki, możesz również użyć map()funkcji do przetworzenia swojego nagrania:

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

ale tak naprawdę nie jest to tak czytelne.

Te narzędzia są idealne do tego rodzaju prostej, ale powtarzalnej logiki.

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

Daje ci dokładnie to, gdzie chcesz być.

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

toolz.valmap(f, my_list)

Możesz to zrobić w miejscu, zamiast tworzyć nowy słownik, co może być lepsze w przypadku dużych słowników (jeśli nie potrzebujesz kopii).

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)

skutkuje my_dictionaryzawartością:

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

Ze względu na PEP-0469, który zmienił nazwę iteritems () na items () i PEP-3113, który usunął rozpakowywanie parametrów Tuple , w Pythonie 3.x powinieneś napisać Martijn Pieters ♦ odpowiedz w ten sposób:

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

Chociaż moja pierwotna odpowiedź nie trafiła w sedno (próbując rozwiązać ten problem z rozwiązaniem klucza dostępu w fabryce defaultdict ), przerobiłem go, aby zaproponować faktyczne rozwiązanie obecnego pytania.

Oto on:

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

Stosowanie:

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

Chodzi o podklasę oryginalnego słownika, aby zapewnić mu pożądaną funkcjonalność: „mapowanie” funkcji na wszystkie wartości.

Plusem jest to, że słownik ten może być używany do przechowywania oryginalnych danych, tak jakby to był dict, podczas przekształcania dowolnych danych na żądanie za pomocą wywołania zwrotnego.

Oczywiście możesz nazwać klasę i funkcję tak, jak chcesz (nazwa wybrana w tej odpowiedzi jest inspirowana array_walk()funkcją PHP ).

Uwaga: Ani try- exceptblok ani returnstwierdzenia są obowiązkowe dla funkcjonalności, są tam do dalszego naśladować zachowanie PHP array_walk.

Aby uniknąć indeksowania od wewnątrz lambda, na przykład:

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

Możesz także:

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

Właśnie natknąłem się na ten przypadek użycia. Zaimplementowałem odpowiedź gensa , dodając rekurencyjne podejście do obsługi wartości, które również dyktują:

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)

Może to być przydatne w przypadku plików json lub yaml, które kodują ciągi jako bajty w Pythonie 2