Requires no additional copy of the iterable.

Standard implementation of cycle looks like:

def cycle(iterable): # v1
    # cycle('ABCD') --> A B C D A B C D A B C D ...
    saved = []
    for element in iterable:
        yield element
        saved.append(element)
    while saved:
        for element in saved:
              yield element

We propose to change it to

def cycle(iterable): # v2
    # cycle('ABCD') --> A B C D A B C D A B C D ...
    while True:
        for element in iterable:
              yield element

Drawback: a little incompatible with the previous cycle

v1 can accept an iteratable which can be iterated only once while v2 cannot.

Benefit: more memory-efficient

It doesn't require an additional copy.

I think v2 is better. If the caller wants to cycle through an iteratable (named it) which can be iterated only once, he can use cycle(list(it)). In most cases, the caller holds repeatable iterable, so cycle(it) is ok without additional memory consumption.

Benefit for DeepLearning

And there are cases where multiple iter calls to an iterable returns different iterators! The dataloader for DeepLearning is a perfect example:

# dl is a dataloader
first = [img, label for img, label in dl]
second = [img, label for img, label in dl]
assert first[0] != second[0]

What's more, in DeepLearning, it is not possible to store the whole dataset in memory, but the dataloader can be called multiple times to get the iterator:

# v1
cycle(dl) # memory not enough

# v2
cycle(dl) # no problem

So I hope we can get this more memory efficient cycle :)