Zuordnung von Werten in einem Python-Wörterbuch

Wenn { k1: v1, k2: v2 ... }ich ein Wörterbuch habe, das ich erhalten möchte, übergebe { k1: f(v1), k2: f(v2) ... }ich eine Funktion f.

Gibt es eine solche eingebaute Funktion? Oder muss ich tun

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

Im Idealfall würde ich einfach schreiben

my_dictionary.map_values(f)

oder

my_dictionary.mutate_values_with(f)

Das heißt, es ist mir egal, ob das ursprüngliche Wörterbuch mutiert oder eine Kopie erstellt wird.

Es gibt keine solche Funktion; Der einfachste Weg, dies zu tun, besteht darin, ein Diktatverständnis zu verwenden:

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

Verwenden Sie in Python 2.7 die .iteritems()Methode .items(), um Speicherplatz zu sparen. Die Diktatverständnis-Syntax wurde erst in Python 2.7 eingeführt.

Beachten Sie, dass es in Listen auch keine solche Methode gibt. Sie müssten ein Listenverständnis oder die map()Funktion verwenden.

Daher können Sie die map()Funktion auch zur Verarbeitung Ihres Diktats verwenden:

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

aber das ist wirklich nicht so lesbar.

Diese Tools eignen sich hervorragend für diese Art von einfacher, aber sich wiederholender Logik.

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

Bringt Sie genau dahin, wo Sie sein möchten.

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

toolz.valmap(f, my_list)

Sie können dies direkt tun, anstatt ein neues Diktat zu erstellen, was für große Wörterbücher vorzuziehen ist (wenn Sie keine Kopie benötigen).

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)

führt zu folgenden my_dictionary:

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

Aufgrund von PEP-0469, das iteritems () in items () umbenannte, und PEP-3113, das das Entpacken von Tuple-Parametern entfernte , sollten Sie in Python 3.x Martijn Pieters ♦ Antwort wie folgt schreiben :

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

Während meine ursprüngliche Antwort den Punkt verfehlt hat (indem ich versucht habe, dieses Problem mit der Lösung für den Zugriff auf den Schlüssel in der Factory of DefaultDict zu lösen ), habe ich sie überarbeitet, um eine tatsächliche Lösung für die vorliegende Frage vorzuschlagen.

Hier ist es:

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

Verwendung:

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

Die Idee ist, das ursprüngliche Diktat in Unterklassen zu unterteilen, um ihm die gewünschte Funktionalität zu geben: eine Funktion über alle Werte "abzubilden".

Der Pluspunkt ist, dass dieses Wörterbuch verwendet werden kann, um die Originaldaten so zu speichern, als ob es eine wäre dict, während alle Daten auf Anfrage mit einem Rückruf transformiert werden.

Natürlich können Sie die Klasse und die Funktion beliebig benennen (der in dieser Antwort gewählte Name ist von der PHP- array_walk()Funktion inspiriert ).

Hinweis: Weder der try- exceptBlock noch die returnAnweisungen sind für die Funktionalität obligatorisch, sie dienen dazu, das Verhalten der PHPs weiter nachzuahmen array_walk.

Um eine Indizierung innerhalb von Lambda zu vermeiden, gehen Sie wie folgt vor:

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

Sie können auch tun:

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

Gerade über diesen Anwendungsfall gekommen. Ich habe die Antwort von gens implementiert und einen rekursiven Ansatz für den Umgang mit Werten hinzugefügt, die auch Diktate sind:

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)

Dies kann nützlich sein, wenn Sie mit JSON- oder YamL-Dateien arbeiten, die Zeichenfolgen in Python 2 als Bytes codieren