Wie kann ich mithilfe abstrakter Basisklassen eine robuste und flexible Wörterbuchunterklasse mit Kleinbuchstaben erstellen?

Implementieren einer „perfekten“ Diktunterklasse mit ABCs

In diesem Artikel untersuchen wir, wie man eine maßgeschneiderte Unterklasse eines Diktats erstellt, die sich in verschiedenen Szenarien ideal verhält.

Die Herausforderung

Unser Ziel ist es, eine Unterklasse von „dict“ zu konstruieren, in der sich die Schlüssel immer befinden in Kleinbuchstaben. Diese scheinbar einfache Aufgabe erfordert, dass wir bestimmte Methoden sorgfältig überschreiben.

Schlüsselmanipulationsmethoden überschreiben

Um das gewünschte Schlüsselverhalten zu erreichen, müssen wir „__getitem__“, „__setitem__“ und „ __delitem__'-Methoden. Durch die Anpassung dieser Methoden können wir wichtige Interaktionen abfangen und die Kleinbuchstabentransformation erzwingen.

Minimale Transformation mit ABCs

Anstatt „dict“ direkt in Unterklassen zu unterteilen, können wir ABCs (Abstract Base Classes) von nutzen das Modul „collections.abc“. Dieser Ansatz bietet eine sauberere und robustere Implementierung.

Durch die Implementierung des „MutableMapping“-ABC stellen wir die Einhaltung der dict-Schnittstelle sicher. Der folgende Codeausschnitt stellt eine minimale Implementierung unseres transformierten Wörterbuchs bereit:

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

Schlüsseltransformationslogik

Die Methode „_keytransform“ ist für die Anwendung der gewünschten Transformation auf die Schlüssel verantwortlich. In unserem Fall wird der Schlüssel einfach in Kleinbuchstaben zurückgegeben:

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

Vererbung und Erweiterung

Um unser transformiertes Wörterbuch zu verwenden, können wir eine Unterklasse von „TransformedDict“ erstellen und die gewünschte Schlüsseltransformation im angeben '_keytransform'-Methode. Zum Beispiel:

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

Das implementierte „TransformedDict“ funktioniert mit Pickle, da es intern auf einem Standard-Dict basiert.

Es ist wichtig Beachten Sie, dass die direkte Unterklassifizierung von „dict“ im Allgemeinen nicht empfohlen wird, da dies zu unerwartetem Verhalten führen kann. Durch die Verwendung von ABCs können wir robuste und flexible Unterklassen erstellen, die sich an die gewünschte Schnittstelle halten, in diesem Fall die eines „MutableMapping“.

Das obige ist der detaillierte Inhalt vonWie kann ich mithilfe abstrakter Basisklassen eine robuste und flexible Wörterbuchunterklasse mit Kleinbuchstaben erstellen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!