Einen Python-Iterator rückwärts laufen lassen?

Es ist trotzdem eine python-Liste-iterator, rückwärts zu gehen?

Im Grunde habe ich diese

class IterTest(object):
    def __init__(self, data):
        self.data = data
        self.__iter = None

    def all(self):
        self.__iter = iter(self.data)
        for each in self.__iter:
            mtd = getattr(self, type(each).__name__)
            mtd(each)

    def str(self, item):
        print item

        next = self.__iter.next()
        while isinstance(next, int):
            print next
            next = self.__iter.next()

    def int(self, item):
        print "Crap i skipped C"

if __name__ == '__main__':
    test = IterTest(['a', 1, 2,3,'c', 17])
    test.all()

Läuft dieser code ergibt in der Ausgabe:

a
1
2
3
Crap i skipped C

Weiß ich, warum es gibt mir den Ausgang, jedoch ist es ein Weg, gehe ich einen Schritt rückwärts in der str () - Methode auf, um einen Schritt?

BEARBEITEN

Okay vielleicht, um diese besser klar. Ich will nicht, um eine volle Rückseite, im Grunde, was ich wissen möchte, ob es einen einfachen Weg, um die Entsprechung einer bidirektionale Iteratoren in python?

InformationsquelleAutor der Frage UberJumper | 2010-05-05

Nein, im Allgemeinen, Sie können eine Python-iterator rückwärts zu gehen. Allerdings, wenn Sie nur wollen, um einen Schritt zurück, sobald Sie können versuchen, so etwas wie dieses:

def str(self, item):
    print item

    prev, current = None, self.__iter.next()
    while isinstance(current, int):
        print current
        prev, current = current, self.__iter.next()

Können Sie dann den Zugriff auf das Vorherige element zu jeder Zeit im prev.

Wenn Sie wirklich brauchen ein bidirektionaler iterator implementieren Sie eine sich selbst, aber es ist wahrscheinlich vorstellen, noch mehr Aufwand als die Lösung oben:

class bidirectional_iterator(object):
    def __init__(self, collection):
        self.collection = collection
        self.index = 0

    def next(self):
        try:
            result = self.collection[self.index]
            self.index += 1
        except IndexError:
            raise StopIteration
        return result

    def prev(self):
        self.index -= 1
        if self.index < 0:
            raise StopIteration
        return self.collection[self.index]

    def __iter__(self):
        return self

InformationsquelleAutor der Antwort Tamás

Bin ich etwas fehlt oder konnte Sie nicht verwenden, die Technik, beschrieben in der "Iterator" - Abschnitt in der Python-tutorial?

>>> class reverse_iterator:
...     def __init__(self, collection):
...         self.data = collection
...         self.index = len(self.data)
...     def __iter__(self):
...         return self
...     def next(self):
...         if self.index == 0:
...             raise StopIteration
...         self.index = self.index - 1
...         return self.data[self.index]
...     
>>> for each in reverse_iterator(['a', 1, 2, 3, 'c', 17]):
...     print each
... 
17
c
3
2
1
a

Ich weiß, dass dies nicht zu Fuß den iterator rückwärts, aber ich bin mir ziemlich sicher, dass es keine Möglichkeit gibt, das zu tun, im Allgemeinen. Stattdessen schreiben Sie einen iterator, wandelt einen getrennten Sammlung in umgekehrter Reihenfolge.

Bearbeiten Sie können auch die rückgängig() - Funktion, um eine umgekehrte iterator für jede Sammlung, so dass Sie nicht haben, um Ihre eigenen schreiben:

>>> it = reversed(['a', 1, 2, 3, 'c', 17])
>>> type(it)
<type 'listreverseiterator'>
>>> for each in it:
...  print each
... 
17
c
3
2
1
a

InformationsquelleAutor der Antwort D.Shawley

3

Einen iterator, ist per definition ein Objekt mit der next() Methode -- keine Erwähnung von prev() zu löschen. So müssen Sie entweder den cache der Ergebnisse, so knnen Sie oder implementieren Sie Ihre iterator, so gibt es Ergebnisse in der Reihenfolge, die Sie Sie sein wünschen.

InformationsquelleAutor der Antwort ktdrv

Basierend auf Ihrer Frage, es klingt wie Sie wollen, so etwas wie dieses:

class buffered:
    def __init__(self,it):
        self.it = iter(it)
        self.buf = []
    def __iter__(self): return self
    def __next__(self):
        if self.buf:
            return self.buf.pop()
        return next(self.it)
    def push(self,item): self.buf.append(item)

if __name__=="__main__":
    b = buffered([0,1,2,3,4,5,6,7])
    print(next(b)) # 0
    print(next(b)) # 1
    b.push(42)
    print(next(b)) # 42
    print(next(b)) # 2

InformationsquelleAutor der Antwort David X

Können Sie wickeln Sie Ihre iterator ein iterator Helfer, um es zu aktivieren, um rückwärts zu gehen. Es speichert die iterierten Werte in einer Sammlung und Wiederverwendung, wenn Sie rückwärts gehen.

class MemoryIterator:
    def __init__(self, iterator : Iterator):
        self._iterator : Iterator = iterator
        self._array = []
        self._isComplete = False
        self._pointer = 0

    def __next__(self):
        if self._isComplete or self._pointer < len(self._array):
            if self._isComplete and self._pointer >= len(self._array):
                raise StopIteration()

            value = self._array[self._pointer]
            self._pointer = self._pointer + 1
            return value

        try:
            value = next(self._iterator)
            self._pointer = self._pointer + 1
            self._array.append(value)
            return value
        except(StopIteration):
            self._isComplete = True

    def prev(self):        
        if self._pointer - 2 < 0:
            raise StopIteration()

        self._pointer = self._pointer - 1
        return self._array[self._pointer - 1]

Die Nutzung, ähnlich wie diese:

my_iter = iter(my_iterable_source)
memory_iterator = MemoryIterator(my_iter)
try:
    if forward:
        print(next(memory_iterator))
    else:
        print(memory_iterator.prev()
except(StopIteration):
    pass

InformationsquelleAutor der Antwort Jonáš Kulhánek

ich denke, thi wird Ihnen helfen, Ihr problem zu lösen

    class TestIterator():
        def __init__(self):`
            self.data = ["MyData", "is", "here","done"]
            self.index = -1
            #self.index=len(self.data)-1
    def __iter__(self):
        return self

    def next(self):
        self.index += 1
        if self.index >= len(self.data):
            raise StopIteration
        return self.data[self.index]

    def __reversed__(self):
        self.index = -1
        if self.index >= len(self.data):
            raise StopIteration
        return self.data[self.index]

r = TestIterator()
itr=iter(r)
print (next(itr))
print (reversed(itr))

InformationsquelleAutor der Antwort dilshad

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.