Comment puis-je créer une sous-classe de dictionnaire robuste et flexible avec des clés minuscules à l'aide de classes de base abstraites ?

Implémentation d'une sous-classe de dictée « parfaite » avec ABC

Dans cet article, nous explorons comment créer une sous-classe sur mesure d'une dictée qui se comporte idéalement dans divers scénarios.

Le défi

Notre objectif est de construire une sous-classe de « dict » où les clés sont toujours présentes minuscule. Cette tâche apparemment simple nous oblige à remplacer soigneusement des méthodes spécifiques.

Remplacer les méthodes de manipulation de clés

Pour obtenir le comportement de clé souhaité, nous devons remplacer '__getitem__', '__setitem__' et ' Méthodes __delitem__'. En personnalisant ces méthodes, nous pouvons intercepter les interactions clés et appliquer la transformation en minuscules.

Transformation minimale avec ABC

Au lieu de sous-classer directement « dict », nous pouvons exploiter les ABC (classes de base abstraites) de le module 'collections.abc'. Cette approche offre une implémentation plus propre et plus robuste.

En implémentant l'ABC 'MutableMapping', nous garantissons le respect de l'interface dict. L'extrait de code suivant fournit une implémentation minimale de notre dictionnaire transformé :

from collections.abc import MutableMapping

class TransformedDict(MutableMapping):
    def __init__(self, *args, **kwargs):
        self.store = dict()
        self.update(dict(*args, **kwargs))

    def __getitem__(self, key):
        return self.store[self._keytransform(key)]

    def __setitem__(self, key, value):
        self.store[self._keytransform(key)] = value

    def __delitem__(self, key):
        del self.store[self._keytransform(key)]

    def __iter__(self):
        return iter(self.store)

    def __len__(self):
        return len(self.store)

    def _keytransform(self, key):
        return key

Logique de transformation des clés

La méthode '_keytransform' est chargée d'appliquer la transformation souhaitée aux clés. Dans notre cas, il renvoie simplement la clé en minuscule :

def _keytransform(self, key):
    return key.lower()

Héritage et extension

Pour utiliser notre dictionnaire transformé, nous pouvons sous-classer 'TransformedDict' et spécifier la transformation de clé souhaitée dans le Méthode '_keytransform'. Par exemple :

class MyTransformedDict(TransformedDict):

    def _keytransform(self, key):
        return key.lower()

s = MyTransformedDict([('Test', 'test')])

assert s.get('TEST') is s['test']   # free get
assert 'TeSt' in s                  # free __contains__

Pickling and Beyond

Le 'TransformedDict' implémenté fonctionne avec pickle, grâce à sa dépendance à l'égard d'un dict standard en interne.

Il est important de notez que le sous-classement direct de « dict » n'est généralement pas recommandé, car cela peut conduire à un comportement inattendu. En utilisant les ABC, nous pouvons créer des sous-classes robustes et flexibles qui adhèrent à l'interface souhaitée, dans ce cas, celle d'un « MutableMapping ».

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!