બદલી ન શકાય તેવી વસ્તુ નિર્માણ પછી બદલી શકાતી નથી; બદલી શકાય તેવી વસ્તુ બદલી શકાય છે. આ તફાવત Python માટે કેન્દ્રીય છે અને aliasing, dict keys, ફંક્શન દલીલો, અને સૂક્ષ્મ બગ્સના વર્ગને અસર કરે છે.
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable: list, dict, set, bytearray, and most custom objects
x =
x.upper()
x +=
n =
n +=
બદલી ન શકાય તેવી વસ્તુઓ સાથે, તે કામગીરી જે "બદલવા" જેવી લાગે છે તે વાસ્તવમાં એક નવી વસ્તુ ઉત્પન્ન કરે છે અને ચલને પુનર્બંધિત કરે છે. મૂળ કોઈ પણ રીતે બદલાતું નથી.
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[:]
બદલી શકાય તેવી વસ્તુને સોંપવું તેને કૉપિ કરતું નથી — બંને નામો એક જ વસ્તુનો સંદર્ભ આપે છે, તેથી એક દ્વારા સંશોધન બીજાને અસર કરે છે. આ ઘણાને આશ્ચર્ય કરે છે અને વાસ્તવિક બગ્સ સર્જે છે.
d = {(1, 2): "point"} # ✅ tuple key — immutable, hashable
d = {[1, 2]: "x"} # ❌ TypeError — lists are unhashable (mutable)
Dict keys અને set સભ્યો hashable હોવા જોઈએ, જે અપરિવર્તનીયતાની આવશ્યકતા છે (એક બદલી શકાય તેવી key બદલી શકે છે અને hash table તોડી શકે છે).
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
બદલીતાતા એ એક મૂળભૂત Python ખ્યાલ છે જે વર્તનના વિશાળ શ્રેણી અને બગ્સને સમજાવે છે: aliasing ફંદો (સોંપણી બદલી શકાય તેવી વસ્તુઓની નકલ કરતું નથી), શા માટે ફંક્શનો પાસ કરેલી સૂચી બદલી શકે છે પરંતુ int નહીં, શા માટે ફક્ત અપરિવર્તનીય વસ્તુઓ dict keys/set સભ્યો હોઈ શકે છે, અને બદલી શકાય તેવી ડિફોલ્ટ દલીલ pitfall.
કયા પ્રકારો બદલી શકાય તેવી વિપરીત અપરિવર્તનીય છે તે સમજવું — અને તે શેર કરેલી વસ્તુને સંશોધિત કરવું તેની બધી સંદર્ભોને અસર કરે છે — સાચો Python લખવા અને તેની કેટલીક સૌથી સામાન્ય આશ્ચર્યો છોડવા માટે જરૂરી છે.