How to slice a generator object or iterator?

Question

I would like to loop over a \"slice\" of an iterator. I\'m not sure if this is possible as I understand that it is not possible to slice an iterator. What I would like to do

Answer 1

let's clarify something first. Spouse you want to extract the first values ​​from your generator, based on the number of arguments you specified to the left of the expression. Starting from this moment, we have a problem, because in Python there are two alternatives to unpack something.

Let's discuss these alternatives using the following example. Imagine you have the following list l = [1, 2, 3]

1) The first alternative is to NOT use the "start" expression

a, b, c = l # a=1, b=2, c=3

This works great if the number of arguments at the left of the expression (in this case, 3 arguments) is equal to the number of elements in the list. But, if you try something like this

a, b = l # ValueError: too many values to unpack (expected 2)

This is because the list contains more arguments than those specified to the left of the expression

2) The second alternative is to use the "start" expression; this solve the previous error

a, b, c* = l #  a=1, b=2, c=[3]

The "start" argument act like a buffer list. The buffer can have three possible values:

    a, b, *c = [1, 2] # a=1, b=2, c=[]
    a, b, *c = [1, 2, 3] # a=1, b=2, c=[3]
    a, b, *c = [1, 2, 3, 4, 5] # a=1, b=2, c=[3,4,5]

Note that the list must contain at least 2 values (in the above example). If not, an error will be raised

Now, jump to your problem. If you try something like this:

a, b, c = generator

This will work only if the generator contains only three values (the number of the generator values must be the same as the number of left arguments). Elese, an error will be raise.

If you try something like this:

a, b, *c = generator

• If the number of values in the generator is lower than 2; an error will be raise because variables "a", "b" must have a value
• If the number of values in the generator is 3; then a=, b=(val_2>, c=[]
• If the numeber of values in the generator is greater than 3; then a=, b=(val_2>, c=[, ... ] In this case, if the generator is infinite; the program will be blocked trying to consume the generator

What I propose for you is the following solution

# Create a dummy generator for this example
def my_generator():
i = 0
while i < 2:
    yield i
    i += 1

# Our Generator Unpacker
class GeneratorUnpacker:
    def __init__(self, generator):
        self.generator = generator

    def __iter__(self):
        return self

    def __next__(self):
        try:
            return next(self.generator)
        except StopIteration:
            return None # When the generator ends; we will return None as value

if __name__ == '__main__':
    dummy_generator = my_generator()
    g =  GeneratorUnpacker(dummy_generator )
    a, b, c = next(g), next(g), next(g)