Gibt es eine clevere Möglichkeit, den Schlüssel an die default_factory von defaultdict zu übergeben?

Eine Klasse hat einen Konstruktor, der einen Parameter akzeptiert:

class C(object):
    def __init__(self, v):
        self.v = v
        ...

Irgendwo im Code ist es nützlich, dass Werte in einem Diktat ihre Schlüssel kennen.
Ich möchte ein Standarddiktat mit dem Schlüssel verwenden, der an neugeborene Standardwerte übergeben wird:

d = defaultdict(lambda : C(here_i_wish_the_key_to_be))

Irgendwelche Vorschläge?

Es qualifiziert sich kaum als klug - aber Unterklassen sind dein Freund:

class keydefaultdict(defaultdict):
    def __missing__(self, key):
        if self.default_factory is None:
            raise KeyError( key )
        else:
            ret = self[key] = self.default_factory(key)
            return ret

d = keydefaultdict(C)
d[x] # returns C(x)

Nein, da ist kein.

Die defaultdictImplementierung kann nicht so konfiguriert werden, dass sie fehlend keyan den default_factoryStandard übergeben wird. Sie können nur Ihre eigene defaultdictUnterklasse implementieren , wie oben von @JochenRitzel vorgeschlagen.

Aber das ist nicht "klug" oder fast so sauber wie eine Standardbibliothekslösung (falls vorhanden). Somit lautet die Antwort auf Ihre prägnante Ja / Nein-Frage eindeutig "Nein".

Es ist schade, dass in der Standardbibliothek ein so häufig benötigtes Tool fehlt.

Ich glaube nicht, dass du defaultdicthier überhaupt brauchst . Warum nicht einfach die dict.setdefaultMethode anwenden?

>>> d = {}
>>> d.setdefault('p', C('p')).v
'p'

Das würde natürlich viele Instanzen von schaffen C. Falls es sich um ein Problem handelt, reicht meiner Meinung nach der einfachere Ansatz aus:

>>> d = {}
>>> if 'e' not in d: d['e'] = C('e')

defaultdictSoweit ich sehen kann, wäre es schneller als die oder eine andere Alternative.

ETA in Bezug auf die inTestgeschwindigkeit im Vergleich zur Verwendung der Try-Except-Klausel:

>>> def g():
    d = {}
    if 'a' in d:
        return d['a']


>>> timeit.timeit(g)
0.19638929363557622
>>> def f():
    d = {}
    try:
        return d['a']
    except KeyError:
        return


>>> timeit.timeit(f)
0.6167065411074759
>>> def k():
    d = {'a': 2}
    if 'a' in d:
        return d['a']


>>> timeit.timeit(k)
0.30074866358404506
>>> def p():
    d = {'a': 2}
    try:
        return d['a']
    except KeyError:
        return


>>> timeit.timeit(p)
0.28588609450770264

Hier ist ein funktionierendes Beispiel für ein Wörterbuch, das automatisch einen Wert hinzufügt. Die Demonstrationsaufgabe beim Suchen doppelter Dateien in / usr / include. Beachten Sie, dass das benutzerdefinierte Wörterbuch PathDict nur vier Zeilen benötigt:

class FullPaths:

    def __init__(self,filename):
        self.filename = filename
        self.paths = set()

    def record_path(self,path):
        self.paths.add(path)

class PathDict(dict):

    def __missing__(self, key):
        ret = self[key] = FullPaths(key)
        return ret

if __name__ == "__main__":
    pathdict = PathDict()
    for root, _, files in os.walk('/usr/include'):
        for f in files:
            path = os.path.join(root,f)
            pathdict[f].record_path(path)
    for fullpath in pathdict.values():
        if len(fullpath.paths) > 1:
            print("{} located in {}".format(fullpath.filename,','.join(fullpath.paths)))