Comment sous-classer correctement dict et surcharger __getitem__ & __setitem__ ?

Question

Je suis en train de déboguer un code et je veux savoir quand un dictionnaire particulier est consulté. En fait, il s'agit d'une classe qui sous-classe dict et met en œuvre quelques fonctionnalités supplémentaires. Quoi qu'il en soit, ce que j'aimerais faire, c'est sous-classer dict et ajoutez une dérogation __getitem__ y __setitem__ pour produire des résultats de débogage. Pour l'instant, j'ai

class DictWatch(dict):
    def __init__(self, *args):
        dict.__init__(self, args)

    def __getitem__(self, key):
        val = dict.__getitem__(self, key)
        log.info("GET %s['%s'] = %s" % str(dict.get(self, 'name_label')), str(key), str(val)))
        return val

    def __setitem__(self, key, val):
        log.info("SET %s['%s'] = %s" % str(dict.get(self, 'name_label')), str(key), str(val)))
        dict.__setitem__(self, key, val)

'name_label' est une clé qui sera éventuellement définie et que je souhaite utiliser pour identifier la sortie. J'ai ensuite modifié la classe que j'instrumente pour qu'elle devienne la sous-classe DictWatch au lieu de dict et a modifié l'appel au superconstructeur. Pourtant, rien ne semble se passer. Je pensais être malin, mais je me demande si je ne devrais pas prendre une autre direction.

Merci pour votre aide !

Answer 1

Un autre problème se pose lorsque l'on sous-classe dict est que le système intégré de __init__ n'appelle pas update et le système intégré update n'appelle pas __setitem__ . Ainsi, si vous voulez que toutes les opérations setitem passent par votre __setitem__ vous devez vous assurer qu'elle est appelée par vous-même :

class DictWatch(dict):
    def __init__(self, *args, **kwargs):
        self.update(*args, **kwargs)

    def __getitem__(self, key):
        val = dict.__getitem__(self, key)
        print('GET', key)
        return val

    def __setitem__(self, key, val):
        print('SET', key, val)
        dict.__setitem__(self, key, val)

    def __repr__(self):
        dictrepr = dict.__repr__(self)
        return '%s(%s)' % (type(self).__name__, dictrepr)

    def update(self, *args, **kwargs):
        print('update', args, kwargs)
        for k, v in dict(*args, **kwargs).items():
            self[k] = v

Answer 2

Ce que vous faites devrait absolument fonctionner. J'ai testé votre classe et, à part une parenthèse ouvrante manquante dans vos déclarations, elle fonctionne parfaitement. Il n'y a que deux choses auxquelles je peux penser. Tout d'abord, la sortie de votre déclaration de journal est-elle correctement définie ? Vous pourriez avoir besoin de mettre un logging.basicConfig(level=logging.DEBUG) au début de votre script.

Deuxièmement, __getitem__ y __setitem__ ne sont appelées que pendant les [] accès. Veillez donc à n'accéder qu'aux DictWatch via d[key] plutôt que d.get() y d.set()

Answer 3

Envisager une sous-classe UserDict o UserList . Ces classes sont destinées à être sous-classées alors que la classe normale dict y list ne le sont pas et contiennent des optimisations.

Answer 4

Cela ne devrait pas vraiment changer le résultat (qui devrait fonctionner, pour de bonnes valeurs de seuil d'enregistrement) : votre init devrait être :

def __init__(self,*args,**kwargs) : dict.__init__(self,*args,**kwargs) 

car si vous appelez votre méthode avec DictWatch([(1,2),(2,3)]) ou DictWatch(a=1,b=2), cela échouera.

(ou, mieux, ne pas définir de constructeur pour cela)

Answer 5

En tant que Réponse d'Andrew Pate proposé, sous-classement collections.UserDict au lieu de dict est beaucoup moins sujette aux erreurs.

Voici un exemple montrant un problème lorsque l'on hérite de dict naïvement :

class MyDict(dict):

  def __setitem__(self, key, value):
    super().__setitem__(key, value * 10)

d = MyDict(a=1, b=2)  # Bad! MyDict.__setitem__ not called
d.update(c=3)  # Bad! MyDict.__setitem__ not called
d['d'] = 4  # Good!
print(d)  # {'a': 1, 'b': 2, 'c': 3, 'd': 40}

UserDict hérite de collections.abc.MutableMapping Cela fonctionne donc comme prévu :

class MyDict(collections.UserDict):

  def __setitem__(self, key, value):
    super().__setitem__(key, value * 10)

d = MyDict(a=1, b=2)  # Good: MyDict.__setitem__ correctly called
d.update(c=3)  # Good: MyDict.__setitem__ correctly called
d['d'] = 4  # Good
print(d)  # {'a': 10, 'b': 20, 'c': 30, 'd': 40}

De même, il suffit de mettre en œuvre __getitem__ pour être automatiquement compatible avec key in my_dict , my_dict.get ,

Remarque : UserDict es no une sous-classe de dict Ainsi isinstance(UserDict(), dict) échouera (mais isinstance(UserDict(), collections.abc.MutableMapping) fonctionnera).