Come creare correttamente sottoclassi e sovrascrivere __getitem__ e __setitem__

Sto eseguendo il debug di un codice e voglio scoprire quando si accede a un particolare dizionario. Bene, in realtà è una classe che sottoclasse dicte implementa un paio di funzionalità extra. Comunque, quello che vorrei fare è sottoclasse dictme stesso e aggiungere override __getitem__e __setitem__produrre un output di debug. In questo momento, l'ho fatto

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'è una chiave che alla fine verrà impostata che voglio utilizzare per identificare l'output. Ho quindi cambiato la classe che sto strumentando in sottoclasse DictWatchanziché dicte ho cambiato la chiamata al superconstructor. Tuttavia, sembra che non stia succedendo nulla. Pensavo di essere intelligente, ma mi chiedo se dovrei andare in una direzione diversa.

Grazie per l'aiuto!

Quello che stai facendo dovrebbe assolutamente funzionare. Ho testato la tua classe e, a parte una parentesi di apertura mancante nelle tue istruzioni di registro, funziona perfettamente. Ci sono solo due cose a cui riesco a pensare. Innanzitutto, l'output dell'istruzione di log è impostato correttamente? Potrebbe essere necessario inserire un logging.basicConfig(level=logging.DEBUG)all'inizio del copione.

Secondo, __getitem__e __setitem__vengono chiamati solo durante gli []accessi. Quindi assicurati di accedere solo DictWatchtramite d[key], anziché d.get()ed.set()

Un altro problema durante la sottoclasse dictè che il built-in __init__non chiama updatee il built-in updatenon chiama __setitem__. Quindi, se vuoi che tutte le operazioni setitem passino attraverso la tua __setitem__funzione, dovresti assicurarti che venga chiamata tu stesso:

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

Considera la creazione di sottoclassi UserDicto UserList. Queste classi sono intese come sottoclassi mentre le normali dicte listnon lo sono e contengono ottimizzazioni.

Ciò non dovrebbe davvero cambiare il risultato (che dovrebbe funzionare, per buoni valori di soglia di registrazione): il tuo init dovrebbe essere:

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

invece, perché se chiami il tuo metodo con DictWatch ([(1,2), (2,3)]) o DictWatch (a = 1, b = 2) questo fallirà.

(o, meglio, non definire un costruttore per questo)

Tutto quello che dovrai fare è

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

Un esempio di utilizzo per uso personale

### 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")

Nota : testato solo in python3

Per completare la risposta di Andrew Pate, ecco un esempio che mostra una differenza tra dicte UserDict:

È difficile sovrascrivere dict correttamente:

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}

UserDictereditano da collections.abc.MutableMapping, quindi è molto più facile personalizzare:

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}

Allo stesso modo, è sufficiente implementare __getitem__per essere automaticamente compatibile con key in my_dict, my_dict.get, ...

Nota: UserDictnon è una sottoclasse di dict, quindi isinstance(UserDict(), dict)fallirà (ma isinstance(UserDict(), collections.abc.MutableMapping)funzionerà)