問題

實驗樓python挑戰(zhàn)賽1 實現(xiàn)一個不可變的dict，數(shù)據(jù)只能由類初始化的時候通過參數(shù)傳遞，修改、添加都會拋出TypeError

解決方法

繼承ABCs中的MultiMapping, 復寫其中的部分方法即可。

代碼

import collections


class ImmutableDict(collections.MutableMapping):
 def __init__(self, **kwargs):
     self.store = dict(**kwargs)
     self.error = TypeError("'ImmutableDict' objects are immutable")
     # self.update(dict(*args, **kwargs))

 def __setitem__(self, key, value):
     # 涉及到修改時會觸發(fā)這個方法
     raise self.error

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

 def __delitem__(self, key):
     # 刪除時觸發(fā)
     raise self.error

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

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


class Get(object):
 def __init__(self):
     pass

 def __getitem__(self, item):
     return hash(item)


if __name__ == "__main__":
 test = ImmutableDict(name="sun", age=22, location="China")
 # test["name"] = "zhang"
 # test.pop("name")   TypeError will raised..
 # print(test.pop("name"))
 # for item in test:
     # print(item)
     #print(test[item])

MultiMapping 源碼：

class MutableMapping(Mapping):

    @abstractmethod
    def __setitem__(self, key, value):
        raise KeyError

    @abstractmethod
    def __delitem__(self, key):
        raise KeyError

    __marker = object()

    def pop(self, key, default=__marker):
        try:
            value = self[key]
        except KeyError:
            if default is self.__marker:
                raise
            return default
        else:
            del self[key]
            return value

    def popitem(self):
        try:
            key = next(iter(self))
        except StopIteration:
            raise KeyError
        value = self[key]
        del self[key]
        return key, value

    def clear(self):
        try:
            while True:
                self.popitem()
        except KeyError:
            pass

    def update(self, other=(), **kwds):
        if isinstance(other, Mapping):
            for key in other:
                self[key] = other[key]
        elif hasattr(other, "keys"):
            for key in other.keys():
                self[key] = other[key]
        else:
            for key, value in other:
                self[key] = value
        for key, value in kwds.items():
            self[key] = value

    def setdefault(self, key, default=None):
        try:
            return self[key]
        except KeyError:
            self[key] = default
        return default

MutableMapping.register(dict)

Mapping 源碼：

class Mapping(Sized, Iterable, Container):

    @abstractmethod
    def __getitem__(self, key):
        raise KeyError

    def get(self, key, default=None):
        try:
            return self[key]
        except KeyError:
            return default

    def __contains__(self, key):
        try:
            self[key]
        except KeyError:
            return False
        else:
            return True

    def iterkeys(self):
        return iter(self)

    def itervalues(self):
        for key in self:
            yield self[key]

    def iteritems(self):
        for key in self:
            yield (key, self[key])

    def keys(self):
        return list(self)

    def items(self):
        return [(key, self[key]) for key in self]

    def values(self):
        return [self[key] for key in self]

    # Mappings are not hashable by default, but subclasses can change this
    __hash__ = None

    def __eq__(self, other):
        if not isinstance(other, Mapping):
            return NotImplemented
        return dict(self.items()) == dict(other.items())

    def __ne__(self, other):
        return not (self == other)

分析兩個問題：

• .get 的時候究竟發(fā)生了什么？
• .pop 的時候發(fā)生了什么？

嘗試進行斷點調(diào)試：

嘗試

get 跳轉(zhuǎn)到了Mapping中的get

image.png

image.png

注意其中的self就是我們實例化的immutableDict類

結(jié)論： .get顯示定義是在Mapping中，但是Mapping又把這個方法的實現(xiàn)拋給了子類，事實上，就是調(diào)用了 immutableDict.getitem中的方法。
所以我們在get 會觸發(fā)我們在 immutableDict.getitem中定義的異常
pop 也就很類似了。