Tuples — Complete Deep Dive 📦

Python ki immutable data structure — Tuples. Lists ka faster, memory-efficient bhai. Creation se lekar Named Tuples tak, Packing/Unpacking se lekar Dictionary Keys tak — 10 topics Basic se Advanced tak. Employee data ke real examples aur interview Q&A ke saath. Data Insights par.

📑 Is Chapter Mein Kya Sikhenge:

• 🟢 Basic: Introduction, Creating Tuples, Indexing & Slicing
• 🟡 Medium: Immutability, Packing/Unpacking, Methods, Operations
• 🔴 Advanced: Named Tuples, Tuple as Dictionary Key
• 📋 Summary: Tuple vs List — Complete Comparison Table

📊 Sample Data — Employee Records

Is chapter ke saare examples Employee data par based honge. Har employee ek tuple hai: (id, name, age, department, salary)

📘 Definition: A Tuple is an ordered, immutable (unchangeable), and indexed collection that allows duplicate values. Tuples are created using parentheses () and can hold items of any data type. Once created, tuples CANNOT be modified — no add, remove, or change. This immutability makes tuples faster, memory-efficient, and safe for fixed data.

🎯 Samjho Hinglish Mein: Tuple = List ka "lock ho gaya" version. Ek baar bana diya, ab nahi badal sakte — na add, na remove, na change. Socho employee ka ID card — ek baar issue ho gaya toh usmein change nahi hota. Same tuple mein — data protection ke liye perfect. Aur immutable hone ki wajah se list se FAST hai aur MEMORY bhi kam use karta hai. Jab data fix hai (coordinates, RGB colors, employee record), tuple use karo.

📋 Tuple Properties:

💻 Quick Example:

# Employee record as tuple — fixed data
employee = (101, "Jatin", 25, "IT", 50000)

print(employee)          # (101, 'Jatin', 25, 'IT', 50000)
print(type(employee))    # <class 'tuple'>
print(employee[1])       # Jatin (access by index)
print(len(employee))     # 5

# Trying to modify — ERROR!
# employee[1] = "Rahul"
# TypeError: 'tuple' object does not support item assignment

💬 Interview Q&A:

📘 Definition: Tuples can be created using parentheses (), the tuple() constructor, without parentheses (tuple packing), or from other iterables. Single-element tuple needs a TRAILING COMMA — (5,) not (5). Empty tuple is ().

💻 Examples:

# Example 1: All ways to create a tuple

# Method 1: Parentheses (most common)
employee = (101, "Jatin", 25, "IT", 50000)
departments = ("IT", "HR", "Finance", "Marketing")

# Method 2: Without parentheses (tuple packing)
emp2 = 102, "Priya", 30, "HR", 75000
print(type(emp2))  # <class 'tuple'> — still tuple!

# Method 3: tuple() constructor
from_list = tuple([101, "Jatin", 25])
from_string = tuple("Python")  # ('P','y','t','h','o','n')
from_range = tuple(range(1, 6))  # (1, 2, 3, 4, 5)

# Method 4: Empty tuple
empty = ()
empty2 = tuple()

print(employee)
print(from_string)
print(from_range)

Output:
<class 'tuple'>
(101, 'Jatin', 25, 'IT', 50000)
('P', 'y', 't', 'h', 'o', 'n')
(1, 2, 3, 4, 5)

# Example 2: The SINGLE ELEMENT TUPLE TRAP! ⚠️

# WRONG WAY — this is NOT a tuple!
not_tuple = (101)
print(type(not_tuple))  # <class 'int'> — just parentheses grouping!

# CORRECT WAY — trailing comma zaroori hai!
single = (101,)
print(type(single))  # <class 'tuple'> ✅
print(len(single))   # 1

# Same rule for strings
wrong = ("Jatin")   # str, not tuple!
right = ("Jatin",)  # tuple with 1 element

# Even without parentheses — comma makes it tuple
also_tuple = 101,
print(type(also_tuple))  # <class 'tuple'>

# Example 3: Nested tuples & mixed data

