Ne kadar "mükemmel" bir nesne olarak yapabilir miyim ^em>dictmümkün olduğunca? Nihai hedef basit olmasıdicthangi tuşların küçük.

Bunu yapmak için geçersiz kılmak edebilirim ilkel bazı küçük ayarlanmalıdır görünüyor bu iş, ancak tüm araştırma ve girişimleri bu değil gibi yapmış dava:

• Ben ise override __getitem__/__setitem__ 5*/set * işe yaramıyor. Onlara nasıl iş yapabilirim? Elbette bunları tek tek uygulamak gerek değil mi?

• Çalışma turşu engelliyor muyum, ve __setstate__ vb uygulamak gerekiyor mu?

• need repr, update and __init__?

• Sadece 20* *(UserDictkullanmamalısın görünüyor olmalıyım veya 12**)? Eğer öyleyse, nasıl? Doktorlar tam olarak aydınlatıcı değil.

İşte benim ilk anda get() çalışmıyor en azından gidip orada şüphe yok. küçük ince çok sorunun

class arbitrary_dict(dict):
    """A dictionary that applies an arbitrary key-altering function
       before accessing the keys."""

    def __keytransform__(self, key):
        return key

    # Overridden methods. List from 
    # http://stackoverflow.com/questions/2390827/how-to-properly-subclass-dict

    def __init__(self, *args, **kwargs):
        self.update(*args, **kwargs)

    # Note: I'm using dict directly, since super(dict, self) doesn't work.
    # I'm not sure why, perhaps dict is not a new-style class.

    def __getitem__(self, key):
        return dict.__getitem__(self, self.__keytransform__(key))

    def __setitem__(self, key, value):
        return dict.__setitem__(self, self.__keytransform__(key), value)

    def __delitem__(self, key):
        return dict.__delitem__(self, self.__keytransform__(key))

    def __contains__(self, key):
        return dict.__contains__(self, self.__keytransform__(key))


class lcdict(arbitrary_dict):
    def __keytransform__(self, key):
        return str(key).lower()

ABCs ile bir dict gibi oldukça kolay bir şekilde davranan bir nesne yazabilirsiniz (Soyut Sınıflar) collections modülünden. O bile sana söyler eğer bir yöntem kaçırdıysanız, aşağıdaki ABC kapanır minimal versiyonu.

import collections


class TransformedDict(collections.MutableMapping):
    """A dictionary that applies an arbitrary key-altering
       function before accessing the keys"""

    def __init__(self, *args, **kwargs):
        self.store = dict()
        self.update(dict(*args, **kwargs))  # use the free update to set keys

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

    def __setitem__(self, key, value):
        self.store[self.__keytransform__(key)] = value

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

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

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

    def __keytransform__(self, key):
        return key

ABC ve birkaç ücretsiz yöntemleri:

class MyTransformedDict(TransformedDict):

    def __keytransform__(self, key):
        return key.lower()


s = MyTransformedDict([('Test', 'test')])

assert s.get('TEST') is s['test']   # free get
assert 'TeSt' in s                  # free __contains__
                                    # free setdefault, __eq__, and so on

import pickle
assert pickle.loads(pickle.dumps(s)) == s
                                    # works too since we just use a normal dict

dict (veya diğer yerleşiklere) doğrudan alt sınıf olmaz. Sen tam olarak ne yapmak istiyorum, çünkü sık sık, hiç mantıklı değilbir dict arayüzü uygulamak. Ve bu Akk için tam olarak ne olduğunu.