enumerate, zip and reversed

## What enumerate actually is `enumerate` is a built-in type, not a function that builds a list. Calling `enumerate(iterable, start=0)` constructs an `enumerate` object: a lazy iterator that holds a reference to an iterator over your input plus one integer counter. Each time it is advanced it pulls the next value from the underlying iterator and hands back a two-tuple `(counter, value)`, then bumps the counter. Nothing is precomputed and nothing is copied, so the memory cost is constant no matter how long the input is. That design is why the idiom is preferred over `range(len(items))`. The `range(len(...))` form asks two things of the object that `enumerate` does not: that it report a length, and that it support integer subscripting. A list, tuple or string satisfies both. A generator object, an open file, a `zip` object, a network cursor or anything else that can only be walked forwards satisfies neither. Writing `for i in range(len(f))` over a file is simply a `TypeError`; `for lineno, line in enumerate(f, start=1)` is the canonical way to number lines while streaming. ## The two arguments The first argument is any iterable — anything `iter()` accepts. The second, `start`, is the initial value of the counter and defaults to `0`. It can be passed positionally or by keyword, and `start=1` is by far the most common non-default: report rows, line numbers, ranked results and anything a human will read are conventionally one-based. The single most important thing to be able to state in an interview is what `start` does *not* do. It does not skip elements, it does not step the counter by more than one, and it does not change which values are produced. `list(enumerate(['a', 'b'], start=1))` is `[(1, 'a'), (2, 'b')]` — both elements, offset numbering. If you need to skip the header of a feed you slice or advance the iterator explicitly; if you need to skip *and* number the rest, you combine the two, and then the counter no longer lines up with positions in the original sequence. That mismatch is worth saying out loud: once `start` is anything but `0`, the counter is a label, not a valid index. Using it as an index is a silent off-by-one. ## Unpacking in the loop header `for i, item in enumerate(items):` works because each yielded value is a tuple and the `for` statement performs ordinary tuple unpacking. That composes: if the elements are themselves pairs, nested unpacking reads cleanly. ```python rows = [("sku-1", 4), ("sku-2", 9)] for position, (sku, count) in enumerate(rows, start=1): print(position, sku, count) ``` If you forget to unpack, the loop variable is the whole tuple, and the usual symptom is a confusing `TypeError` when you try to use it as a string or a number. ## When range(len(...)) is still right The idiom is not banned. Three cases keep it honest. First, when you want positions but not values at all — for instance building a list of indices that satisfy some property computed elsewhere. Second, when you must assign back into the sequence during the walk: `items[i] = transform(items[i])` needs the index, and `enumerate` gives you a *copy of the reference* to the element, not a writable slot, so rebinding the loop variable changes nothing in the list. Third, when you are stepping over a sequence with a stride or pairing an index against a second structure by position, where explicit arithmetic is clearer than a counter. Outside those, `enumerate` is the more general tool: it works on iterables with no length, it removes the repeated subscript from the body, and it keeps the counter and the value visibly in step. ## Cost and behaviour notes The object is an iterator, so it produces each pair on demand; you can wrap it around an unbounded source and stop early with `break`. It composes with anything that takes an iterable — `dict(enumerate(names))` builds a position-to-name mapping, and `sorted`, `min` and `max` accept the pairs directly, comparing counter first and value second, which is occasionally exactly what you want and occasionally a surprise.