# List of employee tuples (real-world pattern)
employees = [
    (101, "Jatin", 25, "IT", 50000),
    (102, "Priya", 30, "HR", 75000),
    (103, "Rahul", 28, "Finance", 60000)
]

# Nested tuple — tuple inside tuple
company = (
    "TechCorp",
    (101, "Jatin", "IT"),
    (102, "Priya", "HR")
)
print(company[1])       # (101, 'Jatin', 'IT')
print(company[1][1])    # Jatin

# Mixed data types
record = (101, "Jatin", 50000.75, True, ["Python", "SQL"])
print(record)

💬 Interview Q&A:

📘 Definition: Tuple indexing works EXACTLY like list indexing — positive indexing starts from 0, negative from -1. Slicing uses [start:stop:step] and ALWAYS returns a new tuple. The only difference: you CANNOT modify elements using indexing (immutable).

Employee: (101, "Jatin", 25, "IT", 50000)
   (+)      0       1     2     3    4
   (-)     -5      -4    -3    -2   -1

Access:   emp[0] = 101
          emp[-1] = 50000
Slice:    emp[1:4] = ('Jatin', 25, 'IT')
Modify:   emp[0] = 999 → ❌ TypeError!

💻 Examples:

# Example 1: Basic indexing
employee = (101, "Jatin", 25, "IT", 50000)

# Positive indexing
print(employee[0])   # 101 (ID)
print(employee[1])   # Jatin (Name)
print(employee[3])   # IT (Department)

# Negative indexing
print(employee[-1])  # 50000 (last — Salary)
print(employee[-2])  # IT (second last)

# Trying to modify — TypeError!
# employee[1] = "Rahul"
# TypeError: 'tuple' object does not support item assignment

# Workaround — create new tuple
updated = (employee[0], "Rahul") + employee[2:]
print(updated)  # (101, 'Rahul', 25, 'IT', 50000)

# Example 2: Slicing
employee = (101, "Jatin", 25, "IT", 50000)

# Basic slicing
print(employee[1:4])   # ('Jatin', 25, 'IT')
print(employee[:3])    # (101, 'Jatin', 25) — first 3
print(employee[2:])    # (25, 'IT', 50000) — from index 2
print(employee[:])     # Full copy

# Step slicing
nums = (10, 20, 30, 40, 50, 60, 70)
print(nums[::2])    # (10, 30, 50, 70)
print(nums[::-1])   # (70, 60, 50, 40, 30, 20, 10) — reversed!

# Negative slicing
print(employee[-3:])   # (25, 'IT', 50000) — last 3

# Example 3: Real-world — extract data from employee tuples
employees = [
    (101, "Jatin", 25, "IT", 50000),
    (102, "Priya", 30, "HR", 75000),
    (103, "Rahul", 28, "Finance", 60000)
]

# Get all employee names (index 1)
names = [emp[1] for emp in employees]
print(names)  # ['Jatin', 'Priya', 'Rahul']

# Get all salaries (index -1 or 4)
salaries = [emp[-1] for emp in employees]
print(f"Total salary: ₹{sum(salaries)}")  # ₹185000

# Get partial info — name + department only
name_dept = [(emp[1], emp[3]) for emp in employees]
print(name_dept)
# [('Jatin', 'IT'), ('Priya', 'HR'), ('Rahul', 'Finance')]

💬 Interview Q&A:

📘 Definition: Immutability means the tuple's structure and references cannot change after creation. However, if a tuple contains MUTABLE objects (like lists), those inner objects CAN still be modified. The tuple's reference to that object doesn't change — but the object itself does. This is one of the most misunderstood Python concepts.

🎯 Samjho Hinglish Mein: Tuple ek locked box hai. Andar jo cheez rakhi hai uski jagah nahi badal sakte. But agar andar ek notebook (list) rakhi hai, toh notebook ke pages toh likhe ja sakte hain! Notebook ki JAGAH nahi badal sakte, but notebook mein CONTENT change ho sakta hai. Interview mein yeh trap sabko confuse karta hai — clarity zaroori hai!

