Mikä on ero muuttuvien ja muuttumattomien objektien välillä?

Question

Accepted Answer

**Muuttumaton** objekti ei voi muuttua luomisen jälkeen; **muuttuva** objekti voi muuttua. Tämä ero on keskeinen Pythonissa ja vaikuttaa aliasoitumiseen, dict-avaimiin, funktio-argumentteihin ja joukkoon hienovaraisia virheitä.

## Kaksi kategoriaa

```text
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable:   list, dict, set, bytearray, and most custom objects
```

## Muuttumaton: "muutos" luo uuden objektin

```python
x = "hello"
x.upper()       # returns a NEW string "HELLO" — x is unchanged
x += " world"   # rebinds x to a NEW string; the original "hello" is untouched

n = 5
n += 1          # creates a new int 6; doesn't modify the int object 5
```

Muuttumattomien kohdalla operaatiot, jotka näyttävät "muuttavan" arvoa, tuottavat itse asiassa uuden objektin ja sitouvat muuttujan uudelleen. Alkuperäinen ei koskaan muutu.

## Muuttuva: muutettu paikalla

```python
lst = [1, 2, 3]
lst.append(4)   # modifies the SAME list object → [1, 2, 3, 4]
lst[0] = 99     # in-place change
```

## Aliasoitumisen ansa (käytännön vaara)

```python
# mutable — two names point to the SAME object
a = [1, 2, 3]
b = a            # b is NOT a copy — it's the same list
b.append(4)
print(a)         # [1, 2, 3, 4] ← a changed too! (they're aliases)

# to actually copy:
b = a.copy()     # or list(a), or a[:]
```

Muuttuvan objektin antaminen ei kopioi sitä — molemmat nimet viittaavat samaan objektiin, joten muuttaminen toisen kautta vaikuttaa toiseen. Tämä yllättää monet ja aiheuttaa todellisia virheitä.

## Miksi muuttumattomat voivat olla dict keys / set members

```python
d = {(1, 2): "point"}   # ✅ tuple key — immutable, hashable
d = {[1, 2]: "x"}       # ❌ TypeError — lists are unhashable (mutable)
```

Dict keys ja set members täytyy olla **hashable**, mikä vaatii muuttumattomuutta (muuttuva avain voisi muuttua ja rikkoa hash-taulukon).

## Funktio-argumentit

```python
def modify(lst): lst.append(99)   # mutates the caller's list (passed by reference)
def rebind(n): n += 1             # rebinds locally; caller's int unchanged
```

## Miksi sillä on merkitystä

Muuttuvuus on perustavanlaatuinen Python-käsite, joka selittää laajan valikoiman käyttäytymistä ja virheitä: aliasoitumisen ansa (antaminen ei kopioi muuttuvia), miksi funktiot voivat muuttaa välitettyä listaa mutta eivät kokonaislukua, miksi vain muuttumattomat objektit voivat olla dict keys/set members, ja muuttuvan oletusargumentin ansa.

Ymmärtäminen siitä, mitkä tyypit ovat muuttuvia vs muuttumattomia — ja että jaetun objektin muuttaminen vaikuttaa kaikkiin siihen viittauksiin — on välttämätöntä oikean Pythonin kirjoittamiseksi ja joidenkin sen yleisimmistä yllätyksistä välttämiseksi.