Vad är skillnaden mellan lists, tuples och dictionaries?

Question

Accepted Answer

Dessa tre är Pythons mest använda collections, var och en lämpad för olika behov. De viktigaste skillnaderna är **mutabilitet**, **ordning** och **hur du får åtkomst till element**.

## List — ordnad, muterbar sekvens

```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
```

Använd en **list** för en ordnad samling som ändras — lägg till, ta bort, sortera om objekt.

## Tuple — ordnad, oförändrad sekvens

```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
```

Använd en **tuple** för en fast grupp värden som inte bör ändras — koordinater, poster, funktionsretur med flera värden. Eftersom tuples är oförändringsbar kan de också vara **dict keys** och är något mer minneseffektiva.

## Dict — nyckel-värde-mappning

```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
```

Använd en **dict** för att mappa nycklar till värden för snabb sökning efter namn (O(1)). Sedan Python 3.7 bevarar dicts insättningsordningen.

## Jämförelse

```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
```

## Varför det är viktigt

Att välja rätt samling är ett grundläggande, dagligt Python-beslut som påverkar korrekthet, prestanda och avsikt.

Lists för muterbar ordnad data, tuples för fasta/oförändringsbar poster (och dict keys), dicts för snabb nyckelbaserad sökning — att använda rätt sort kommunicerar avsikt (en tuple signalerar "detta ändras inte") och ger rätt prestanda-egenskaper (dict O(1) sökningar jämfört med list O(n) sökning).

Att missbruka dem (t.ex. söka igenom en list när en dict lookup passar) är en vanlig källa till långsam eller otydlig kod.