💻 Examples:

# Example 1: Standard immutability
employee = (101, "Jatin", 25, "IT", 50000)

# All these will fail!
# employee[0] = 999          → TypeError
# employee.append(60000)     → AttributeError (no append)
# employee.remove("Jatin")   → AttributeError (no remove)
# del employee[0]            → TypeError

# Only way to "change" — create new tuple
new_emp = employee[:1] + ("Rahul",) + employee[2:]
print(new_emp)  # (101, 'Rahul', 25, 'IT', 50000)
print(employee)  # Original unchanged

# Example 2: The MUTABLE-INSIDE TRAP! ⚠️

# Employee with skills list inside tuple
employee = (101, "Jatin", ["Python", "SQL"])
print("Before:", employee)

# We CAN'T change the tuple's structure
# employee[2] = ["Java"]  → TypeError!

# BUT we CAN modify the list INSIDE the tuple!
employee[2].append("Power BI")
employee[2].append("Tableau")
print("After:", employee)
# (101, 'Jatin', ['Python', 'SQL', 'Power BI', 'Tableau'])
# ↑ Tuple change ho gaya! But actually list changed hai, tuple's reference same

# Tuple ki id same hai, list ki id bhi same hai
# Sirf list ka content changed hai

# Example 3: Hashability & the trap

# Pure tuple (all immutable inside) — HASHABLE ✅
pure_emp = (101, "Jatin", 25)
print(hash(pure_emp))  # Works! Some hash value

# Can be used as dict key
emp_data = {pure_emp: "IT Department"}
print(emp_data)

# Tuple with mutable inside — NOT HASHABLE ❌
impure_emp = (101, "Jatin", ["Python"])
# hash(impure_emp)  → TypeError: unhashable type: 'list'
# {impure_emp: "IT"}  → TypeError!

# Rule: Tuple hashable hai TABHI jab andar SAB kuch hashable ho

💬 Interview Q&A:

📘 Definition: Packing = combining multiple values into a single tuple (t = 1, 2, 3). Unpacking = extracting tuple values into separate variables (a, b, c = t). The number of variables must match the tuple length. The * operator allows extended unpacking — one variable can catch multiple values.

🎯 Samjho Hinglish Mein: Packing = kai cheezein ek dabbe (tuple) mein rakhna. Unpacking = dabba khol ke cheezein alag-alag rakhna. Python ka superpower — ek line mein multiple assign karo, variables swap karo, functions se multiple values return karo. * operator jokey ka role play karta hai — "baaki sab yahan aa jao!"

💻 Examples:

# Example 1: Basic Packing & Unpacking

# PACKING — multiple values → tuple
employee = 101, "Jatin", 25, "IT", 50000
print(employee)       # (101, 'Jatin', 25, 'IT', 50000)
print(type(employee)) # <class 'tuple'>

# UNPACKING — tuple → separate variables
emp_id, name, age, dept, salary = employee
print(name)     # Jatin
print(salary)   # 50000

# Number of variables MUST match!
# a, b = employee  → ValueError: too many values to unpack
# a, b, c, d, e, f = employee  → ValueError: not enough values

# Example 2: Extended Unpacking with *

employee = (101, "Jatin", 25, "IT", 50000)

# * catches multiple values as list
emp_id, *details = employee
print(emp_id)   # 101
print(details)  # ['Jatin', 25, 'IT', 50000] — list!

# * in middle
emp_id, *middle, salary = employee
print(emp_id)   # 101
print(middle)   # ['Jatin', 25, 'IT']
print(salary)   # 50000

# * at end
*first, dept, salary = employee
print(first)    # [101, 'Jatin', 25]
print(dept)     # IT
print(salary)   # 50000

# Ignore unwanted values with _
emp_id, name, _, _, salary = employee  # age & dept ignored
print(f"{name} earns ₹{salary}")  # Jatin earns ₹50000

# Example 3: Real-world use cases

# 1. Swap variables without temp variable!
a, b = 10, 20
a, b = b, a
print(a, b)  # 20 10 (swapped!)

