Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Python Tuples का complete guide – immutability, creation, packing/unpacking, named tuples, tuple vs list comparison, use cases, और interview questions हिंदी में।
Introduction (परिचय)
Tuple एक ordered, immutable sequence है। एक बार बनाने के बाद इसके elements change नहीं किए जा सकते।
Key Properties: - 🔒 Immutable – Create होने के बाद elements बदल नहीं सकते - ✅ Ordered – Elements का order maintain होता है - ✅ Allows Duplicates - ✅ Heterogeneous – Different types allowed - ✅ Hashable – Dictionary key बन सकती है (if all elements hashable) - ⚡ Faster than List – Less overhead
2. Indexing and Slicing
Tuple indexing और slicing exactly list जैसी है।
Example
colors = ("red", "green", "blue", "yellow", "purple")
# Positive indexing
print(colors[0]) # red
print(colors[2]) # blue
print(colors[-1]) # purple (last)
print(colors[-2]) # yellow
# Slicing
print(colors[1:4]) # ('green', 'blue', 'yellow')
print(colors[:3]) # ('red', 'green', 'blue')
print(colors[::2]) # ('red', 'blue', 'purple')
print(colors[::-1]) # ('purple', 'yellow', 'blue', 'green', 'red')
# Nested tuple indexing
matrix = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
print(matrix[0]) # (1, 2, 3)
print(matrix[1][2]) # 6
print(matrix[-1][-1]) # 9
Output:
Example
red
blue
purple
yellow
('green', 'blue', 'yellow')
('red', 'green', 'blue')
('red', 'blue', 'purple')
('purple', 'yellow', 'blue', 'green', 'red')
(1, 2, 3)
6
9
3. Immutability (अपरिवर्तनीयता)
Example
nums = (1, 2, 3, 4, 5)
# ❌ इन operations से TypeError आएगा:
try:
nums[0] = 99
except TypeError as e:
print(f"Error: {e}")
# Error: 'tuple' object does not support item assignment
try:
del nums[1]
except TypeError as e:
print(f"Error: {e}")
# Error: 'tuple' object doesn't support item deletion
try:
nums.append(6)
except AttributeError as e:
print(f"Error: {e}")
# Error: 'tuple' object has no attribute 'append'
# ✅ Tuple को "modify" करने का सही तरीका (new tuple create करें)
nums = (1, 2, 3)
modified = nums[:1] + (99,) + nums[2:]
print(modified) # (1, 99, 3)
# Converting: tuple → list → modify → tuple
nums = (1, 2, 3, 4, 5)
temp = list(nums)
temp[2] = 99
nums = tuple(temp)
print(nums) # (1, 2, 99, 4, 5)
# Note: Mutable elements inside tuple CAN be changed
t = (1, [2, 3], 4)
t[1].append(99) # list is mutable!
print(t) # (1, [2, 3, 99], 4)
Output:
| Error | 'tuple' object does not support item assignment |
| Error | 'tuple' object doesn't support item deletion |
| Error | 'tuple' object has no attribute 'append' |
4. Tuple Packing & Unpacking
Python की सबसे powerful features में से एक।
Example
# Packing – multiple values → one tuple
point = 10, 20 # (10, 20)
person = "Alice", 25, "Engineer" # ('Alice', 25, 'Engineer')
# Unpacking – tuple → multiple variables
x, y = 10, 20
print(x, y) # 10 20
name, age, job = ("Bob", 30, "Developer")
print(name, age, job) # Bob 30 Developer
# Swap variables (classic Python trick!)
a, b = 5, 10
a, b = b, a # tuple pack/unpack
print(a, b) # 10 5
# Extended unpacking with *
first, *rest = (1, 2, 3, 4, 5)
print(first) # 1
print(rest) # [2, 3, 4, 5]
*start, last = (1, 2, 3, 4, 5)
print(start) # [1, 2, 3, 4]
print(last) # 5
a, *b, c = (1, 2, 3, 4, 5)
print(a, b, c) # 1 [2, 3, 4] 5
# Nested unpacking
(x1, y1), (x2, y2) = (1, 2), (3, 4)
print(x1, y1, x2, y2) # 1 2 3 4
# Unpack in for loop
points = [(1, 2), (3, 4), (5, 6)]
for x, y in points:
print(f"x={x}, y={y}")
Output:
Example
10 20
Bob 30 Developer
10 5
1
[2, 3, 4, 5]
[1, 2, 3, 4]
5
1 [2, 3, 4] 5
1 2 3 4
x=1, y=2
x=3, y=4
x=5, y=6
5. Tuple Methods (Only 2!)
Tuples के पास सिर्फ 2 methods हैं (immutable होने के कारण):
python example
nums = (1, 2, 3, 2, 4, 2, 5, 1)
# count() – occurrences गिनना
print(nums.count(2)) # 3
print(nums.count(1)) # 2
print(nums.count(9)) # 0
# index() – पहली occurrence का index
print(nums.index(2)) # 1
print(nums.index(1)) # 0
# index with start and end
print(nums.index(2, 2)) # 3 (index 2 से search)
print(nums.index(2, 2, 6)) # 3 (index 2-5 में search)
# ValueError if not found
try:
nums.index(99)
except ValueError:
print("Not found!") # Not found!Output:
Example
3
2
0
1
0
3
3
Not found!
Tuple Methods vs List Methods
| Method | Tuple | List |
|---|---|---|
count() | ✅ | ✅ |
index() | ✅ | ✅ |
append() | ❌ | ✅ |
extend() | ❌ | ✅ |
insert() | ❌ | ✅ |
remove() | ❌ | ✅ |
pop() | ❌ | ✅ |
sort() | ❌ | ✅ |
reverse() | ❌ | ✅ |
clear() | ❌ | ✅ |
copy() | ❌ | ✅ |
6. Tuple as Dictionary Key
Tuples hashable हैं (अगर सभी elements hashable हों), इसलिए dictionary keys बन सकती हैं।
Example
# Tuples as keys
locations = {}
locations[(28.6139, 77.2090)] = "New Delhi"
locations[(19.0760, 72.8777)] = "Mumbai"
locations[(12.9716, 77.5946)] = "Bangalore"
print(locations[(28.6139, 77.2090)]) # New Delhi
# Grid/graph coordinates
grid = {}
grid[(0, 0)] = "start"
grid[(1, 0)] = "path"
grid[(2, 2)] = "end"
for (r, c), val in grid.items():
print(f"({r},{c}) → {val}")
# ❌ List cannot be a key (unhashable)
try:
d = {[1, 2]: "value"}
except TypeError as e:
print(f"Error: {e}") # unhashable type: 'list'
# ✅ But tuple can
d = {(1, 2): "value"}
print(d[(1, 2)]) # value
Output:
| (0,0) | start |
| (1,0) | path |
| (2,2) | end |
| Error | unhashable type: 'list' |
7. Named Tuples (namedtuple)
collections.namedtuple से readable tuples बनाएं।
Example
from collections import namedtuple
# Define named tuple
Point = namedtuple('Point', ['x', 'y'])
Person = namedtuple('Person', ['name', 'age', 'city'])
Color = namedtuple('Color', 'red green blue') # space-separated string also works
# Create instances
p = Point(3, 4)
person = Person("Alice", 25, "Delhi")
c = Color(255, 128, 0)
# Access by name (readable!)
print(p.x, p.y) # 3 4
print(person.name) # Alice
print(person.age) # 25
print(c.red, c.green) # 255 128
# Still tuple – access by index
print(p[0], p[1]) # 3 4
# Named tuple methods
print(p._asdict()) # OrderedDict([('x', 3), ('y', 4)])
print(person._fields) # ('name', 'age', 'city')
# _replace() – create modified copy
p2 = p._replace(x=10)
print(p2) # Point(x=10, y=4)
print(p) # Point(x=3, y=4) ← unchanged
# Unpack like regular tuple
x, y = p
print(x, y) # 3 4
# Use case: function returning multiple values
def get_stats(nums):
return (min(nums), max(nums), sum(nums)/len(nums))
Stats = namedtuple('Stats', ['minimum', 'maximum', 'average'])
def get_stats_named(nums):
return Stats(min(nums), max(nums), sum(nums)/len(nums))
data = [1, 2, 3, 4, 5]
s = get_stats_named(data)
print(f"Min: {s.minimum}, Max: {s.maximum}, Avg: {s.average}")
# Min: 1, Max: 5, Avg: 3.0
Output:
Example
3 4
Alice
25
255 128
3 4
OrderedDict([('x', 3), ('y', 4)])
('name', 'age', 'city')
Point(x=10, y=4)
Point(x=3, y=4)
3 4
Min: 1, Max: 5, Avg: 3.0
8. Tuple Operations
python example
t1 = (1, 2, 3)
t2 = (4, 5, 6)
# Concatenation (new tuple)
t3 = t1 + t2
print(t3) # (1, 2, 3, 4, 5, 6)
# Repetition
t4 = t1 * 3
print(t4) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
# Membership
print(2 in t1) # True
print(7 in t1) # False
# Length, min, max, sum
nums = (3, 1, 4, 1, 5, 9)
print(len(nums)) # 6
print(min(nums)) # 1
print(max(nums)) # 9
print(sum(nums)) # 23
# Comparison (lexicographic)
print((1, 2, 3) == (1, 2, 3)) # True
print((1, 2, 3) < (1, 2, 4)) # True
print((1, 2) < (1, 2, 3)) # True
# Iteration
for item in (10, 20, 30):
print(item, end=" ") # 10 20 30
print()
# zip with tuple
names = ("Alice", "Bob")
scores = (95, 87)
for name, score in zip(names, scores):
print(f"{name}: {score}")Output:
Example
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
True
False
6
1
9
23
True
True
True
10 20 30
Alice: 95
Bob: 87
9. Performance: Tuple vs List
Example
import sys
import timeit
# Memory comparison
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
tup = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(f"List size: {sys.getsizeof(lst)} bytes") # 184 bytes (approx)
print(f"Tuple size: {sys.getsizeof(tup)} bytes") # 136 bytes (approx)
# Speed comparison
list_time = timeit.timeit("[1,2,3,4,5,6,7,8,9,10]", number=1_000_000)
tuple_time = timeit.timeit("(1,2,3,4,5,6,7,8,9,10)", number=1_000_000)
print(f"List creation: {list_time:.4f}s")
print(f"Tuple creation: {tuple_time:.4f}s")
# Tuple is ~5x faster to create!
Performance Summary:
| Aspect | Tuple | List |
|---|---|---|
| Memory | Less (~30% less) | More |
| Creation | Faster | Slower |
| Access | Same O(1) | Same O(1) |
| Iteration | Slightly faster | Slightly slower |
| Modification | Not allowed | O(1)/O(n) |
| As dict key | ✅ Yes | ❌ No |
| Thread safety | ✅ Safer | ❌ Needs locking |
10. Use Cases (कब उपयोग करें)
Example
# 1. Fixed data (constants)
RGB_RED = (255, 0, 0)
RGB_GREEN = (0, 255, 0)
RGB_BLUE = (0, 0, 255)
# 2. Multiple return values from function
def divmod_custom(a, b):
return a // b, a % b # returns tuple
quotient, remainder = divmod_custom(17, 5)
print(quotient, remainder) # 3 2
# 3. Enumerate (returns tuples)
fruits = ["apple", "banana", "cherry"]
for i, fruit in enumerate(fruits):
print(i, fruit)
# 4. Database records (rows as tuples)
users = [
(1, "Alice", "alice@email.com"),
(2, "Bob", "bob@email.com"),
(3, "Charlie","charlie@email.com"),
]
for id, name, email in users:
print(f"User {id}: {name} <{email}>")
# 5. Dictionary key (coordinates, grid, etc.)
visited = set()
visited.add((0, 0))
visited.add((1, 2))
print((0, 0) in visited) # True
# 6. String formatting
name, age = "Alice", 25
print("Name: %s, Age: %d" % (name, age)) # old-style formatting
11. Tuple Comprehension? (Generator)
Example
# ❌ Tuple comprehension नहीं होती!
t = (x**2 for x in range(5))
print(type(t)) # <class 'generator'> ← generator है!
print(t) # <generator object>
# ✅ tuple() के साथ wrap करें
t = tuple(x**2 for x in range(5))
print(t) # (0, 1, 4, 9, 16)
# Or use list comprehension then convert
lst = [x**2 for x in range(5)]
t = tuple(lst)
print(t) # (0, 1, 4, 9, 16)
12. Interview Questions (इंटरव्यू प्रश्न)
Q1: Tuple immutable होती है, फिर भी (1, [2, 3], 4) में list change हो सकती है?
हाँ! Tuple immutable का मतलब है tuple के references change नहीं होते। लेकिन अगर एक reference किसी mutable object (list) को point करता है, तो वह object internally change हो सकता है।
Q2: Empty tuple और single-element tuple में क्या difference?
python example
empty = ()
single = (1,) # trailing comma जरूरी
not_tuple = (1) # यह int है!Q3: Tuple को list में और list को tuple में convert?
python example
t = (1, 2, 3)
l = list(t) # tuple → list
t2 = tuple(l) # list → tupleQ4: Why are tuples faster than lists?
Tuples immutable होती हैं, इसलिए Python उन्हें optimize करता है – constant folding (same tuple code में सिर्फ एक बार create होती है), less memory allocation, simpler internal structure।
Q5: Tuple को sort कैसे करें?
python example
t = (3, 1, 4, 1, 5, 9)
sorted_t = tuple(sorted(t)) # (1, 1, 3, 4, 5, 9)
sorted_desc = tuple(sorted(t, reverse=True)) # (9, 5, 4, 3, 1, 1)Q6: Two tuples को merge कैसे करें?
Example
t1 = (1, 2, 3)
t2 = (4, 5, 6)
merged = t1 + t2 # (1, 2, 3, 4, 5, 6)
merged2 = (*t1, *t2) # (1, 2, 3, 4, 5, 6) [Python 3.5+]
Summary
| Feature | Tuple | List |
|---|---|---|
| Syntax | (1, 2, 3) | [1, 2, 3] |
| Mutable | ❌ No | ✅ Yes |
| Methods | 2 (count, index) | 11+ |
| Hashable | ✅ Yes | ❌ No |
| Memory | Less | More |
| Speed | Faster | Slower |
| Best for | Fixed data, dict keys, function return | Dynamic collections |
🎯 Rule of Thumb: जब data "should not change" तो Tuple use करें – records, coordinates, config values, function return values।
Output Blocks for Remaining Sections
Section 9 Output:
Output
List size: 184 bytes Tuple size: 136 bytes List creation: 0.0732s Tuple creation: 0.0118s
Section 10 Output:
Output
3 2 0 apple 1 banana 2 cherry User 1: Alice <alice@email.com> User 2: Bob <bob@email.com> User 3: Charlie <charlie@email.com> True Name: Alice, Age: 25
Section 11 Output:
Output
<class 'generator'> <generator object <genexpr> at 0x...> (0, 1, 4, 9, 16) (0, 1, 4, 9, 16)
⚠️ Common Mistakes (आम गलतियाँ)
❌ Mistake 1: Single Element Tuple बनाते वक्त comma भूलना
python example
# ❌ WRONG - यह tuple नहीं, integer है!
t = (42)
print(type(t)) # <class 'int'>
# ✅ RIGHT - trailing comma लगाओ
t = (42,)
print(type(t)) # <class 'tuple'>Output
<class 'int'> <class 'tuple'>
❌ Mistake 2: Tuple को modify करने की कोशिश
Example
# ❌ TypeError आएगा
t = (1, 2, 3)
t[0] = 99 # TypeError: 'tuple' object does not support item assignment
# ✅ New tuple बनाओ
t = (99,) + t[1:]
print(t) # (99, 2, 3)
Output
TypeError: 'tuple' object does not support item assignment (99, 2, 3)
❌ Mistake 3: Tuple comprehension समझना
python example
# ❌ यह generator है, tuple नहीं!
result = (x**2 for x in range(5))
print(type(result)) # <class 'generator'>
# ✅ tuple() से wrap करो
result = tuple(x**2 for x in range(5))
print(result) # (0, 1, 4, 9, 16)Output
<class 'generator'> (0, 1, 4, 9, 16)
❌ Mistake 4: Mutable elements inside tuple को safe समझना
Example
# ❌ Tuple immutable है, लेकिन अंदर का list change हो सकती है!
t = (1, [2, 3], 4)
t[1].append(99)
print(t) # (1, [2, 3, 99], 4) — changed!
# ✅ अगर truly immutable चाहिए तो nested tuples use करो
t = (1, (2, 3), 4) # अब कोई change नहीं हो सकता
Output
(1, [2, 3, 99], 4)
❌ Mistake 5: Unpacking में variable count mismatch
Example
# ❌ ValueError: too many/not enough values to unpack
t = (1, 2, 3)
# a, b = t # ValueError: too many values to unpack
# ✅ Star (*) unpacking use करो
a, *b = t
print(a, b) # 1 [2, 3]
Output
1 [2, 3]
❌ Mistake 6: List with mutable elements को dict key बनाना
Example
# ❌ TypeError - list containing tuple is unhashable
# d = {([1, 2], 3): "value"} # TypeError!
# ✅ Tuple of tuples use करो (सभी elements hashable हों)
d = {((1, 2), 3): "value"}
print(d) # {((1, 2), 3): 'value'}
Output
{((1, 2), 3): 'value'}❌ Mistake 7: += operator पर confusion
python example
# ❌ यह original tuple modify नहीं करता — new object बनता है!
t = (1, 2, 3)
print(id(t)) # कुछ id
t += (4, 5)
print(id(t)) # DIFFERENT id! (new tuple बना)
print(t) # (1, 2, 3, 4, 5)Output
140234567890 140234567999 (1, 2, 3, 4, 5)
✅ Key Takeaways (मुख्य बातें)
- 🔒 Tuple immutable है — एक बार बनाने के बाद elements add, remove, या change नहीं कर सकते।
- 📦 Tuple packing/unpacking Python की most powerful feature है — swap, multiple return values, और loop destructuring में बहुत काम आती है।
- ⚡ Tuple list से faster और lighter है — ~30% कम memory लेती है और creation ~5x तेज़ होता है।
- 🔑 Tuple hashable है — dictionary keys और set elements बन सकती है (अगर सभी elements hashable हों)।
- 📝 Single element tuple में trailing comma ज़रूरी है —
(42,)tuple है,(42)सिर्फ int! - 🛠️ Tuple के पास सिर्फ 2 methods हैं —
count()औरindex(), क्योंकि modify करने वाली methods की ज़रूरत नहीं। - 🏷️ Named tuples readability बढ़ाती हैं —
point.xबहुत clearer हैpoint[0]से। - 🎭 Mutable objects inside tuple change हो सकते हैं — tuple references को protect करती है, objects को नहीं।
- 🔄 Tuple को "modify" करने के लिए — list में convert करो, change करो, फिर tuple में वापस convert करो।
- 📊 Use tuple when data should not change — coordinates, RGB values, database records, config constants।
❓ FAQ (अक्सर पूछे जाने वाले सवाल)
Q1: Tuple और List में कब कौनसी use करें?
Tuple use करें जब data fixed हो और change नहीं होना चाहिए — जैसे coordinates(x, y), RGB colors(255, 0, 0), database records, function return values। List use करें जब data dynamic हो और add/remove/modify करना हो — जैसे shopping cart, to-do list, growing collections।
Q2: क्या Tuple को sort किया जा सकता है?
हाँ! लेकिन in-place नहीं (.sort()available नहीं)।sorted()function use करें जो new sorted tuple return करता है: ``python t = (3, 1, 4, 1, 5) sorted_t = tuple(sorted(t)) # (1, 1, 3, 4, 5)``
Q3: Tuple में duplicate values allowed हैं?
हाँ! Tuple ordered sequence है, duplicates पूरी तरह allowed हैं: ``python t = (1, 2, 2, 3, 3, 3) print(t.count(3)) # 3 ``Q4: Tuple hashable कब नहीं होती?
जब tuple के अंदर कोई mutable (unhashable) element हो — जैसे list: ``python t = (1, [2, 3]) # यह hashable नहीं है! # hash(t) → TypeError: unhashable type: 'list' ``Q5: namedtuple और regular class में क्या difference है?
namedtuple lightweight, immutable, और memory-efficient है। Regular class में methods, inheritance, mutability सब मिलता है। जब simple data container चाहिए (no methods), namedtuple best है। Complex behavior के लिए class use करें।Q6: Tuple अंदर list change हो सकती है — तो immutable का मतलब क्या?
Immutable = tuple object itself change नहीं होता — यानी references fixed रहते हैं। लेकिन अगर reference किसी mutable object (list) को point करता है, तो वो object अपने अंदर change हो सकता है। Analogy: आपके घर का address fix है (tuple), लेकिन घर के अंदर furniture रख/हटा सकते हो (list)।
Q7: Python internally tuples को कैसे optimize करता है?
Python tuples के लिए constant folding करता है — अगर code में same tuple बार-बार बनती है तो एक ही object reuse होता है। साथ ही small tuples (length 0-20) को free list में cache करता है, जिससे creation/deletion faster होता है।
Q8: *args function parameter tuple क्यों होता है?
*argstuple इसलिए होता है क्योंकि function arguments fixed होने चाहिए — accidentally modify नहीं होना चाहिए। Tuple immutability गारंटी देती है कि function body मेंargssafely iterate हो सकता है बिना किसी side-effect के।
🎯 Interview Questions (Detailed)
Q1: Tuple और List में fundamental difference क्या है? कब कौनसी use करें?
Answer: Tuple immutable और List mutable है। Tuple use करें जब data fixed हो (coordinates, configs, dict keys)। List use करें जब dynamic collection चाहिए। Tuple faster है, less memory लेती है, और hashable है (dict key बन सकती है)। List versatile है — append, remove, sort सब support करती है।
Q2: (1) और (1,) में क्या difference है? Explain with type.
Answer:(1)एक integer है — parentheses यहाँ grouping operator हैं।(1,)एक tuple है — trailing comma tuple बनाती है।type((1))→<class 'int'>,type((1,))→<class 'tuple'>। यह Python interviews में बहुत common trick question है।
Q3: Tuple immutable है फिर भी t = (1, [2,3], 4) में t[1].append(5) कैसे work करता है?
Answer: Tuple की immutability means — tuple के references (pointers) change नहीं होते। t[1] हमेशा same list object को point करेगा। लेकिन वो list object internally mutable है, इसलिए उसके अंदर changes हो सकते हैं। Tuple guarantee करती है "कौन-कौन से objects हैं" — not "objects के अंदर क्या है"।Q4: Tuple को dictionary key क्यों बना सकते हैं लेकिन list को नहीं?
Answer: Dictionary keys hashable होनी चाहिए। Hashable = object की lifetime में hash value change नहीं होनी चाहिए। Tuple immutable है → hash stable रहता है → dict key बन सकती है। List mutable है → elements change होने पर hash बदल जाएगा → dict key नहीं बन सकती। Exception: अगर tuple में list है (1, [2,3]), तो यह tuple भी unhashable होगी!Q5: Python internally tuples को lists से differently कैसे store करता है?
Answer: List internally variable-size array maintain करती है (over-allocation for amortized O(1) append)। Tuple fixed-size है — exactly उतनी memory allocate होती है जितने elements हैं। Tuple creation में CPython tuple free-list use करता है (small tuples cache होती हैं), और constant folding से compile-time पर same tuples reuse होती हैं। इसीलिए tuple ~30% कम memory लेती है।
Q6: *args tuple क्यों होता है? list भी हो सकता था।
Answer: Design decision — function arguments modify नहीं होने चाहिए accidentally। Tuple immutable है, जिससे function body में args safe रहते हैं। कोईargs.append()याargs[0] = xaccidentally नहीं कर सकता। यह defensive programming principle follow करता है।
Q7: Tuple packing/unpacking के 3 practical use cases बताओ।
Answer: 1. Variable swap:a, b = b, a— no temp variable needed 2. Multiple return values:def minmax(lst): return min(lst), max(lst)→lo, hi = minmax(data)3. Loop destructuring:for i, (name, score) in enumerate(students):— nested unpacking Bonus: Extended unpacking:first, *rest, last = (1,2,3,4,5)→ head/tail pattern
Q8: namedtuple vs dataclass — कब कौनसी use करें?
Answer:namedtupleuse करें जब simple, immutable, lightweight data container चाहिए (no methods needed, tuple-like behavior)।dataclassuse करें जब mutable objects चाहिए, methods add करने हों, default values चाहिए, या__post_init__logic हो।namedtuplememory-efficient है;dataclassfeature-rich है। Python 3.7+ में dataclass generally preferred है complex cases के लिए।
Q9: Tuple slice करने पर new tuple बनती है या same object?
Answer: Tuple slice always new tuple object बनाती है — event[:]भी new object return करती है (unlike some implementations of strings)। लेकिन elements copy नहीं होते — shallow copy होती है (references same objects को point करते हैं)।t = (1,2,3); s = t[:]→t is scould beTruedue to Python optimization for same content, but generally it's a new object।
Q10: Write a function that flattens nested tuples — ((1,2),(3,(4,5)),6) → (1,2,3,4,5,6)
Answer: ``python def flatten_tuple(t): result = [] for item in t: if isinstance(item, tuple): result.extend(flatten_tuple(item)) else: result.append(item) return tuple(result) nested = ((1, 2), (3, (4, 5)), 6) print(flatten_tuple(nested)) # (1, 2, 3, 4, 5, 6)`Recursive approach —isinstance(item, tuple)` check करके nested tuples को recursively flatten करते हैं।
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python Tuples – Immutable Sequences.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, data, structures, tuples
Related Python Master Course Topics
Continue learning this concept
Data StructuresPython Comprehensions – List, Dict, Set & GeneratorPython Comprehensions का complete guide – list comprehension, dictionary comprehension, set comprehension, generator expressions, nested comprehensions, conditional filtering, और performance comparison with Hindi explanations।Data StructuresPython Dictionaries – Key-Value StorePython Dictionaries का complete guide – creation, access, modification, nested dicts, dict comprehension, defaultdict, OrderedDict, और real-world use cases with Hindi explanations और interview questions।Data StructuresPython Dictionary Methods – Complete ReferencePython Dictionary के सभी built-in methods का complete reference – get, keys, values, items, update, pop, popitem, setdefault, copy, clear, fromkeys – examples और time complexity के साथ।Data StructuresPython List Methods – All Built-in MethodsPython List के सभी built-in methods का complete reference – append, extend, insert, remove, pop, sort, reverse, index, count, copy, clear – examples और time complexity के साथ।Data StructuresPython Lists – Complete GuidePython Lists ka complete guide – creation, indexing, slicing, mutability, nesting, and real-world usage with code examples, time complexity, and interview questions.Data StructuresPython Set Methods – Complete ReferencePython Set के सभी built-in methods का complete reference – add, remove, discard, pop, clear, update, union, intersection, difference, symmetric_difference और in-place variants के साथ examples।