Класс python, который действует как dict

Я хочу написать собственный класс, который ведет себя как dict - так что я наследую от dict.

Однако мой вопрос: нужно ли мне создавать закрытый dictчлен в моем __init__()методе? Я не вижу в этом смысла, так как у меня уже естьdict поведение, если я просто наследую от dict.

Может ли кто-нибудь указать, почему большинство фрагментов наследования выглядят так, как показано ниже?

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

   # other methods follow

Вместо более простого ...

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

   # other methods follow

На самом деле, я думаю, что я подозреваю, что ответ на вопрос состоит в том, что пользователи не могут напрямую обращаться к вашему словарю (т.е. они должны использовать методы доступа, которые вы предоставили).

Однако как насчет оператора доступа к массиву []? Как бы это реализовать? Пока я не видел примера, показывающего, как переопределить []оператор.

Так что если [] функция доступа не предоставляется в пользовательском классе, унаследованные базовые методы будут работать в другом словаре?

Я попробовал следующий фрагмент, чтобы проверить свое понимание наследования Python:

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]

Получила следующую ошибку:

KeyError: <встроенный идентификатор функции>

Что не так с приведенным выше кодом?

Как мне исправить класс, myDictчтобы я мог писать такой код?

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

[Редактировать]

Я отредактировал приведенный выше пример кода, чтобы избавиться от глупой ошибки, которую допустил до того, как выскочил из-за стола. Это была опечатка (я должен был заметить это по сообщению об ошибке).

Ознакомьтесь с документацией по эмуляции типов контейнеров . В вашем случае первым параметром addдолжен быть 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}

Как это

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

Теперь вы можете использовать встроенные функции, например dict.get()as self.get().

Вам не нужно заворачивать скрытое self._dict. Ваш класс уже является диктатом.

Для полноты, вот ссылка на документацию, упомянутую @ björn-pollex для последней версии Python 2.x (2.7.7 на момент написания):

Эмуляция типов контейнеров

(Извините за то, что не использую функцию комментариев, мне просто не разрешено делать это с помощью stackoverflow.)

Проблема с этим фрагментом кода:

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

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


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

... в том, что ваш метод 'add' (... и любой метод, который вы хотите быть членом класса) должен иметь явное 'self', объявленное в качестве первого аргумента, например:

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

Чтобы реализовать перегрузку оператора для доступа к элементам по ключу, посмотрите в документации волшебные методы __getitem__и __setitem__.

Обратите внимание, что, поскольку Python использует Duck Typing, на самом деле может не быть причин для получения вашего пользовательского класса dict из класса dict языка - без дополнительных сведений о том, что вы пытаетесь сделать (например, если вам нужно передать экземпляр этого class в некоторый код, который не сломается, если только isinstance(MyDict(), dict) == True), вам может быть лучше просто реализовать API, который делает ваш класс достаточно похожим на dict, и остановиться на этом.

Вот альтернативное решение:

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

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

Я действительно нигде не вижу правильного ответа на это

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

Все, что вам действительно нужно сделать, это определить свое собственное __init__- это все, что вам нужно.

Другой пример (немного посложнее):

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"}

Этот последний пример удобен, когда вы хотите встроить какую-то логику.

В любом случае ... короче говоря class GiveYourClassAName(dict), этого достаточно, чтобы ваш класс вел себя как диктатор. Любая операция dict, которую вы выполняете, selfбудет ничем не хуже обычного dict.

Это мое лучшее решение. Я использовал это много раз.

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

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

Вы можете использовать как:

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

Никогда не наследовать встроенный dict Python! например updateметод не используется __setitem__, они много делают для оптимизации. Используйте UserDict.

from collections import UserDict

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