# 2. Multiple return values from function
def get_employee_stats(employees):
    total = sum(emp[4] for emp in employees)
    avg = total / len(employees)
    highest = max(emp[4] for emp in employees)
    return total, avg, highest  # tuple packing

employees = [
    (101, "Jatin", 25, "IT", 50000),
    (102, "Priya", 30, "HR", 75000),
    (103, "Rahul", 28, "Finance", 60000)
]

# Unpack multiple returns
total, avg, highest = get_employee_stats(employees)
print(f"Total: ₹{total}, Avg: ₹{avg:.0f}, Max: ₹{highest}")

# 3. Iterate with unpacking
for emp_id, name, age, dept, salary in employees:
    print(f"{name} ({dept}): ₹{salary}")

# 4. Enumerate + unpacking
for idx, (emp_id, name, *_) in enumerate(employees, 1):
    print(f"{idx}. {name} (ID: {emp_id})")

Output:
Total: ₹185000, Avg: ₹61667, Max: ₹75000
Jatin (IT): ₹50000
Priya (HR): ₹75000
Rahul (Finance): ₹60000
1. Jatin (ID: 101)
2. Priya (ID: 102)
3. Rahul (ID: 103)

💬 Interview Q&A:

📘 Definition: Since tuples are immutable, they only have TWO methods — count(value) returns how many times a value appears, and index(value) returns the position of the first occurrence. Compare this to lists which have 11+ methods (append, remove, sort, etc.) — tuples are minimalist by design.

📋 Only 2 Methods:

💻 Examples:

# Example 1: count() — count occurrences

# Departments of all employees
departments = ("IT", "HR", "Finance", "IT", "Marketing", "IT")

print(departments.count("IT"))        # 3
print(departments.count("HR"))        # 1
print(departments.count("Sales"))     # 0 (safe — no error)

# Practical: department-wise employee count
for dept in set(departments):
    count = departments.count(dept)
    print(f"{dept}: {count} employees")

# Example 2: index() — find position

employee = (101, "Jatin", 25, "IT", 50000)

# Find position of specific values
print(employee.index("Jatin"))  # 1
print(employee.index("IT"))     # 3

# If not found — ValueError!
# employee.index("Rahul") → ValueError

# Safe search — check first
target = "Rahul"
if target in employee:
    print(f"Found at index {employee.index(target)}")
else:
    print(f"{target} not found")

# index() with range: index(value, start, end)
departments = ("IT", "HR", "IT", "Finance", "IT")
print(departments.index("IT"))       # 0 (first IT)
print(departments.index("IT", 1))    # 2 (search from index 1)
print(departments.index("IT", 3))    # 4 (search from index 3)

# Example 3: Real-world — Department analysis

# All employee departments
all_depts = ("IT", "HR", "Finance", "IT", "Marketing", 
             "IT", "HR", "Finance", "IT", "HR")

# Department frequency analysis
unique_depts = set(all_depts)
dept_stats = [(dept, all_depts.count(dept)) for dept in unique_depts]
dept_stats.sort(key=lambda x: x[1], reverse=True)

print("Department Statistics:")
for dept, count in dept_stats:
    print(f"  {dept}: {count} employees")

# Find first Finance employee position
if "Finance" in all_depts:
    pos = all_depts.index("Finance")
    print(f"First Finance emp at position: {pos}")

💬 Interview Q&A:

📘 Definition: Tuples support several operations: Concatenation (+) merges two tuples into a new one. Repetition (*) repeats tuple n times. Membership (in, not in) checks if value exists. Iteration using for-loop. Comparison (==, <, >) works element-wise. All these return NEW tuples — original remains unchanged.

💻 Examples:

# Example 1: Concatenation (+) and Repetition (*)

# Concatenation — merge tuples
basic_info = (101, "Jatin")
job_info = ("IT", 50000)
full_record = basic_info + job_info
print(full_record)  # (101, 'Jatin', 'IT', 50000)

# Original tuples unchanged
print(basic_info)  # (101, 'Jatin')

