Index e Slice un generatore in Python

Question

Diciamo che ho una funzione di generatore che assomiglia a questo:

def fib(): 
    x,y = 1,1 
    while True: 
     x, y = y, x+y 
     yield x 

Idealmente, ho potuto solo usare fib() [10] o fib() [2 : 12: 2] per ottenere indici e sezioni, ma al momento devo usare itertools per queste cose. Non posso usare un generatore per una sostituzione in sostituzione di elenchi.

credo che la soluzione sarà quella di avvolgere fib() in una classe:

class Indexable(object): 
    .... 

fib_seq = Indexable(fib()) 

Cosa dovrebbe indicizzabile guarda come per fare questo lavoro?

Answer 1

import itertools 

class Indexable(object): 
    def __init__(self,it): 
     self.it = iter(it) 
    def __iter__(self): 
     return self.it 
    def __getitem__(self,index): 
     try: 
      return next(itertools.islice(self.it,index,index+1)) 
     except TypeError: 
      return list(itertools.islice(self.it,index.start,index.stop,index.step)) 

Si può usare in questo modo:

it = Indexable(fib()) 
print(it[10]) 
#144 
print(it[2:12:2]) 
#[610, 1597, 4181, 10946, 28657] 

noti che it[2:12:2] non restituisce [3, 8, 21, 55, 144] da quando l'iteratore aveva già avanzato 11 elementi a causa della chiamata a it[10].

Edit: Se vuoi it[2:12:2] per tornare [3, 8, 21, 55, 144] allora forse usare questo invece:

class Indexable(object): 

    def __init__(self, it): 
     self.it = iter(it) 
     self.already_computed = [] 

    def __iter__(self): 
     for elt in self.it: 
      self.already_computed.append(elt) 
      yield elt 

    def __getitem__(self, index): 
     try: 
      max_idx = index.stop 
     except AttributeError: 
      max_idx = index 
     n = max_idx - len(self.already_computed) + 1 
     if n > 0: 
      self.already_computed.extend(itertools.islice(self.it, n)) 
     return self.already_computed[index] 

Questa versione salva i risultati in self.already_computed e usa questi risultati se possibile. In caso contrario, calcola più risultati finché non ha un numero sufficiente di per restituire l'elemento o la sezione indicizzata.

Answer 2

Quindi in base al largo il codice ~ unutbu e aggiungendo in un piccolo itertools.tee:

import itertools 

class Indexable(object): 
    def __init__(self, it): 
     self.it = it 

    def __iter__(self): 
     self.it, cpy = itertools.tee(self.it) 
     return cpy 

    def __getitem__(self, index): 
     self.it, cpy = itertools.tee(self.it) 
     if type(index) is slice: 
      return list(itertools.islice(cpy, index.start, index.stop, index.step)) 
     else: 
      return next(itertools.islice(cpy, index, index+1)) 

Answer 3

Se si tratta di una fetta 1-uso di quanto si può semplicemente utilizzare il metodo scritto da ~ unutbu. Se è necessario suddividere più volte, è necessario memorizzare tutti i valori intermedi in modo da poter "riavvolgere" l'iteratore. Dal momento che gli iteratori possono iterare qualsiasi cosa, non avrebbe un metodo di rewind di default.

Inoltre, dal momento che un iteratore riavvolgimento deve memorizzare ogni risultato intermedio sarebbe (nella maggior parte dei casi) non hanno alcun vantaggio rispetto semplicemente facendo list(iterator)

Fondamentalmente ... si sia non hai bisogno di un iteratore, o si' non abbastanza specifico sulla situazione.

Answer 4

Ecco la risposta di ~ unutbu modificata all'elenco delle sottoclassi. Ovviamente l'abuso come append, insert produrrà risultati strani!

si vuole ricevere __str__ e __repr__ metodi gratis se

import itertools 
class Indexable(list): 
    def __init__(self,it): 
     self.it=it 
    def __iter__(self): 
     for elt in self.it: 
      yield elt 
    def __getitem__(self,index): 
     try: 
      max_idx=index.stop 
     except AttributeError: 
      max_idx=index 
     while max_idx>=len(self): 
      self.append(next(self.it)) 
     return list.__getitem__(self,index)