chain(*iterables) walks the first iterable to exhaustion, then the next, and so on, yielding each element exactly once. It accepts any iterable, so you can mix lists, tuples, ranges, and strings without converting them first. Because the result is a lazy iterator, calling next() advances it and a list(...) cast materializes whatever is left. Use chain whenever you find yourself writing a + b + c and one of the operands is not a list, since chain skips the intermediate copies.

Calling chain(rows) with a single iterable-of-iterables yields the outer iterable itself, which is rarely what you want. chain.from_iterable(rows) is the canonical 'flatten exactly one level' helper: it lazily walks each inner iterable in turn. The chain(*rows) form does the same thing but materializes the argument tuple, so prefer from_iterable when the outer container is huge or itself a generator. This is the right pattern for flattening pages of API results, batched rows from a database cursor, or per-file tokens from a directory walk.

chain.from_iterable only removes one level of nesting and assumes every top-level item is iterable. If your data is a ragged tree (mixed scalars and sub-lists, arbitrary depth), chain is the wrong tool and will raise TypeError on the first scalar. The standard fix is a small recursive generator that uses yield from for sub-lists and yield for leaves. Pick the simplest tool that fits: chain for predictable two-level data, recursion only when depth varies.