# Concatenation returns NEW tuple
# Original ki id vs new tuple ki id — different!

# Repetition — repeat n times
zeros = (0,) * 5
print(zeros)  # (0, 0, 0, 0, 0)

placeholder = ("N/A",) * 3
print(placeholder)  # ('N/A', 'N/A', 'N/A')

# ⚠️ Note the comma — (0,) is tuple, (0) is int!

# Example 2: Membership & Iteration

employee = (101, "Jatin", 25, "IT", 50000)

# Membership check
print("Jatin" in employee)     # True
print("Rahul" in employee)     # False
print("Rahul" not in employee) # True
print(50000 in employee)       # True

# Iteration
for item in employee:
    print(item, type(item).__name__)

# Iteration with enumerate
for idx, value in enumerate(employee):
    print(f"Field {idx}: {value}")

# Iterate over list of employee tuples
employees = [
    (101, "Jatin", 50000),
    (102, "Priya", 75000)
]
for emp_id, name, salary in employees:  # unpacking!
    print(f"{name}: ₹{salary}")

# Example 3: Comparison & Built-in Functions

# Tuple comparison — element-wise (lexicographic)
emp1 = (101, "Jatin", 50000)
emp2 = (101, "Jatin", 50000)
emp3 = (102, "Priya", 75000)

print(emp1 == emp2)  # True (identical)
print(emp1 == emp3)  # False
print(emp1 < emp3)   # True (101 < 102)

# Built-in functions
salaries = (50000, 75000, 60000, 55000, 80000)

print(f"Count: {len(salaries)}")         # 5
print(f"Total: ₹{sum(salaries)}")        # ₹320000
print(f"Max: ₹{max(salaries)}")          # ₹80000
print(f"Min: ₹{min(salaries)}")          # ₹50000
print(f"Sorted: {sorted(salaries)}")    # returns LIST!

# Convert list ↔ tuple
lst = list(salaries)       # tuple → list (mutable)
lst.append(90000)
new_tup = tuple(lst)       # list → tuple (immutable)
print(new_tup)  # (50000, 75000, 60000, 55000, 80000, 90000)

💬 Interview Q&A:

📘 Definition: A namedtuple is a factory function from the collections module that creates tuple subclasses with NAMED FIELDS. Instead of accessing by index (emp[1]), you can use meaningful names (emp.name). It combines tuple's immutability + dict's readability. Perfect for representing records without creating a full class.

🎯 Samjho Hinglish Mein: Normal tuple mein emp[0], emp[1] — bhool jaate ho kya kya hai kahan. Named tuple mein emp.id, emp.name, emp.salary — clean aur readable! Mini-class ki tarah hai — attributes se access karo, but immutable rahega. Data science mein records represent karne ka lightweight tarika. Class banane se pehle sochke namedtuple try karo.

💻 Examples:

# Example 1: Regular tuple vs Named tuple
from collections import namedtuple

# REGULAR TUPLE — index-based (confusing!)
emp_regular = (101, "Jatin", 25, "IT", 50000)
print(emp_regular[1])   # Jatin (but which field is this?)

# NAMED TUPLE — clear & readable!
Employee = namedtuple("Employee", ["id", "name", "age", "dept", "salary"])

# Create instance
emp = Employee(101, "Jatin", 25, "IT", 50000)

# Access by name (readable!)
print(emp.name)     # Jatin
print(emp.salary)   # 50000
print(emp.dept)     # IT

# Still works like tuple — access by index
print(emp[1])       # Jatin

# Still immutable
# emp.name = "Rahul"  → AttributeError!

# Example 2: Special methods of namedtuple
from collections import namedtuple

Employee = namedtuple("Employee", ["id", "name", "age", "dept", "salary"])
emp = Employee(101, "Jatin", 25, "IT", 50000)

# _asdict() — convert to dict
emp_dict = emp._asdict()
print(emp_dict)
# {'id': 101, 'name': 'Jatin', 'age': 25, 'dept': 'IT', 'salary': 50000}

