What does Python's enumerate() yield, and what does its start argument change?

## What the built-in actually returns `enumerate` is a built-in callable with the signature `enumerate(iterable, start=0)`. Calling it does **not** produce a list and does not consume the input; it constructs an **enumerate object**, which is itself an iterator. Each time that iterator is advanced, it pulls exactly one item from the wrapped iterable and yields a two-element tuple: the current count first, the item second. When the wrapped iterable is exhausted, the enumerate object raises `StopIteration` in the normal way and the surrounding `for` loop ends. The tuple order matters and is a common slip: it is `(count, item)`, not `(item, count)`. In practice you rarely see the tuple, because the `for` statement's target list unpacks it for you: ```python for position, name in enumerate(["ada", "grace", "alan"]): print(position, name) ``` If the items are themselves tuples, nest the target: `for i, (key, value) in enumerate(mapping.items()):`. ## The start argument `start` is the value the counter takes on the first yielded tuple; it defaults to `0`. `enumerate(rows, start=1)` yields `(1, rows[0])`, `(2, rows[1])`, and so on. It may be passed positionally (`enumerate(rows, 1)`) or by keyword, and it accepts any integer, including negative values. The crucial point — and the one an interviewer is usually probing — is that `start` changes **only the counter**. It does not skip an element, it does not slice the input, and it does not alter the items. `enumerate(rows, start=1)` and `enumerate(rows)` walk exactly the same elements in exactly the same order; only the numbers differ. This makes `start=1` the right tool for human-facing output such as report line numbers or ranked output, where people count from one. The corollary is the off-by-one trap: once you have chosen `start=1`, the counter is no longer a valid index into the original sequence. Code that writes `rows[position]` inside a loop opened with `start=1` reads the wrong element and, on the last pass, raises `IndexError`. If you need both a display number and an index, either keep `start=0` and add one at the point of display, or bind two names. There is no `step` parameter. The counter always advances by exactly one per item. Anyone who wants every second item is describing slicing or a different iteration tool, not `enumerate`. ## Why laziness matters Because `enumerate` is an iterator wrapper rather than a sequence builder, it composes with things that have no length and no indexing at all: an open text file iterated line by line, a generator, a network reader, an object that produces items one at a time and cannot rewind. Numbering those with subscripts is impossible; numbering them with `enumerate` is one word. It also means no intermediate list is built, so memory stays flat no matter how long the stream is. The other side of laziness is single use. An enumerate object is consumed as you walk it; a second `for` over the same object yields nothing, because both the counter and the underlying iterable are already exhausted. If you genuinely need the pairs twice, materialise them once with `list(enumerate(items))` — that gives a real list of tuples you can iterate repeatedly, index and slice. ## What gets enumerated `enumerate` numbers whatever the iterable yields — nothing more. Over a `dict` it yields `(count, key)`, because iterating a dict yields keys; to number key/value pairs you enumerate `mapping.items()`. Over a `str` it yields `(count, character)`. Over a file object it yields `(count, line)`, with the line's trailing newline still attached. Over a `set` it yields the elements in the set's iteration order, which is not insertion order and should not be relied on for stable numbering. ## Reading the result correctly A quick self-check that catches most misuse: the counter is *produced by* `enumerate`, and the item is produced by the underlying iterable; they are independent. `start` touches the first. Slicing, filtering or reversing the input touches the second. Confusing the two is what produces reports whose numbering restarts, skips or runs one ahead of the data it labels. One last detail worth knowing: iterating `enumerate(seq)` avoids the repeated subscript lookups that a manual counter plus indexing would perform, and it removes the hand-maintained `i += 1` line that is easy to forget inside a branch. That readability argument, not raw speed, is the reason style guides reach for it by default.