C'è un modo intelligente per passare la chiave al default_factory di defaultdict?

Una classe ha un costruttore che accetta un parametro:

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

Da qualche parte nel codice, è utile che i valori in un dict conoscano le loro chiavi.
Voglio usare un defaultdict con la chiave passata ai valori predefiniti del neonato:

d = defaultdict(lambda : C(here_i_wish_the_key_to_be))

Eventuali suggerimenti?

Difficilmente si qualifica come intelligente , ma la sottoclasse è tua amica:

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)

No non c'è.

La defaultdictrealizzazione non può essere configurato per passare mancanti keyal default_factoryout-of-the-box. La tua unica opzione è implementare la tua defaultdictsottoclasse, come suggerito da @JochenRitzel, sopra.

Ma questo non è "intelligente" o quasi pulito come sarebbe una soluzione di libreria standard (se esistesse). Quindi la risposta alla tua domanda succinta, sì / no è chiaramente "No".

Peccato che alla libreria standard manchi uno strumento così spesso necessario.

Non penso che tu abbia affatto bisogno di defaultdictqui. Perché non usare solo il dict.setdefaultmetodo?

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

Questo ovviamente creerà molte istanze di C. Nel caso si tratti di un problema, penso che l'approccio più semplice farà:

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

Sarebbe più veloce di defaultdicto di qualsiasi altra alternativa per quanto posso vedere.

ETA relativo alla velocità del intest rispetto all'utilizzo della clausola try-tranne:

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

Ecco un esempio funzionante di un dizionario che aggiunge automaticamente un valore. L'attività dimostrativa nella ricerca di file duplicati in / usr / include. Nota che il dizionario di personalizzazione PathDict richiede solo quattro righe:

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