# _replace() — create modified copy (immutable stays!)
promoted = emp._replace(salary=70000, dept="Senior IT")
print(promoted)
# Employee(id=101, name='Jatin', age=25, dept='Senior IT', salary=70000)
print(emp)  # Original unchanged!

# _fields — see all field names
print(Employee._fields)
# ('id', 'name', 'age', 'dept', 'salary')

# _make() — create from iterable
data = [102, "Priya", 30, "HR", 75000]
emp2 = Employee._make(data)
print(emp2)

# Example 3: Real-world use case
from collections import namedtuple

Employee = namedtuple("Employee", ["id", "name", "age", "dept", "salary"])

# Create list of employees
employees = [
    Employee(101, "Jatin", 25, "IT", 50000),
    Employee(102, "Priya", 30, "HR", 75000),
    Employee(103, "Rahul", 28, "Finance", 60000),
    Employee(104, "Neha", 26, "IT", 55000)
]

# Filter — IT department employees
it_emps = [e for e in employees if e.dept == "IT"]
for e in it_emps:
    print(f"{e.name} (₹{e.salary})")

# Aggregate — total salary
total = sum(e.salary for e in employees)
print(f"Total salary: ₹{total}")

# Sort — by salary descending
sorted_emps = sorted(employees, key=lambda e: e.salary, reverse=True)
print("Top earner:", sorted_emps[0].name)

# Give everyone 10% raise (create new list)
raised = [e._replace(salary=int(e.salary * 1.1)) for e in employees]
for e in raised:
    print(f"{e.name}: ₹{e.salary}")

Output:
Jatin (₹50000)
Neha (₹55000)
Total salary: ₹240000
Top earner: Priya
Jatin: ₹55000
Priya: ₹82500
Rahul: ₹66000
Neha: ₹60500

💬 Interview Q&A:

📘 Definition: Only hashable objects can be used as dictionary keys or set elements. Tuples are hashable ONLY IF all their elements are hashable (immutable). This makes tuples the perfect choice for composite keys — like (city, year) or (x, y) coordinates. Lists cannot be dict keys because they're mutable/unhashable.

🎯 Samjho Hinglish Mein: Dictionary key ke liye ek unique "fingerprint" chahiye — jo change na ho. Immutable objects ka fingerprint (hash) same rehta hai — isliye dict key ban sakte hain. Tuple immutable hai, so hashable. But agar tuple ke andar list hai (mutable), toh fingerprint change ho sakta hai — hashable nahi. Real-world: (employee_id, year) combination se salary track karo — composite key ki jaan!

💻 Examples:

# Example 1: Hashable check

# Immutable types — hashable ✅
print(hash(42))               # works
print(hash("Jatin"))          # works
print(hash((101, "Jatin")))  # works

# Mutable types — NOT hashable ❌
# hash([1, 2, 3])           → TypeError
# hash({1: "a"})             → TypeError
# hash({1, 2})               → TypeError

# Tuple with mutable inside — NOT hashable ❌
# hash((1, [2, 3]))          → TypeError

# Rule: tuple hashable hai TABHI jab andar sab hashable ho
print(hash((1, 2, 3)))         # ✅
print(hash(("a", "b", (1, 2)))) # ✅ (nested tuple ok)

# Example 2: Tuple as composite dictionary key

# Employee attendance — (emp_id, date) as key
attendance = {
    (101, "2024-01-15"): "Present",
    (101, "2024-01-16"): "Absent",
    (102, "2024-01-15"): "Present",
    (102, "2024-01-16"): "Present",
}

# Lookup with tuple key
print(attendance[(101, "2024-01-15")])  # Present
print(attendance[(102, "2024-01-16")])  # Present

# Salary by (department, year)
salary_data = {
    ("IT", 2023): 500000,
    ("IT", 2024): 550000,
    ("HR", 2023): 400000,
    ("HR", 2024): 450000,
}

print(f"IT 2024 total: ₹{salary_data[('IT', 2024)]}")

