Come sottoclasse correttamente dict e override __getitem__ & __setitem__

Question

Sto eseguendo il debug di alcuni codici e voglio scoprire quando si accede a un determinato dizionario. Bene, in realtà è una classe che sottoclasse dict e implementa un paio di funzioni extra. Ad ogni modo, quello che mi piacerebbe fare è sottoclasse dict e aggiungere l'override __getitem__ e __setitem__ per produrre un output di debug. In questo momento, ho

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 finirà per essere impostato che voglio utilizzare per identificare l'uscita. Ho quindi cambiato la classe che sto strumentando alla sottoclasse DictWatch anziché dict e ho cambiato la chiamata al supercostruttore. Tuttavia, nulla sembra accadere. Pensavo di essere intelligente, ma mi chiedo se dovrei andare in una direzione diversa.

Grazie per l'aiuto!

Answer 1

Quello che stai facendo dovrebbe funzionare assolutamente. Ho testato la tua classe e, a parte una parentesi aperta mancante nelle tue dichiarazioni di registro, funziona perfettamente. Ci sono solo due cose che posso pensare. Innanzitutto, l'output dell'istruzione del tuo registro è impostato correttamente? Potrebbe essere necessario inserire uno logging.basicConfig(level=logging.DEBUG) nella parte superiore dello script.

Secondo, __getitem__ e __setitem__ vengono chiamati solo durante gli accessi []. Quindi assicuratevi di accedere solo DictWatch via d[key], piuttosto che d.get() e d.set()

Answer 2

che non dovrebbe davvero cambiare il risultato (che dovrebbe funzionare, per i buoni valori di soglia di registrazione): 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)

Answer 3

Un altro problema quando sottoclasse dict è che il built-in __init__ non chiama update, e il built-in update non chiama __setitem__. Quindi, se si desidera che tutte le operazioni SetItem di passare attraverso la vostra funzione __setitem__, è necessario assicurarsi che venga chiamato da soli:

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 

Answer 4

Tutto quello che dovrete fare è

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

Un esempio dell'uso di mio 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