Tuples — immutability, use cases — Hinglish notes

1.2.23 · Coding › Introduction to Programming (Python)

WHAT is a tuple?

Definition Tuple

Ek tuple ordered, immutable values ka collection hota hai, jo parentheses aur comma-separated items ke saath likha jaata hai:

point = (3, 4)
rgb   = (255, 128, 0)
single = (42,)      # one-element tuple NEEDS the trailing comma
empty  = ()

Ordered → items ki fixed positions hoti hain (point[0] is 3).
Immutable → creation ke baad aap elements change, add, ya delete nahi kar sakte.
Heterogeneous → mixed types rakh sakta hai: ("Asha", 21, 5.6).

Common mistake "Parentheses hi tuple banate hain."

Kyun sahi lagta hai: hum (3, 4) dekhte hain aur assume karte hain ki () hi matter karta hai. Sachai: comma tuple banata hai, parentheses nahi!

a = (3)     # this is just the int 3  (parens = grouping)
b = (3,)    # THIS is a 1-tuple
c = 3, 4    # also a tuple! → (3, 4)

Fix: single-element tuple ke liye hamesha trailing comma lagao.

WHY does immutability exist? (first-principles reasoning)

Programming languages humein collection ke do flavours deti hai purpose ke saath:

Lists — jab data time ke saath change hota ho (ek growing to-do list).
Tuples — jab data change nahi hona chahiye (ek fixed coordinate, ek date).

"Tuples dict keys ho sakte hain lekin lists kyun nahi" — derive karna

Ek dictionary ek key ko store karta hai usse ek number compute karke jo hash kehlata hai. Rule yeh hai:

$equal objects ⟹ equal hashes, forever$

Logic ka flow (ise derive karo):

Dict ek key ko uske hash se dhundhta hai, phir equality check karta hai.
Agar ek key ke contents change ho sakein, toh uska hash bhi change ho jaata.
Phir dict us entry ko "bhool" jaata — aap usse kabhi nahi dhoondh paate.
Isliye Python sirf hashable (effectively immutable) keys allow karta hai.
Tuples (of immutable items) immutable hain → hashable hain → ✅ valid keys.
Lists mutable hain → unhashable hain → ❌ TypeError.

d = {(0, 0): "origin"}     # works
d = {[0, 0]: "origin"}     # TypeError: unhashable type: 'list'

HOW tuples behave — jo operations aap kar sakte aur nahi kar sakte

Figure — Tuples — immutability, use cases

Formula Aap kya KAR SAKTE ho (read-only access)

Operation	Example	Result
Index	`t[0]`	pehla item
Slice	`t[1:3]`	ek naya tuple
Length	`len(t)`	count
Membership	`5 in t`	bool
Concatenate	`t1 + t2`	naya tuple
Repeat	`t * 3`	naya tuple
Unpack	`x, y = t`	vars mein assign
Count/Index	`t.count(4)`, `t.index(4)`	sirf 2 methods

Worked example Immutability in action — Yeh step kyun?

t = (1, 2, 3)
t[0] = 99          # ❌ TypeError

Yeh step kyun? Kisi index ko assignment Python se kehta hai ki slot 0 overwrite karo. Tuples slot writes forbid karte hain → error. Yahi defining behaviour hai yaad rakhne ke liye.

Common mistake "Immutable matlab deeply frozen."

Kyun sahi lagta hai: "aap tuple change nahi kar sakte" sunne mein total lagta hai. Sachai: immutability shallow hoti hai. Tuple ke slots fixed hain, lekin agar kisi slot mein ek mutable object (jaise list) ho, toh woh object phir bhi change ho sakta hai.

t = (1, [2, 3])
t[1].append(4)     # ✅ works! t is now (1, [2, 3, 4])
t[1] = [9]         # ❌ still TypeError (can't replace the slot)

Fix: "tuple immutable" = har slot kis object ko point karta hai yeh fixed hai, objects khud nahi.

Worked Examples

Worked example 1. Ek function se multiple values return karna

def min_max(nums):
    return min(nums), max(nums)   # packs into a tuple
 
lo, hi = min_max([4, 1, 9, 2])    # unpacks
print(lo, hi)   # 1 9

Yeh step kyun? return a, b tuples ka classic, idiomatic use hai — Python values ko pack karta hai, caller unhe unpack karta hai. Ek aisi list banane se behtar jo aap kabhi modify na karte.

Worked example 2. Variables swap karna (koi temp variable nahi chahiye)

