What is the difference between chain and chain.from_iterable in itertools?
The first takes 0 or more arguments, each an iterable, the second one takes one argument which is expected to produce the iterables:
from itertools import chainchain(list1, list2, list3)iterables = [list1, list2, list3]chain.from_iterable(iterables)
but iterables
can be any iterator that yields the iterables:
def gen_iterables(): for i in range(10): yield range(i)itertools.chain.from_iterable(gen_iterables())
Using the second form is usually a case of convenience, but because it loops over the input iterables lazily, it is also the only way you can chain an infinite number of finite iterators:
def gen_iterables(): while True: for i in range(5, 10): yield range(i)chain.from_iterable(gen_iterables())
The above example will give you a iterable that yields a cyclic pattern of numbers that will never stop, but will never consume more memory than what a single range()
call requires.
I could not find any valid example ... where I can see the difference between them [
chain
andchain.from_iterable
] and why to choose one over the other
The accepted answer is thorough. For those seeking a quick application, consider flattening several lists:
list(itertools.chain(["a", "b", "c"], ["d", "e"], ["f"]))# ['a', 'b', 'c', 'd', 'e', 'f']
You may wish to reuse these lists later, so you make an iterable of lists:
iterable = (["a", "b", "c"], ["d", "e"], ["f"])
Attempt
However, passing in an iterable to chain
gives an unflattened result:
list(itertools.chain(iterable))# [['a', 'b', 'c'], ['d', 'e'], ['f']]
Why? You passed in one item (a tuple). chain
needs each list separately.
Solutions
When possible, you can unpack an iterable:
list(itertools.chain(*iterable))# ['a', 'b', 'c', 'd', 'e', 'f']list(itertools.chain(*iter(iterable)))# ['a', 'b', 'c', 'd', 'e', 'f']
More generally, use .from_iterable
(as it also works with infinite iterators):
list(itertools.chain.from_iterable(iterable))# ['a', 'b', 'c', 'd', 'e', 'f']g = itertools.chain.from_iterable(itertools.cycle(iterable))next(g)# "a"
They do very similar things. For small number of iterables itertools.chain(*iterables)
and itertools.chain.from_iterable(iterables)
perform similarly.
The key advantage of from_iterables
lies in the ability to handle large (potentially infinite) number of iterables since all of them need not be available at the time of the call.