Jak poprawnie dyktować podklasy i nadpisywać __getitem__ i __setitem__

Debuguję kod i chcę się dowiedzieć, kiedy uzyskuje się dostęp do określonego słownika. Cóż, w rzeczywistości jest to klasa, która jest podklasą dicti implementuje kilka dodatkowych funkcji. W każdym razie chciałbym zrobić podklasę dictsiebie i dodać nadpisanie __getitem__oraz __setitem__wygenerować wyjście debugowania. Teraz mam

class DictWatch(dict):
    def __init__(self, *args):
        dict.__init__(self, args)

    def __getitem__(self, key):
        val = dict.__getitem__(self, key)
        log.info("GET %s['%s'] = %s" % str(dict.get(self, 'name_label')), str(key), str(val)))
        return val

    def __setitem__(self, key, val):
        log.info("SET %s['%s'] = %s" % str(dict.get(self, 'name_label')), str(key), str(val)))
        dict.__setitem__(self, key, val)

' name_label'jest kluczem, który ostatecznie zostanie ustawiony i którego chcę użyć do zidentyfikowania wyniku. Następnie zmieniłem klasę, którą obsługuję, na podklasę DictWatchzamiast dicti zmieniłem wywołanie superkonstruktora. Mimo wszystko wydaje się, że nic się nie dzieje. Myślałem, że jestem sprytny, ale zastanawiam się, czy powinienem iść w innym kierunku.

Dzięki za pomoc!

To, co robisz, powinno absolutnie działać. Przetestowałem twoją klasę i poza brakującym nawiasem otwierającym w twoich instrukcjach dziennika, działa dobrze. Przychodzą mi do głowy tylko dwie rzeczy. Po pierwsze, czy dane wyjściowe instrukcji log są ustawione poprawnie? Może być konieczne umieszczenie logging.basicConfig(level=logging.DEBUG)u góry skryptu.

Po drugie, __getitem__i __setitem__są wywoływane tylko podczas []dostępu. Upewnij się więc, że masz dostęp tylko DictWatchprzez d[key], a nie d.get()id.set()

Innym problemem podczas tworzenia podklas dictjest to, że element wbudowany __init__nie wywołuje update, a element wbudowany updatenie wywołuje __setitem__. Tak więc, jeśli chcesz, aby wszystkie operacje setitem przechodziły przez twoją __setitem__funkcję, powinieneś upewnić się, że zostanie wywołana samodzielnie:

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

    def __getitem__(self, key):
        val = dict.__getitem__(self, key)
        print 'GET', key
        return val

    def __setitem__(self, key, val):
        print 'SET', key, val
        dict.__setitem__(self, key, val)

    def __repr__(self):
        dictrepr = dict.__repr__(self)
        return '%s(%s)' % (type(self).__name__, dictrepr)

    def update(self, *args, **kwargs):
        print 'update', args, kwargs
        for k, v in dict(*args, **kwargs).iteritems():
            self[k] = v

Rozważ podklasy UserDictlub UserList. Te klasy są przeznaczone do podklasy, podczas gdy normalne dicti listnie są, i zawierają optymalizacje.

To nie powinno tak naprawdę zmienić wyniku (co powinno działać, dla dobrych wartości progowych logowania): twój init powinien być:

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

zamiast tego, ponieważ wywołanie metody z DictWatch ([(1,2), (2,3)]) lub DictWatch (a = 1, b = 2) zakończy się niepowodzeniem.

(lub lepiej nie definiuj konstruktora)

Wszystko, co będziesz musiał zrobić, to

class BatchCollection(dict):
    def __init__(self, inpt={}):
        super(BatchCollection, self).__init__(inpt)

Przykładowe użycie do użytku osobistego

### EXAMPLE
class BatchCollection(dict):
    def __init__(self, inpt={}):
        super(BatchCollection, self).__init__(inpt)

    def __setitem__(self, key, item):
        if (isinstance(key, tuple) and len(key) == 2
                and isinstance(item, collections.Iterable)):
            # self.__dict__[key] = item
            super(BatchCollection, self).__setitem__(key, item)
        else:
            raise Exception(
                "Valid key should be a tuple (database_name, table_name) "
                "and value should be iterable")

Uwaga : testowano tylko w python3

Aby uzupełnić odpowiedź na pasztet irlandzki, oto przykład pokazujący różnicę między dicta UserDict:

Trudno jest poprawnie nadpisać dyktando:

class MyDict(dict):

  def __setitem__(self, key, value):
    super().__setitem__(key, value * 10)


d = MyDict(a=1, b=2)  # Bad! MyDict.__setitem__ not called
d.update(c=3)  # Bad! MyDict.__setitem__ not called
d['d'] = 4  # Good!
print(d)  # {'a': 1, 'b': 2, 'c': 3, 'd': 40}

UserDictdziedziczą z collections.abc.MutableMapping, więc jest znacznie łatwiejsza do dostosowania:

class MyDict(collections.UserDict):

  def __setitem__(self, key, value):
    super().__setitem__(key, value * 10)


d = MyDict(a=1, b=2)  # Good: MyDict.__setitem__ correctly called
d.update(c=3)  # Good: MyDict.__setitem__ correctly called
d['d'] = 4  # Good
print(d)  # {'a': 10, 'b': 20, 'c': 30, 'd': 40}

Podobnie, trzeba tylko wdrożyć __getitem__automatycznie być zgodny z key in my_dict, my_dict.get...

Uwaga: UserDictnie jest podklasą dict, więc isinstance(UserDict(), dict)zawiedzie (ale isinstance(UserDict(), collections.abc.MutableMapping)będzie działać)