itertools.repeat VS itertools.cycle

Question

Is there any difference between itertools.repeat(n) and itertools.cycle(n) ? As it seems, they produce the same output. Is one more efficient to use in a situation where I need an infinite loop of some element?

Answer 1

Simply, itertools.repeat will repeat the given argument, and itertools.cycle will cycle over the given argument. Don't run this code, but for example:

from itertools import repeat, cycle

for i in repeat('abcd'): print(i)
# abcd, abcd, abcd, abcd, ...

for i in cycle('abcd'): print(i)
# a, b, c, d, a, b, c, d, ...

Answer 2

These are equivalent but the first is clearer and a little faster:

it = repeat(x)
it = cycle([x])

However, cycle has the option of repeating entire sequences:

it = cycle(['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'])

And repeat has the option of setting a limit on the number of repetitions:

it = repeat(x, 5)         # Return five repetitions of x

Also, the intended use cases are different.

In particular, repeat was designed to provided a repeated argument to a mapped function:

it = imap(pow, repeat(2), range(10))

While cycle is intended for cyclic recurring behaviors. Here is a Python 3 example that returns 1/1 - 1/3 + 1/5 - 1/7 + 1/9 + ... :

it = accumulate(map(operator.truediv, cycle([1, -1]), count(1, 2)))

The latter example shows how all the parts fit together the create an "iterator algebra".

Hope you found this to be illuminating :-)

Answer 3

itertools.cycle() takes an iterator . You can't do, for example, itertools.cycle(5) - this will throw an error:

>>> itertools.cycle(3)
Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

itertools.repeat() will repeat the same element over and over again - it is not designed to iterate through the elements of an iterator. It is very good for returning the same object over and over again.

In other words, doing itertools.repeat([1,2,3], 5) does:

>>>>[i for i in itertools.repeat([1,2,3], 5)]
[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]

while doing itertools.cycle([1,2,3]) returns an infinite list that looks like [1,2,3,1,2,3,1,2,3,...] (or it least it would if you could fit it in memory somehow).

The difference is fairly profound.

Answer 4

Refer to the itertools documents to know the difference.

>>> import itertools
>>> help(itertools.repeat)
Help on class repeat in module itertools:

class repeat(__builtin__.object)
 |  repeat(object [,times]) -> create an iterator which returns the object
 |  for the specified number of times.  If not specified, returns the object
 |  endlessly.
 |
...
...

>>> help(itertools.cycle)
Help on class cycle in module itertools:

class cycle(__builtin__.object)
 |  cycle(iterable) --> cycle object
 |
 |  Return elements from the iterable until it is exhausted.
 |  Then repeat the sequence indefinitely.
 |

Answer 5

itertools.repeat returns the same object over and over again, and itertools.cycle iterates over the same object over and over again. So:

import itertools

# Warning: infinite loop ahead
for x in itertools.repeat([1, 2, 3]):
    print(x)
    # [1, 2, 3], [1, 2, 3], ...

for x in itertools.cycle([1, 2, 3]):
    print(x)
    # 1, 2, 3, 1, 2, 3, ...

So if what you want is something that returns one object several times, use itertools.repeat ; and if it's something that loops over some different object use itertools.cycle .