Egy nem változtatható objektum nem módosítható létrehozása után; egy változtatható objektum módosítható. Ez a megkülönböztetés központi a Python számára, és hatással van az aliasing-re, a dict kulcsokra, a függvény argumentumokra, valamint a finom hibák egy osztályára.
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable: list, dict, set, bytearray, and most custom objects
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
A nem változtatható objektumok esetében az olyan műveletek, amelyek úgy tűnnek, hogy "megváltoztatják" az értéket, valójában egy új objektumot hoznak létre és újra kötik a változót. Az eredeti soha nem módosul.
lst = [1, 2, 3]
lst.append(4) # modifies the SAME list object → [1, 2, 3, 4]
lst[0] = 99 # in-place change
# 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[:]
Egy változtatható objektum hozzárendelése nem másolja le — mindkét név ugyanarra az objektumra hivatkozik, így az egyiken keresztüli mutáció a másikra is hatással van. Ez sokan meglepetésére jár, és valós hibákat okoz.
d = {(1, 2): "point"} # ✅ tuple key — immutable, hashable
d = {[1, 2]: "x"} # ❌ TypeError — lists are unhashable (mutable)
A dict kulcsoknak és a halmaz tagoknak hash-eligéknek kell lenniük, amely nem változtathatóságot igényel (egy változtatható kulcs megváltozhat és megtörheti a hash táblázatot).
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
A változtathatóság egy alapvető Python koncepció, amely a viselkedés és hibák széles körét magyarázza: az aliasing csapda (a hozzárendelés nem másolja le a változtathatókat), miért módosíthatnak a függvények egy átadott listát, de nem int-et, miért lehetnek csak a nem változtatható objektumok dict kulcsok/halmaztagok, és a mutable-default-argument bukta.
Az, hogy mely típusok változtathatók vs nem változtathatók — és hogy a megosztott objektum mutációja az összes rá vonatkozó referenciát érinti — elengedhetetlen a helyes Python írásához és néhány leggyakoribb meglepetésének elkerüléséhez.