dict처럼 작동하는 파이썬 클래스

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 : <내장 함수 ID>

위의 코드에 어떤 문제가 있습니까?

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().

You do not need to wrap a hidden self._dict. Your class already is a dict.

---

For the sake of completeness, here is the link to the documentation mentioned by @björn-pollex for the latest Python 2.x (2.7.7 as of the time of writing):

Emulating Container Types

(Sorry for not using the comments function, I'm just not allowed to do so by stackoverflow.)

---

The problem with this chunk of code:

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

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


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

...is that your 'add' method (...and any method you want to be a member of a class) needs to have an explicit 'self' declared as its first argument, like:

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

To implement the operator overloading to access items by key, look in the docs for the magic methods __getitem__ and __setitem__.

Note that because Python uses Duck Typing, there may actually be no reason to derive your custom dict class from the language's dict class -- without knowing more about what you're trying to do (e.g, if you need to pass an instance of this class into some code someplace that will break unless isinstance(MyDict(), dict) == True), you may be better off just implementing the API that makes your class sufficiently dict-like and stopping there.

---

Here is an alternative solution:

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

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

---

Don’t inherit from Python built-in dict, ever! for example update method woldn't use __setitem__, they do a lot for optimization. Use UserDict.

from collections import UserDict

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

참고URL : https://stackoverflow.com/questions/4014621/a-python-class-that-acts-like-dict