How does slicing work in Python?

Question

IT Interview Practice · Accepted Answer

**Slicing** extracts a portion of a sequence (list, tuple, string) using the syntax `sequence[start:stop:step]`. It's a powerful, concise feature used constantly in Python.

## Basic slicing

```python
nums = [0, 1, 2, 3, 4, 5]

nums[1:4]     # [1, 2, 3]   — start at index 1, up to (NOT including) 4
nums[:3]      # [0, 1, 2]   — from the start (start defaults to 0)
nums[3:]      # [3, 4, 5]   — to the end (stop defaults to len)
nums[:]       # [0, 1, 2, 3, 4, 5] — a full (shallow) COPY
```

The key rule: `start` is **inclusive**, `stop` is **exclusive** (`nums[1:4]` gives indices 1, 2, 3 — not 4).

## Negative indices count from the end

```python
nums[-1]      # 5  — last element
nums[-2]      # 4  — second to last
nums[-3:]     # [3, 4, 5] — last three elements
nums[:-1]     # [0, 1, 2, 3, 4] — everything except the last
```

## The step parameter

```python
nums[::2]     # [0, 2, 4]      — every 2nd element
nums[1::2]    # [1, 3, 5]      — every 2nd, starting at index 1
nums[::-1]    # [5, 4, 3, 2, 1, 0] — REVERSE the sequence (a famous idiom)
```

`nums[::-1]` reversing a sequence is one of the most recognizable Python idioms.

## Slicing strings

```python
s = "Hello"
s[1:4]        # "ell"
s[::-1]       # "olleH" — reverse a string
s[0]          # "H"
```

## Slice assignment (for mutable lists)

```python
nums = [0, 1, 2, 3, 4]
nums[1:3] = [10, 20, 30]   # replace a slice (can change length)
# nums → [0, 10, 20, 30, 3, 4]
```

## Slicing is safe (no IndexError)

```python
nums[10:20]   # [] — out-of-range slices return empty, don't crash (unlike nums[10])
```

Unlike single-index access (which raises `IndexError`), slicing gracefully returns what's available.

## Why it matters

Slicing is a ubiquitous, distinctly-Pythonic feature for extracting, copying, and reversing sequences cleanly.

Understanding the `start:stop:step` syntax (especially inclusive-start/exclusive-stop), negative indices (counting from the end), the reverse idiom (`[::-1]`), and that slices are safe (no crash on out-of-range) lets you manipulate lists and strings concisely and correctly.

It replaces verbose loops for common operations and appears throughout idiomatic Python code.

Basic slicing

Negative indices count from the end

The step parameter

Slicing strings

Slice assignment (for mutable lists)

Slicing is safe (no IndexError)

Why it matters

Related questions