Existe-t-il un moyen intelligent de transmettre la clé à defaultdict's default_factory?

Une classe a un constructeur qui prend un paramètre:

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

Quelque part dans le code, il est utile pour les valeurs d'un dict de connaître leurs clés.
Je souhaite utiliser un defaultdict avec la clé transmise aux valeurs par défaut du nouveau-né:

d = defaultdict(lambda : C(here_i_wish_the_key_to_be))

Aucune suggestion?

Cela n'est guère considéré comme intelligent - mais le sous- classement est votre ami:

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)

Non, il n'y en a pas.

L' defaultdictimplémentation ne peut pas être configurée pour transmettre les données manquantes keyau prêt à l' default_factoryemploi. Votre seule option est d'implémenter votre propre defaultdictsous-classe, comme suggéré par @JochenRitzel, ci-dessus.

Mais ce n'est pas «intelligent» ou presque aussi propre qu'une solution de bibliothèque standard le serait (si elle existait). Ainsi, la réponse à votre question succincte oui / non est clairement «non».

C'est dommage que la bibliothèque standard ne dispose pas d'un outil aussi souvent nécessaire.

Je ne pense pas que vous ayez besoin defaultdictici du tout. Pourquoi ne pas simplement utiliser la dict.setdefaultméthode?

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

Cela créerait bien sûr de nombreux exemples de C. Au cas où c'est un problème, je pense que l'approche la plus simple fera l'affaire:

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

Ce serait plus rapide que la defaultdictou toute autre alternative pour autant que je sache.

ETA concernant la vitesse du intest par rapport à l'utilisation de la clause try-except:

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

Voici un exemple fonctionnel d'un dictionnaire qui ajoute automatiquement une valeur. La tâche de démonstration pour trouver des fichiers en double dans / usr / include. Notez que le dictionnaire personnalisé PathDict ne nécessite que quatre lignes:

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