Eine Python-Klasse, die sich wie ein Diktat verhält

Ich möchte eine benutzerdefinierte Klasse schreiben, die sich wie dictfolgt verhält - also erbe ich von dict.

Meine Frage lautet jedoch: Muss ich dictin meiner __init__()Methode ein privates Mitglied erstellen ? Ich verstehe den Sinn davon nicht, da ich das dictVerhalten bereits habe, wenn ich einfach von erbe dict.

Kann jemand darauf hinweisen, warum die meisten Vererbungsschnipsel wie die folgenden aussehen?

class CustomDictOne(dict):
   def __init__(self):
      self._mydict = {} 

   # other methods follow

Anstelle der einfacheren ...

class CustomDictTwo(dict):
   def __init__(self):
      # initialize my other stuff here ...

   # other methods follow

Ich glaube, ich vermute, dass die Antwort auf die Frage so ist, dass Benutzer nicht direkt auf Ihr Wörterbuch zugreifen können (dh sie müssen die von Ihnen angegebenen Zugriffsmethoden verwenden).

Was ist jedoch mit dem Array-Zugriffsoperator []? Wie würde man das umsetzen? Bisher habe ich kein Beispiel gesehen, das zeigt, wie der []Operator überschrieben wird .

Wenn []in der benutzerdefinierten Klasse keine Zugriffsfunktion bereitgestellt wird, arbeiten die geerbten Basismethoden mit einem anderen Wörterbuch.

Ich habe das folgende Snippet ausprobiert, um mein Verständnis der Python-Vererbung zu testen:

class myDict(dict):
    def __init__(self):
        self._dict = {}

    def add(self, id, val):
        self._dict[id] = val


md = myDict()
md.add('id', 123)
print md[id]

Ich habe folgenden Fehler erhalten:

KeyError: <integrierte Funktions-ID>

Was ist mit dem obigen Code falsch?

Wie korrigiere ich die Klasse, myDictdamit ich solchen Code schreiben kann?

md = myDict()
md['id'] = 123

[Bearbeiten]

Ich habe das obige Codebeispiel bearbeitet, um den dummen Fehler zu beseitigen, den ich gemacht habe, bevor ich von meinem Schreibtisch weggerannt bin. Es war ein Tippfehler (ich hätte ihn anhand der Fehlermeldung erkennen sollen).

Überprüfen Sie die Dokumentation zum Emulieren von Containertypen . In Ihrem Fall sollte der erste Parameter addsein self.

class Mapping(dict):

    def __setitem__(self, key, item):
        self.__dict__[key] = item

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

    def __repr__(self):
        return repr(self.__dict__)

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

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

    def clear(self):
        return self.__dict__.clear()

    def copy(self):
        return self.__dict__.copy()

    def has_key(self, k):
        return k in self.__dict__

    def update(self, *args, **kwargs):
        return self.__dict__.update(*args, **kwargs)

    def keys(self):
        return self.__dict__.keys()

    def values(self):
        return self.__dict__.values()

    def items(self):
        return self.__dict__.items()

    def pop(self, *args):
        return self.__dict__.pop(*args)

    def __cmp__(self, dict_):
        return self.__cmp__(self.__dict__, dict_)

    def __contains__(self, item):
        return item in self.__dict__

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

    def __unicode__(self):
        return unicode(repr(self.__dict__))


o = Mapping()
o.foo = "bar"
o['lumberjack'] = 'foo'
o.update({'a': 'b'}, c=44)
print 'lumberjack' in o
print o

In [187]: run mapping.py
True
{'a': 'b', 'lumberjack': 'foo', 'foo': 'bar', 'c': 44}

So was

class CustomDictOne(dict):
   def __init__(self,*arg,**kw):
      super(CustomDictOne, self).__init__(*arg, **kw)

Jetzt können Sie die integrierten Funktionen wie dict.get()as verwenden self.get().

Sie müssen kein verstecktes verpacken self._dict. Ihre Klasse bereits ist ein dict.

Der Vollständigkeit halber hier der Link zu der Dokumentation, die von @ björn-pollex für das neueste Python 2.x (2.7.7 zum Zeitpunkt des Schreibens) erwähnt wurde:

Containertypen emulieren

(Entschuldigung, dass Sie die Kommentarfunktion nicht verwenden. Ich darf dies nur nicht durch Stackoverflow tun.)

Das Problem mit diesem Codestück:

class myDict(dict):
    def __init__(self):
        self._dict = {}

    def add(id, val):
        self._dict[id] = val


md = myDict()
md.add('id', 123)

... ist, dass Ihre 'add'-Methode (... und jede Methode, die Sie Mitglied einer Klasse werden möchten) ein explizites' self 'als erstes Argument deklarieren muss, wie:

def add(self, 'id', 23):

Um die Überladung des Operators für den Zugriff auf Elemente per Schlüssel zu implementieren, suchen Sie in den Dokumenten nach den magischen Methoden __getitem__und __setitem__.

Da Python Duck Typing verwendet, gibt es möglicherweise keinen Grund, Ihre benutzerdefinierte Diktatklasse aus der Diktatklasse der Sprache abzuleiten - ohne mehr darüber zu wissen, was Sie tun möchten (z. B. wenn Sie eine Instanz davon übergeben müssen Klasse in einen Code an einem Ort, der kaputt geht, es sei denn isinstance(MyDict(), dict) == True), ist es möglicherweise besser, nur die API zu implementieren, die Ihre Klasse ausreichend diktiert und dort stoppt.

Hier ist eine alternative Lösung:

class AttrDict(dict):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.__dict__ = self

a = AttrDict()
a.a = 1
a.b = 2

Ich sehe wirklich nirgendwo die richtige Antwort darauf

class MyClass(dict):
    
    def __init__(self, a_property):
        self[a_property] = a_property

Alles, was Sie wirklich tun müssen, ist, Ihre eigenen zu definieren __init__- das ist wirklich alles, was es auch gibt.

Ein weiteres Beispiel (etwas komplexer):

class MyClass(dict):

    def __init__(self, planet):
        self[planet] = planet
        info = self.do_something_that_returns_a_dict()
        if info:
            for k, v in info.items():
                self[k] = v

    def do_something_that_returns_a_dict(self):
        return {"mercury": "venus", "mars": "jupiter"}

Dieses letzte Beispiel ist praktisch, wenn Sie eine Art Logik einbetten möchten.

Wie auch immer ... kurz gesagt, class GiveYourClassAName(dict)es reicht aus, um Ihre Klasse wie ein Diktat zu verhalten. Jede Diktieroperation, die Sie ausführen, ist selfwie ein reguläres Diktat.

Das ist meine beste Lösung. Ich habe das oft benutzt.

class DictLikeClass:
    ...
    def __getitem__(self, key):
        return getattr(self, key)

    def __setitem__(self, key, value):
        setattr(self, key, value)
    ...

Sie können wie folgt verwenden:

>>> d = DictLikeClass()
>>> d["key"] = "value"
>>> print(d["key"])

Erben Sie niemals von dem in Python integrierten Diktat! Zum Beispiel wird die updateMethode nicht verwendet __setitem__, sie trägt viel zur Optimierung bei. Verwenden Sie UserDict.

from collections import UserDict

class MyDict(UserDict):
    def __delitem__(self, key):
        pass
    def __setitem__(self, key, value):
        pass