Một lớp python hoạt động giống như dict

Tôi muốn viết một lớp tùy chỉnh hoạt động như dict - vì vậy, tôi đang kế thừa từ dict.

Tuy nhiên, câu hỏi của tôi là: Tôi có cần tạo một dictthành viên riêng trong __init__()phương thức của mình không ?. Tôi không hiểu vấn đề này, vì tôi đã códict hành vi nếu tôi thừa kế từ đó dict.

Bất cứ ai có thể chỉ ra lý do tại sao hầu hết các đoạn mã kế thừa trông giống như hình dưới đây?

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

   # other methods follow

Thay vì đơn giản hơn ...

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

   # other methods follow

Trên thực tế, tôi nghĩ rằng tôi nghi ngờ câu trả lời cho câu hỏi là người dùng không thể truy cập trực tiếp từ điển của bạn (tức là họ phải sử dụng các phương pháp truy cập mà bạn đã cung cấp).

Tuy nhiên, còn toán tử truy cập mảng []thì sao? Làm thế nào một người sẽ thực hiện điều đó? Cho đến nay, tôi chưa thấy một ví dụ nào cho thấy cách ghi đè []toán tử.

Vì vậy, nếu một []chức năng truy cập không được cung cấp trong lớp tùy chỉnh, các phương thức cơ sở kế thừa sẽ hoạt động trên một từ điển khác?

Tôi đã thử đoạn mã sau để kiểm tra hiểu biết của mình về tính kế thừa 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]

Tôi gặp lỗi sau:

KeyError: <id hàm tích hợp sẵn>

Có gì sai với đoạn mã trên?

Làm cách nào để sửa lớp myDictđể tôi có thể viết mã như thế này?

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

[Biên tập]

Tôi đã chỉnh sửa mẫu mã ở trên để loại bỏ lỗi ngớ ngẩn mà tôi đã mắc phải trước khi rời khỏi bàn làm việc. Đó là lỗi đánh máy (đáng lẽ tôi phải phát hiện ra nó từ thông báo lỗi).

Kiểm tra tài liệu về mô phỏng các loại thùng chứa . Trong trường hợp của bạn, tham số đầu tiên addphải là 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}

Như thế này

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

Bây giờ bạn có thể sử dụng các chức năng được tích hợp sẵn, chẳng hạn dict.get()như self.get().

Bạn không cần phải bọc một ẩn self._dict. Lớp học của bạn đã là một chính tả.

Để đầy đủ, đây là liên kết đến tài liệu được @ björn-pollex đề cập cho Python 2.x mới nhất (2.7.7 tính đến thời điểm viết bài):

Mô phỏng các loại vùng chứa

(Xin lỗi vì không sử dụng chức năng nhận xét, tôi chỉ không được phép làm như vậy bởi stackoverflow.)

Vấn đề với đoạn mã này:

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

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


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

... là phương thức 'add' của bạn (... và bất kỳ phương thức nào bạn muốn trở thành thành viên của một lớp) cần phải khai báo rõ ràng 'self' làm đối số đầu tiên của nó, như:

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

Để thực hiện nạp chồng toán tử để truy cập các mục theo khóa, hãy tìm trong tài liệu để biết các phương pháp ma thuật __getitem__và__setitem__ .

Lưu ý rằng vì Python sử dụng Duck Typing, thực sự có thể không có lý do gì để lấy lớp dict tùy chỉnh của bạn từ lớp dict của ngôn ngữ - mà không cần biết thêm về những gì bạn đang cố gắng thực hiện (ví dụ: nếu bạn cần chuyển một trường hợp của điều này lớp thành một số mã ở nơi nào đó sẽ bị hỏng trừ khi isinstance(MyDict(), dict) == True), bạn có thể tốt hơn chỉ nên triển khai API làm cho lớp của bạn đủ giống và dừng lại ở đó.

Đây là một giải pháp thay thế:

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

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

Tôi thực sự không thấy câu trả lời thích hợp cho điều này ở bất cứ đâu

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

Tất cả những gì bạn thực sự phải làm là xác định cái riêng của bạn __init__- đó thực sự là tất cả những gì có quá.

Một ví dụ khác (phức tạp hơn một chút):

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

Ví dụ cuối cùng này rất hữu ích khi bạn muốn nhúng một số loại logic.

Dù sao thì ... tóm lại class GiveYourClassAName(dict)là đủ để khiến lớp học của bạn hành động như một chế tài. Bất kỳ thao tác dict nào bạn thực hiện selfsẽ giống như một lệnh dict thông thường.

Đây là giải pháp tốt nhất của tôi. Tôi đã sử dụng điều này nhiều lần.

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

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

Bạn có thể sử dụng như:

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

Đừng kế thừa từ dict tích hợp sẵn trong Python, bao giờ hết! ví dụ như updatephương pháp không sử dụng __setitem__, chúng làm rất nhiều để tối ưu hóa. Sử dụng UserDict.

from collections import UserDict

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