What is the difference between lists, tuples and dictionaries?

Question

Accepted Answer

These three are Python's most-used collections, each suited to different needs. The key distinctions are **mutability**, **ordering**, and **how you access elements**.

## List — ordered, mutable sequence

```python
fruits = ["apple", "banana", "cherry"]
fruits[0]            # "apple" — index access
fruits.append("date") # ✅ mutable — can add/remove/change
fruits[1] = "berry"   # change in place
len(fruits)          # 4
```

Use a **list** for an ordered collection that changes — adding, removing, reordering items.

## Tuple — ordered, immutable sequence

```python
point = (3, 4)
point[0]             # 3 — index access (like a list)
point[0] = 5         # ❌ TypeError — tuples are IMMUTABLE
x, y = point         # unpacking — common use
```

Use a **tuple** for a fixed group of values that shouldn't change — coordinates, records, function returns of multiple values. Being immutable, tuples can also be **dict keys** and are slightly more memory-efficient.

## Dict — key-value mapping

```python
user = {"name": "Ann", "age": 30}
user["name"]              # "Ann" — access by KEY, not index
user["email"] = "a@x.com" # mutable — add/update
user.get("phone", "N/A")  # safe access with a default
for k, v in user.items(): ...  # iterate key-value pairs
```

Use a **dict** to map keys to values for fast lookup by name (O(1)). Since Python 3.7, dicts preserve insertion order.

## Comparison

```text
              List          Tuple         Dict
Mutable?      yes           no            yes
Ordered?      yes           yes           yes (insertion, 3.7+)
Access by     index         index         key
Syntax        [1, 2]        (1, 2)        {"k": v}
Use for       changing seq  fixed record  key→value lookup
Dict key?     no            yes           no
```

## Why it matters

Choosing the right collection is a fundamental, everyday Python decision affecting correctness, performance, and intent.

Lists for mutable ordered data, tuples for fixed/immutable records (and dict keys), dicts for fast key-based lookup — using the appropriate one communicates intent (a tuple signals "this won't change") and gives the right performance characteristics (dict O(1) lookups vs list O(n) search).

Misusing them (e.g. scanning a list when a dict lookup fits) is a common source of slow or unclear code.