a, b = 10, 20
a, b = b, a      # right side becomes (20, 10), then unpacks
print(a, b)      # 20 10

Yeh step kyun? Right-hand side b, a assignment se pehle ek temporary tuple (20, 10) banata hai, isliye koi helper variable nahi chahiye.

Worked example 3. Tuples ko dictionary keys ki tarah use karna (grid)

board = {}
board[(0, 0)] = "X"
board[(1, 2)] = "O"
print(board[(0, 0)])   # X

Yeh step kyun? Coordinates ek fixed pair hain jo kabhi identity nahi badalni chahiye → perfect immutable key. Yahan list [0,0] crash karega.

Worked example 4. Counting aur finding (tuples ke sirf do methods)

t = (5, 3, 5, 8, 5)
print(t.count(5))   # 3
print(t.index(8))   # 3  (position of first 8)

Yeh step kyun? Tuples sirf count aur index expose karte hain kyunki baaki har list method (append, sort, remove...) mutate karta — aur woh forbidden hai.

Tuple vs List — kab kya choose karein (80/20)

	Tuple	List
Syntax	`()`	`[]`
Mutable?	No	Yes
Hashable?	Yes (if items are)	No
Speed	Thoda faster/leaner	Zyada overhead
Methods	`count`, `index`	bahut saare (`append`…)

Active Recall

Recall Forecast-then-Verify (answer padhne se pehle predict karo)

type((5)) kya print karega? → <class 'int'> (koi comma nahi ⇒ tuple nahi).
Kya (1, [2]) dict key ho sakta hai? → Nahi — isme ek list hai, toh yeh unhashable hai.
Kya t + (1,) t ko modify karta hai? → Nahi — ek naya tuple banata hai.
Tuples ke sirf do methods kaunse hain? → count aur index.

Recall Feynman: ek 12-saal ke bacche ko samjhao

Socho glued-together lockers ki ek row. Tune har locker label kiya aur andar ek toy rakha. Kyunki woh glued hain, aap koi naya locker add nahi kar sakte ya koi nahi nikal sakte — yahi hai tuple: ordered aur locked. Ek list wheels wale lockers hain jo aap kabhi bhi rearrange kar sakte ho. Ab, agar tune ek open box of crayons ek glued locker ke andar rakha, toh aap locker move nahi kar sakte, lekin fir bhi aur crayons box mein daal sakte ho — isliye ek tuple jisme list ho, us list ko phir bhi change kiya ja sakta hai.

Connections

Lists — mutability, methods — mutable counterpart; inke beech choose karo.
Dictionaries — keys and values — tuples immutable keys ke taur par shine karte hain.
Sets — hashing & uniqueness — sirf hashable (tuple-like) items allowed hain.
Functions — return values — multiple returns actually tuples hote hain.
Mutable vs Immutable objects — parent concept (int, str, tuple vs list, dict, set).
Hashing in Python — kyun immutability dict keys enable karta hai.

Syntactically tuple ko kya define karta hai — parentheses ya comma?

Comma; parentheses optional grouping hain. 3, 4 ek tuple hai, (3) sirf ek int hai.

Ek one-element tuple kaise likhte hain?

Trailing comma ke saath: (42,).

Tuples dictionary keys kyun ho sakte hain lekin lists nahi?

Tuples immutable hain → hashable (stable hash), lists mutable hain → unhashable, toh woh dict ka lookup tod denge.

t[0] = 5 kisi tuple par kaunsa error deta hai?

TypeError — tuples item assignment support nahi karte.

Tuple immutability deep hoti hai ya shallow?

Shallow — slots fixed hain, lekin andar rakha koi mutable object (jaise list) phir bhi modify ho sakta hai.

Sirf do tuple methods ke naam batao.

count aur index.

Kya t = t + (9,) original tuple ko mutate karta hai?

Nahi — ek naya tuple banata hai aur name t ko rebind karta hai.

a, b = b, a swap andar se kaise kaam karta hai?

Right side b, a ek temporary tuple mein pack hota hai, phir a aur b mein unpack hota hai.

Tuple ko list ke upar kab prefer karna chahiye (80/20 rule)?

Fixed records ke liye, dict/set keys ke liye, aur aisi data ke liye jo accidentally change nahi honi chahiye.

Jo function return min(x), max(x) karta hai woh actually kya return karta hai?

Ek tuple (min, max) jo caller unpack kar sakta hai.