__iter __() implementato come un generatore

Question

Ho una sottoclasse oggetto che implementa una distribuzione dinamica __ iter __ utilizzando un generatore di cache (Ho anche un metodo per invalidare la cache iter) in questo modo:

def __iter__(self): 
    print("iter called") 
    if self.__iter_cache is None: 
     iter_seen = {} 
     iter_cache = [] 
     for name in self.__slots: 
      value = self.__slots[name] 
      iter_seen[name] = True 
      item = (name, value) 
      iter_cache.append(item) 
      yield item   
     for d in self.__dc_list: 
      for name, value in iter(d): 
       if name not in iter_seen: 
        iter_seen[name] = True 
        item = (name, value) 
        iter_cache.append(item) 
        yield item 
     self.__iter_cache = iter_cache 
    else: 
     print("iter cache hit") 
     for item in self.__iter_cache: 
      yield item 

sembra sta lavorando ... Ci sono dei trucchi che potrei non essere a conoscenza? Sto facendo qualcosa di ridicolo?

Answer 1

Sembra un approccio molto fragile. È sufficiente modificare qualsiasi __slot, __dc_list, __iter_cache durante l'iterazione attiva per mettere l'oggetto in uno stato incoerente.

È necessario o vietare la modifica dell'oggetto durante l'iterazione o generare tutti gli elementi della cache contemporaneamente e restituire una copia dell'elenco.

Answer 2

container.__iter__() restituisce un oggetto iteratore. Gli stessi oggetti iteratori vengono richiesti per supportare i seguenti due metodi, che formano insieme il protocollo iteratore:

iterator.__iter__() 

restituisce l'oggetto iteratore.

iterator.next() 

Restituire l'elemento successivo dal contenitore.

Questo è esattamente ciò che ha ogni generatore. Quindi non temere alcun effetto collaterale.

Answer 3

Potrebbe essere preferibile separare l'iterazione dell'oggetto dalla memorizzazione nella cache dei valori restituiti. Ciò semplificherebbe il processo di iterazione e ti consentirà di controllare facilmente come viene eseguita la memorizzazione nella cache e se è abilitata o meno, ad esempio.

Un altro possibilmente considerazione importante è il fatto che il codice non gestirà in modo prevedibile la situazione in cui l'oggetto che viene iterato viene cambiato tra chiamate successive al metodo. Un modo semplice per gestirlo sarebbe quello di popolare completamente il contenuto della cache alla prima chiamata, e quindi solo il yield ciò che contiene per ogni chiamata e documentare il comportamento.

Answer 4

Quello che stai facendo è valido anche se strano. Che cos'è un __slots o un __dc_list ?? Generalmente è meglio descrivere il contenuto del tuo oggetto in un nome di attributo, piuttosto che nel suo tipo (es .: self.users piuttosto che self.u_list).

È possibile utilizzare il mio decoratore LazyProperty per semplificare notevolmente questo aspetto.

Basta decorare il tuo metodo con @LazyProperty. Sarà chiamato la prima volta e il decoratore sostituirà quindi l'attributo con i risultati. L'unico requisito è che il valore sia ripetibile; non dipende dallo stato mutabile. Hai anche quel requisito nel tuo codice attuale, con te stesso .__ iter_cache.

def __iter__(self) 
    return self.__iter 

@LazyProperty 
def __iter(self) 
    def my_generator(): 
     yield whatever 
    return tuple(my_generator())