Index et Tranche un Générateur en Python

Permet de dire que j'ai un générateur de fonction qui ressemble à ceci:

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

Idéalement, je pouvais fib()[10] ou fib()[2:12:2] pour obtenir des indices et des tranches, mais actuellement, je utiliser itertools pour ces choses. Je ne peux pas utiliser un générateur pour une baisse de remplacement pour les listes.

Je crois que la solution sera de les envelopper fib() dans une classe:

class Indexable(object):
    ....

fib_seq = Indexable(fib())

Ce qui devrait Indexables ressembler pour faire ce travail?

InformationsquelleAutor Jason Christa | 2010-02-23

generator python

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

Vous pouvez l'utiliser comme ceci:

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

Avis que it[2:12:2] ne retourne pas [3, 8, 21, 55, 144] depuis l'itérateur avait déjà avancé de 11 éléments, en raison de l'appel à it[10].

Edit: Si vous souhaitez it[2:12:2] de retour [3, 8, 21, 55, 144] alors peut-être utiliser ce lieu:

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]

Cette version enregistre les résultats dans self.already_computed, et utilise ces résultats
si cela est possible. Sinon, il calcule plus de résultats jusqu'à ce qu'il a suffisamment nombreux
de retour de l'indexation de l'élément ou de la tranche.

Présentent le même comportement qu'une liste, getitem aurait besoin de rembobiner le générateur. Est-il un moyen facile de faire cela?
Je ne sais pas si il y a moyen de le faire, facile ou pas, mais la Fraise classe pourrait simplement de stocker toutes les déjà généré des éléments dans une liste. Puis __getitem__ tirer les numéros directement à partir de la liste, après la première faire avancer le générateur si nécessaire.
Grâce MatrixFrog; c'est ce que j'ai fait.
C'est une solution pratique. Il semble que il ya deux façons de le faire à ma question, à l'aide d'un cache de résultat, comme vous avez, ou la copie de l'itérateur. C'est juste un compromis entre l'utilisation de mémoire ou de processeur.

InformationsquelleAutor unutbu

0

Donc basé sur le code de la ~unutbu et en ajoutant un peu de itertools.tee shirt:
```
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))
```
- Droit, mais cette option brûlures CPU à chaque fois que vous l'utilisez. Pour les listes qui sont trop longues pour les stocker dans ~unutbu de already_computed le temps CPU nécessaire ici est susceptible d'être excessif de trop.
- Je pense que ça pourrait descendre à la complexité de la génératrice, si le code à l'intérieur du générateur du CPU est lourd à l'aide de already_computed est la meilleure option, mais peut-être si elle est simple comme xrange juste à recalculer c'est mieux.
- Ne pas itertools.té à l'interne qu'à stocker les résultats de sorte qu'il peut les rejouer plus tard? Il n'a aucun moyen de savoir si il peut copier l'itérateur soit; envisager un itérateur sur réseau entrante, ou quelque chose.
InformationsquelleAutor Jason Christa
0

Si c'est un 1-utilisation de la tranche que vous pouvez simplement utiliser la méthode écrite par ~unutbu. Si vous devez couper plusieurs fois vous devez stocker toutes les valeurs intermédiaires de sorte que vous pouvez "rewind", l'itérateur. Depuis les itérateurs peut itérer tout ce qu'il n'aurait pas un rembobinage de la méthode par défaut.

Aussi, depuis un rembobinage itérateur doit stocker tous les résultats intermédiaires, il serait (dans la plupart des cas) n'ont aucun avantage, par rapport à tout simplement faire list(iterator)

Essentiellement... soit vous n'avez pas besoin d'un itérateur, ou vous n'êtes pas assez précis sur la situation.
- list(fib()) vous donnera un MemoryError finalement
- Comment est le cas où je veux les 6 000 ème nombre de fibonacci. La façon la plus claire d'exprimer c'est fib[6000] même s'il y a plusieurs façons de l'obtenir, ils ne sont pas exprimés avec autant d'élégance.
- Mon point est, dans presque toutes les situations de la vie réelle que vous feriez l'objet lui-même peut être tranché au lieu de la mise en œuvre de tranchage à la génératrice. Si vous ne le faites pas, il serait impossible d'optimiser l'appel de la fonction correctement. Pour les grands nombres de fibonacci vous ne voulez pas de générer l'ensemble de la liste juste pour obtenir un nombre, vous devez utiliser une méthode de "deviner" le nombre.
InformationsquelleAutor Wolph

Ici est de ~unutbu de la réponse modifiée à la sous-classe de la liste. Évidemment, les abus tels que append, insert etc. va produire des résultats bizarres!

vous obtenez __str__ et __repr__ méthodes pour gratuit si

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)

Les listes sont trop différents de ce que nous voulons pour que cela soit utile. Ne pas le faire.
Ok, mais qui est "nous"?
Les personnes qui ont ce problème, je suppose.

InformationsquelleAutor John La Rooy

À la tranche générateur vous pouvez utiliser islice fonction de itertools

from itertools import islice

for i in islice(generator, 5):
    # Will be taken first 5 elems

for i in islice(generator, 5, None):
    # Will be taken everything starting at 5th

InformationsquelleAutor M. Alekseev

Vous devez vous connecter pour publier un commentaire.