Générateurs Python zippés dont le 2ème est plus court: comment récupérer un élément consommé en silence

Je veux analyser 2 générateurs de longueur (potentiellement) différente avec zip:

for el1, el2 in zip(gen1, gen2):
    print(el1, el2)

Cependant, s'il gen2a moins d'éléments, un élément supplémentaire de gen1est "consommé".

Par exemple,

def my_gen(n:int):
    for i in range(n):
        yield i

gen1 = my_gen(10)
gen2 = my_gen(8)

list(zip(gen1, gen2))  # Last tuple is (7, 7)
print(next(gen1))  # printed value is "9" => 8 is missing

gen1 = my_gen(8)
gen2 = my_gen(10)

list(zip(gen1, gen2))  # Last tuple is (7, 7)
print(next(gen2))  # printed value is "8" => OK

Apparemment, une valeur manque ( 8dans mon exemple précédent) car elle gen1est lue (générant ainsi la valeur 8) avant de se rendre compte qu'elle gen2n'a plus d'éléments. Mais cette valeur disparaît dans l'univers. Quand gen2est "plus long", il n'y a pas un tel "problème".

QUESTION : Existe-t-il un moyen de récupérer cette valeur manquante (c'est- 8à- dire dans mon exemple précédent)? ... idéalement avec un nombre variable d'arguments (comme le zipfait).

REMARQUE : J'ai actuellement implémenté d'une autre manière en utilisant itertools.zip_longestmais je me demande vraiment comment obtenir cette valeur manquante en utilisant zipou équivalent.

NOTE 2 : J'ai créé quelques tests des différentes implémentations dans ce REPL au cas où vous voudriez soumettre et essayer une nouvelle implémentation :) https://repl.it/@jfthuong/MadPhysicistChester

Une façon serait d'implémenter un générateur qui vous permet de mettre en cache la dernière valeur:

class cache_last(collections.abc.Iterator):
    """
    Wraps an iterable in an iterator that can retrieve the last value.

    .. attribute:: obj

       A reference to the wrapped iterable. Provided for convenience
       of one-line initializations.
    """
    def __init__(self, iterable):
        self.obj = iterable
        self._iter = iter(iterable)
        self._sentinel = object()

    @property
    def last(self):
        """
        The last object yielded by the wrapped iterator.

        Uninitialized iterators raise a `ValueError`. Exhausted
        iterators raise a `StopIteration`.
        """
        if self.exhausted:
            raise StopIteration
        return self._last

    @property
    def exhausted(self):
        """
        `True` if there are no more elements in the iterator.
        Violates EAFP, but convenient way to check if `last` is valid.
        Raise a `ValueError` if the iterator is not yet started.
        """
        if not hasattr(self, '_last'):
            raise ValueError('Not started!')
        return self._last is self._sentinel

    def __next__(self):
        """
        Retrieve, record, and return the next value of the iteration.
        """
        try:
            self._last = next(self._iter)
        except StopIteration:
            self._last = self._sentinel
            raise
        # An alternative that has fewer lines of code, but checks
        # for the return value one extra time, and loses the underlying
        # StopIteration:
        #self._last = next(self._iter, self._sentinel)
        #if self._last is self._sentinel:
        #    raise StopIteration
        return self._last

    def __iter__(self):
        """
        This object is already an iterator.
        """
        return self

Pour l'utiliser, encapsulez les entrées pour zip:

gen1 = cache_last(range(10))
gen2 = iter(range(8))
list(zip(gen1, gen2))
print(gen1.last)
print(next(gen1)) 

Il est important de créer gen2un itérateur plutôt qu'un itérable, afin que vous puissiez savoir lequel a été épuisé. Si gen2est épuisé, vous n'avez pas besoin de vérifier gen1.last.

Une autre approche consisterait à remplacer zip pour accepter une séquence mutable d'itérables au lieu d'itérables séparés. Cela vous permettrait de remplacer les itérables par une version chaînée qui inclut votre élément "jeté un œil":

def myzip(iterables):
    iterators = [iter(it) for it in iterables]
    while True:
        items = []
        for it in iterators:
            try:
                items.append(next(it))
            except StopIteration:
                for i, peeked in enumerate(items):
                    iterables[i] = itertools.chain([peeked], iterators[i])
                return
            else:
                yield tuple(items)

gens = [range(10), range(8)]
list(myzip(gens))
print(next(gens[0]))

Cette approche est problématique pour de nombreuses raisons. Non seulement il perdra l'itérable d'origine, mais il perdra toutes les propriétés utiles que l'objet d'origine aurait pu avoir en le remplaçant par un chainobjet.

C'est l' zipéquivalent d'implémentation donné dans la documentation

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

Dans votre 1er exemple gen1 = my_gen(10)et gen2 = my_gen(8). Après les deux générateurs sont consommés jusqu'à la 7ème itération. Maintenant, à la 8e itération, les gen1appels elem = next(it, sentinel)renvoient 8, mais lorsque les gen2appels elem = next(it, sentinel)reviennent sentinel(car à ce moment, ils gen2sont épuisés) et if elem is sentinelsont satisfaits et la fonction exécute le retour et s'arrête. Renvoie maintenant next(gen1)9.

Dans votre 2ème exemple gen1 = gen(8)et gen2 = gen(10). Après les deux générateurs sont consommés jusqu'à la 7ème itération. Maintenant, à la 8e itération, l' gen1appel elem = next(it, sentinel)revient sentinel(car à ce stade gen1est épuisé) et if elem is sentinelest satisfait et la fonction exécute le retour et s'arrête. Renvoie maintenant next(gen2)8.

Inspiré par la réponse de Mad Physicist , vous pouvez utiliser ce Genwrapper pour le contrer:

Edit : Pour gérer les cas pointés par Jean-François T.

Une fois qu'une valeur est consommée par l'itérateur, elle disparaît à jamais de l'itérateur et il n'y a pas de méthode de mutation sur place pour que les itérateurs la rajoutent à l'itérateur. Une solution consiste à stocker la dernière valeur consommée.

class Gen:
    def __init__(self,iterable):
        self.d = iter(iterable)
        self.sentinal = object()
        self.prev = self.sentinal
    def __iter__(self):
        return self
    @property
    def last_val_consumed(self):
        if self.prev is None:
            raise StopIteration
        if self.prev == self.sentinal:
            raise ValueError('Nothing has been consumed')
        return self.prev
    def __next__(self):
        self.prev = next(self.d,None)
        if self.prev is None:
            raise StopIteration
        return self.prev

Exemples:

# When `gen1` is larger than `gen2`
gen1 = Gen(range(10))
gen2 = Gen(range(8))
list(zip(gen1,gen2))
# [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7)]
gen1.last_val_consumed
# 8 #as it was the last values consumed
next(gen1)
# 9
gen1.last_val_consumed
# 9

# 2. When `gen1` or `gen2` is empty
gen1 = Gen(range(0))
gen2 = Gen(range(5))
list(zip(gen1,gen2))
gen1.last_val_consumed
# StopIteration error is raised
gen2.last_val_consumed
# ValueError is raised saying `ValueError: Nothing has been consumed`

Je peux voir que vous avez déjà trouvé cette réponse et elle a été évoquée dans les commentaires, mais j'ai pensé que j'en ferais une réponse. Vous souhaitez utiliser itertools.zip_longest(), qui remplacera les valeurs vides du générateur le plus court par None:

import itertools

def my_gen(n:int):
    for i in range(n):
        yield i

gen1 = my_gen(10)
gen2 = my_gen(8)

for i, j in itertools.zip_longest(gen1, gen2):
    print(i, j)

Tirages:

0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 None
9 None

Vous pouvez également fournir un fillvalueargument lors de l'appel zip_longestpour remplacer le Nonepar une valeur par défaut, mais fondamentalement pour votre solution une fois que vous avez frappé un None(ou iou j) dans la boucle for, l'autre variable aura votre 8.

Inspiré par l'élucidation de @ GrandPhuba zip, créons une variante "sûre" (testée ici ):

def safe_zip(*args):
    """
    Safe zip that restores last consumed element in eachgenerator
    if not able to consume an element in all of them

    Returns:
        * generators in tuple
        * generator for zipped generators
    """
  continue_ = True
  n = len(args)
  result = (_ for _ in [])
  while continue_:
    addend = []
    for i, gen in enumerate(args):
      try:
        value = next(gen)
        addend.append(value)
      except StopIteration:
        genlist = list(args)
        args = tuple([chain([v], g) for v, g in zip(addend, genlist[:i])]+genlist[i:])
        continue_ = False
        break
    if len(addend)==n: result = chain(result, [tuple(addend)])
  return args, result

Voici un test de base:

    g1, g2 = (i for i in range(10)), (i for i in range(4))
    # Create (g1, g2), g3 first, then loop over g3 as one would with zip
    (g1, g2), g3 = safe_zip(g1, g2)
    for a, b in g3:
        print(a, b)#(0, 0) to (3, 3)
    for x in g1:
        print(x)#4 to 9

vous pouvez utiliser itertools.tee et itertools.islice :

from itertools import islice, tee

def zipped(gen1, gen2, pred=list):
    g11, g12 = tee(gen1)
    z = pred(zip(g11, gen2))

    return (islice(g12, len(z), None), gen2), z

gen1 = iter(range(10))
gen2 = iter(range(5))

(gen1, gen2), output = zipped(gen1, gen2)

print(output)
print(next(gen1))
# [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
# 5

Si vous souhaitez réutiliser du code, la solution la plus simple est:

from more_itertools import peekable

a = peekable(a)
b = peekable(b)

while True:
    try:
        a.peek()
        b.peek()
    except StopIteration:
        break
    x = next(a)
    y = next(b)
    print(x, y)


print(list(a), list(b))  # Misses nothing.

Vous pouvez tester ce code à l'aide de votre configuration:

def my_gen(n: int):
    yield from range(n)

a = my_gen(10)
b = my_gen(8)

Il imprimera:

0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
[8, 9] []

Je ne pense pas que vous puissiez récupérer la valeur perdue avec la boucle for de base, car l'itérateur épuisé, tiré de zip(..., ...).__iter__ suppression une fois épuisé et vous ne pouvez pas y accéder.

Vous devez muter votre zip, puis vous pouvez obtenir la position de l'élément déposé avec du code hacky)

z = zip(range(10), range(8))
for _ in iter(z.__next__, None):
    ...
_, (one, other) = z.__reduce__()
_, (i_one,), p_one = one.__reduce__() # p_one == current pos, 1 based
import itertools
val = next(itertools.islice(iter(i_one), p_one - 1, p_one))