# If list used as key — TypeError!
# attendance[[101, "2024-01-15"]] = "Present"
# TypeError: unhashable type: 'list'

# Example 3: Real-world — Employee performance tracking

# (employee_id, quarter) → performance rating
performance = {}

# Add data
performance[(101, "Q1")] = 4.5
performance[(101, "Q2")] = 4.7
performance[(101, "Q3")] = 4.8
performance[(102, "Q1")] = 4.2
performance[(102, "Q2")] = 4.4
performance[(103, "Q1")] = 4.8

# Get specific employee's Q2 rating
print(f"Emp 101 Q2: {performance[(101, 'Q2')]}")

# Get all Q1 ratings
q1_ratings = {k: v for k, v in performance.items() if k[1] == "Q1"}
print("Q1 Ratings:", q1_ratings)

# Sets can also use tuples
processed_records = set()
processed_records.add((101, "2024-01-15"))
processed_records.add((102, "2024-01-15"))
processed_records.add((101, "2024-01-15"))  # duplicate ignored

print(f"Unique records: {len(processed_records)}")  # 2

# Check membership
if (101, "2024-01-15") in processed_records:
    print("Already processed!")

💬 Interview Q&A:

📘 Definition: Tuple aur List dono ordered sequences hain, but fundamentally different — Tuple immutable hai, List mutable. Yeh ek property saari performance, use-case, aur behavior ka difference create karti hai. Right choice = better performance + safer code.

📋 Complete Comparison Table:

💻 Performance Benchmarks:

# Speed comparison — tuple vs list
import timeit
import sys

# 1. Creation speed
list_time = timeit.timeit("[1,2,3,4,5]", number=10000000)
tuple_time = timeit.timeit("(1,2,3,4,5)", number=10000000)
print(f"List creation: {list_time:.3f}s")   # ~0.6s
print(f"Tuple creation: {tuple_time:.3f}s")  # ~0.1s (6x faster!)

# 2. Memory comparison
lst = [1, 2, 3, 4, 5]
tup = (1, 2, 3, 4, 5)
print(f"List size: {sys.getsizeof(lst)} bytes")   # ~104 bytes
print(f"Tuple size: {sys.getsizeof(tup)} bytes")  # ~80 bytes

# 3. Iteration speed
list_iter = timeit.timeit("for x in [1,2,3,4,5]: pass", number=1000000)
tuple_iter = timeit.timeit("for x in (1,2,3,4,5): pass", number=1000000)
print(f"List iter: {list_iter:.3f}s")    # ~0.15s
print(f"Tuple iter: {tuple_iter:.3f}s")   # ~0.12s

# When to use TUPLE vs LIST — practical guide

# ✅ USE TUPLE for FIXED data

# Employee record — fields fixed
employee = (101, "Jatin", 25, "IT", 50000)

# Coordinates — won't change
office_location = (28.6, 77.2)

# Company constants
DEPARTMENTS = ("IT", "HR", "Finance", "Marketing")
WORKING_DAYS = ("Mon", "Tue", "Wed", "Thu", "Fri")

# Dictionary composite key
salary_by_dept_year = {
    ("IT", 2024): 550000,
    ("HR", 2024): 450000
}

# ✅ USE LIST for DYNAMIC data

# Growing employee list
employees = []
employees.append((101, "Jatin"))
employees.append((102, "Priya"))

# Attendance record — daily add
today_attendance = []
today_attendance.append("Jatin")
today_attendance.append("Priya")

# Sortable/filterable data
salaries = [50000, 75000, 60000]
salaries.sort()
salaries.append(85000)

💬 Interview Q&A:

Next: Python Handbook — Part 5

Agle part mein hum cover karenge: Sets — Complete Deep Dive. Unique elements, set operations (union, intersection, difference), frozenset, set comprehension, real-world use cases — sab kuch. Sets ka superpower: fast membership check O(1) aur automatic duplicate removal. Data cleaning aur analysis mein bahut useful. Part 4 (Tuples) aur Part 3A/3B (Lists) Data Insights par available hain.

Happy Learning & Keep Coding! 🚀