What can slice assignment lst[1:3] = [...] do on a Python list that lst[1] = x cannot?

### Two different operations that share a syntax `lst[1] = x` compiles to `__setitem__(1, x)` and does one thing: it puts a new object at position 1. The length is unchanged, the object previously there is dropped, and everything else is untouched. `lst[1:3] = value` compiles to `__setitem__(slice(1, 3), value)` and is a splice: the region between the two bounds is removed and the items of `value` are put in its place. Because the count on the right need not match the count removed, the list's length can change: ```python lst = [0, 1, 2, 3, 4] lst[1:3] = ["a", "b", "c"] # removed 2, inserted 3 # lst is now [0, 'a', 'b', 'c', 3, 4] ``` That single capability — changing length in the middle — is the whole answer to the question, and everything below is a consequence of it. ### Insertion and deletion are the degenerate cases An empty target region inserts without removing: `lst[2:2] = [x, y]` puts two items before the old position 2. An empty right-hand side removes without inserting: `lst[1:3] = []` deletes that region, and `del lst[1:3]` says the same thing more directly through `__delitem__`. Recognising these two forms is what lets you read splicing code that would otherwise look cryptic. ### The right-hand side is an iterable, and that is a trap Slice assignment accepts *any* iterable and consumes it, so a generator, a `range` or a set all work. The trap is that a string is an iterable of characters: ```python lst[0:1] = "hi" # splices in 'h' and 'i', two items ``` Developers who mean "put this string at position 0" want `lst[0] = "hi"`. Assigning a non-iterable to a slice raises `TypeError` — the message says a list can only be assigned an iterable — which at least catches `lst[0:1] = 5` immediately. ### Extended slices are strict When the step is not 1, the arithmetic no longer allows a length change, because the selected positions are scattered and there is nowhere to put a surplus. So an extended-slice assignment demands an exact match: ```python lst = ["a", "c", 4] lst[::2] = [1, 2, 3] # ValueError: attempt to assign sequence of size 3 to extended slice of size 2 ``` Deletion has no such restriction: `del lst[::2]` removes every other element and is a perfectly ordinary operation. That asymmetry — assignment strict, deletion free — is a favourite follow-up. ### `lst[:] = other` versus `lst = other` This is the reason slice assignment shows up in real code that is not doing splicing at all. `lst = other` rebinds a name and leaves the original list object alone; anything else holding a reference to it — a module-level registry, an attribute another object captured, a default argument — still sees the old contents. `lst[:] = other` mutates the existing list in place, replacing all of its contents while preserving its identity, so every reference sees the new state: ```python shared = [1, 2, 3] alias = shared shared[:] = [9, 9] # alias is [9, 9] and alias is shared ``` That is the idiomatic way to refill a list other code already holds. It is also the reason a careless `lst[:] = ...` inside a helper can surprise a caller who expected the helper to be pure. ### What supports it, and what it costs Slice assignment and `del` with a slice require a **mutable** sequence. `list` and `bytearray` support them; `str` and `tuple` raise `TypeError`, because there is no way to change an immutable object in place. A custom class supports them only if it implements `__setitem__` and `__delitem__` and handles a `slice` key. Cost is worth stating at senior level: when the region's length changes, the tail of the list must shift, so a splice near the front of a large list is O(n), not O(k). Repeatedly splicing at position 0 inside a loop is quadratic, and a different structure — or building a new list once — is usually the right answer. ### How to describe it in an interview Say it in three beats. Index assignment replaces one element and the length is fixed. Slice assignment replaces a region with the items of an iterable, so insertion, deletion and resizing are all the same operation. And extended slices are the exception: with a step, the counts must match exactly, though `del` remains unrestricted.