Comment les classes de base abstraites peuvent-elles aider à remplacer parfaitement le comportement d'un dictionnaire ?

Remplacer parfaitement un dict : un guide utilisant des classes de base abstraites

Lors de la création d'une sous-classe du type dict intégré, obtenir un résultat sans faille la mise en œuvre peut être difficile. Au lieu de remplacer toute la classe dict, envisagez d'adopter une approche alternative en utilisant les classes de base abstraites (ABC) du module collections.abc.

Utilisation de MutableMapping ABC

Le MutableMapping ABC fournit une interface pour les classes qui se comportent comme des dictionnaires mutables. En implémentant cette interface, vous pouvez créer un objet qui se comporte comme un dict sans le sous-classer directement. Voici un exemple minimal :

from collections.abc import MutableMapping

class TransformedDict(MutableMapping):
    def __init__(self, *args, **kwargs):
        self.store = dict()
        self.update(dict(*args, **kwargs))  # use the free update to set keys

    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

Cette implémentation fournit une base pour manipuler les clés via la méthode _keytransform. En remplaçant cette méthode dans les sous-classes, vous pouvez appliquer des transformations personnalisées aux clés.

Avantages de l'utilisation des ABC

La mise en œuvre de l'interface MutableMapping offre plusieurs avantages :

• Exhaustivité : L'ABC s'assure que vous avez mis en œuvre toutes les méthodes requises pour un dictionnaire mutable.
• Validation automatique : L'ABC vérifie si vous avez implémenté toutes les méthodes requises, vous permettant ainsi de détecter très tôt les implémentations manquantes.
• Méthodes intégrées : Vous accédez automatiquement à des méthodes telles que get, setdefault, pop et autres sans avoir besoin de les implémenter vous-même.

Exemple d'utilisation

Créer une sous-classe de TransformedDict et définir la méthode _keytransform vous permet de personnaliser la gestion des clés :

class MyTransformedDict(TransformedDict):
    def _keytransform(self, key):
        return key.lower()

s = MyTransformedDict([('Test', 'test')])
assert s.get('TEST') is s['test']
assert 'TeSt' in s

Cette sous-classe permet un accès aux clés insensible à la casse et récupération.

Notes supplémentaires

• Le pickling fonctionne de manière transparente avec cette approche, car vous travaillez essentiellement avec un dict régulier en interne.
• Il Il n'est généralement pas conseillé de sous-classer directement les types intégrés comme dict, car cela peut prêter à confusion et à des erreurs inattendues. comportement.
• L'utilisation des ABC fournit une solution propre et extensible pour créer des objets qui implémentent des interfaces spécifiques.

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!