Sequence Data Types – NIELIT O Level (M3-R5)

💡 Introduction

Python में Sequence Data Types वे data structures हैं जिनमें कई items को एक ordered sequence में store किया जा सकता है। इनकी खासियत है कि हर element का एक index number होता है जिससे हम किसी भी value को access कर सकते हैं।

🧩 Features of Sequence Data Types

• ✅ Ordered collection (items arranged in specific order)
• ✅ Index-based access (0, 1, 2...)
• ✅ Supports slicing, iteration, and concatenation
• ✅ May be mutable (list) or immutable (string, tuple)

📘 Common Sequence Data Types in Python

🔍 Accessing Elements

हर sequence में items को उनकी index position से access किया जा सकता है। Index हमेशा 0 से शुरू होती है।

name = "PYTHON"
print(name[0])   # First character
print(name[3])   # Fourth character
    

numbers = [10, 20, 30, 40, 50]
print(numbers[-1])   # Last element
print(numbers[-3])   # Third from end
    

✂️ Slicing in Sequences

Slicing से हम sequence का कोई हिस्सा निकाल सकते हैं:

list1 = [10, 20, 30, 40, 50, 60]
print(list1[1:4])     # index 1 to 3
print(list1[:3])      # start to index 2
print(list1[::2])     # every 2nd element
  

➕ Concatenation and Repetition

a = [1, 2, 3]
b = [4, 5]
print(a + b)     # Concatenation
print(a * 2)     # Repetition
    

🔁 Iteration in Sequences

fruits = ["apple", "banana", "cherry"]
for item in fruits:
    print(item)
    

🧮 Operations on Sequences

📗 Practical Example

marks = [78, 85, 90, 66, 88]
total = sum(marks)
avg = total / len(marks)
print("Average Marks =", avg)
    

🧠 Key Points

• Sequence is a collection of ordered elements.
• Indexing allows direct access to individual items.
• Lists are mutable, Tuples and Strings are immutable.
• Supports slicing, concatenation, iteration, and membership tests.

🧩 Summary

• Sequence data types = Ordered collections in Python.
• Most common: String, List, Tuple, Range.
• Powerful for loops, pattern problems, and data manipulation.

📘 Introduction

Python में List एक Ordered, Mutable (changeable) collection होती है जिसमें हम कई elements एक साथ रख सकते हैं। Lists को square brackets [ ] में लिखा जाता है। यह Python में सबसे ज़्यादा इस्तेमाल होने वाला sequence data type है।

💡 Syntax:

list_name = [element1, element2, element3, ...]
  

🧩 Example:

fruits = ["apple", "banana", "cherry"]
print(fruits)
  

Output:
['apple', 'banana', 'cherry']

📚 Properties of Lists

• ✅ Ordered — Elements maintain their insertion order.
• ✅ Mutable — You can change elements anytime.
• ✅ Heterogeneous — Different data types allowed.
• ✅ Index-based access — Supports positive and negative indexes.
• ✅ Allows duplicate values.

🧱 Creating Lists

empty_list = []
numbers = [1, 2, 3, 4]
mixed = [10, "Python", 3.14, True]
nested = [[1, 2, 3], [4, 5, 6]]
  

🎯 Accessing Elements

animals = ["cat", "dog", "elephant", "tiger"]
print(animals[0])    # first element
print(animals[-1])   # last element
  

Output:
cat
tiger

✂️ Slicing a List

data = [10, 20, 30, 40, 50]
print(data[1:4])   # elements 1 to 3
print(data[:3])    # first three
print(data[::2])   # every second element
  

Output:
[20, 30, 40]
[10, 20, 30]
[10, 30, 50]

🔁 Traversing a List

names = ["Amit", "Ravi", "Kiran"]
for name in names:
    print("Hello", name)
  

Output:
Hello Amit
Hello Ravi
Hello Kiran

🧩 Modifying Lists

nums = [10, 20, 30]
nums[1] = 99
nums.append(40)
nums.insert(1, 15)
print(nums)
  

Output:
[10, 15, 99, 30, 40]

🧹 Removing Elements

nums = [10, 20, 30, 40, 50]
nums.remove(30)
nums.pop(2)
del nums[0]
print(nums)
  

Output:
[40, 50]

📋 Common List Methods

➕ List Concatenation & Repetition

a = [1, 2]
b = [3, 4]
print(a + b)   # concatenation
print(a * 3)   # repetition
  

Output:
[1, 2, 3, 4]
[1, 2, 1, 2, 1, 2]

🧮 Mathematical Functions

nums = [10, 20, 30, 40, 50]
print(len(nums))
print(max(nums))
print(min(nums))
print(sum(nums))
  

Output:
5
50
10
150

🔍 Membership Testing

colors = ["red", "green", "blue"]
print("red" in colors)
print("yellow" not in colors)
  

Output:
True
True

📘 Nested Lists

matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]
print(matrix[1][2])
  

Output:
6

💻 Practical Programs

nums = [12, 45, 23, 67, 34]
largest = max(nums)
print("Largest =", largest)
    

nums = [1, 2, 3, 4, 5, 6, 7, 8]
even = 0
odd = 0

for n in nums:
    if n % 2 == 0:
        even += 1
    else:
        odd += 1

print("Even:", even)
print("Odd:", odd)
    

nums = [10, 20, 30, 40]
rev = nums[::-1]
print(rev)
    

data = [5, 10, 15, 20]
total = 0
for i in data:
    total += i
print("Total =", total)
    

items = [1, 2, 2, 3, 4, 4, 5]
unique = []
for i in items:
    if i not in unique:
        unique.append(i)
print(unique)
    

nums = [1, 2, 3, 4, 5]
squares = [n * n for n in nums]
print(squares)
    

nums = [10, 40, 20, 50, 30]
nums.sort()
print("Second Largest =", nums[-2])
    

nums = [2, 3, 4]
product = 1
for n in nums:
    product *= n
print("Product =", product)
    

nums = [-3, 5, -1, 0, 7, -8]
pos = []
neg = []

for n in nums:
    if n >= 0:
        pos.append(n)
    else:
        neg.append(n)

print("Positive:", pos)
print("Negative:", neg)
    

nums = [11, 12, 13, 14, 15, 16]
for i in nums:
    if i % 2 == 0:
        print(i)
    

🧠 Summary

• Lists are ordered, mutable, and dynamic.
• They allow multiple data types in one structure.
• Support slicing, iteration, and nested structures.
• Most versatile Python data structure.

📘 Introduction

Tuple Python का एक ordered and immutable (unchangeable) collection data type है। Tuple को parentheses ( ) में लिखा जाता है। यह list की तरह दिखता है लेकिन इसमें एक बार value assign करने के बाद उसे बदला नहीं जा सकता।

💡 Definition:

A tuple is an ordered collection of elements enclosed in parentheses ( ) and is immutable (cannot be changed after creation).

🔹 Syntax:

tuple_name = (element1, element2, element3, ...)
  

🔹 Example:

fruits = ("apple", "banana", "cherry")
print(fruits)
  

Output:
('apple', 'banana', 'cherry')

🧩 Creating Tuples

empty_tuple = ()
numbers = (1, 2, 3, 4)
mixed = (10, "Python", 3.14, True)
nested = ((1, 2), (3, 4))
single = (5,)  # Must add comma for single element tuple
  

🎯 Accessing Elements (Indexing)

colors = ("red", "green", "blue", "yellow")
print(colors[0])
print(colors[-1])
  

Output:
red
yellow

✂️ Slicing Tuples

nums = (10, 20, 30, 40, 50)
print(nums[1:4])
print(nums[:3])
print(nums[::-1])  # reversed
  

Output:
(20, 30, 40)
(10, 20, 30)
(50, 40, 30, 20, 10)

📚 Tuple Characteristics

• ✅ Ordered – Elements maintain their order
• 🚫 Immutable – Cannot change, add, or remove items
• ✅ Allow duplicate values
• ✅ Can contain heterogeneous data
• ✅ Faster than lists (performance-wise)

⚖️ Difference Between List and Tuple

➕ Tuple Operations

a = (1, 2, 3)
b = (4, 5)
print(a + b)   # concatenation
print(a * 2)   # repetition
  

Output:
(1, 2, 3, 4, 5)
(1, 2, 3, 1, 2, 3)

🔍 Membership Testing

nums = (10, 20, 30, 40)
print(20 in nums)
print(50 not in nums)
  

Output:
True
True

🧮 Tuple Functions

nums = (10, 20, 30, 40, 50)
print(len(nums))
print(max(nums))
print(min(nums))
print(sum(nums))
  

Output:
5
50
10
150

📘 Tuple Methods

🧠 Iterating Through a Tuple

animals = ("dog", "cat", "horse")
for a in animals:
    print(a)
  

Output:
dog
cat
horse

🔁 Converting Between List and Tuple

t = (1, 2, 3)
l = list(t)  # tuple to list
l.append(4)
t2 = tuple(l)
print(t2)
  

Output:
(1, 2, 3, 4)

💻 Practical Programs

nums = (45, 12, 89, 33, 67)
print("Max:", max(nums))
print("Min:", min(nums))
    

t = (1, 2, 3, 2, 2, 4, 5)
print("2 appears", t.count(2), "times")
    

t = (10, 20, 30, 40)
print("Index of 30:", t.index(30))
    

cities = ("Delhi", "Mumbai", "Kolkata")
for i in range(len(cities)):
    print(i, ":", cities[i])
    

colors = ("red", "blue", "green")
if "blue" in colors:
    print("Yes, blue is present!")
    

student = ("Amit", 20, "Delhi")
name, age, city = student
print("Name:", name)
print("Age:", age)
print("City:", city)
    

t = ((1, 2), (3, 4), (5, 6))
print(t[1][0])
    

data = [("a", 1), ("b", 2), ("c", 3)]
d = dict(data)
print(d)
    

t = (1, 2, 3, 2, 4, 2, 5)
repeated = []
for i in t:
    if t.count(i) > 1 and i not in repeated:
        repeated.append(i)
print(repeated)
    

💡 Interview Style Questions

• Q: Why are tuples faster than lists?
  A: Tuples are stored in fixed memory and are immutable, so Python optimizes their memory usage.
• Q: Can we change a value inside tuple?
  A: No, tuple elements cannot be changed once created.
• Q: How can we modify a tuple indirectly?
  A: Convert it into a list → make changes → convert back into tuple.

🧠 Summary

• Tuples are ordered, immutable collections.
• Faster than lists and use less memory.
• Useful when data should remain constant.
• Only two main methods: count() and index().

📘 Introduction

Python में Dictionary एक unordered, mutable, and key-value pair data type है। यह real-world mapping (जैसे student → marks) को store करने के लिए use होता है। Dictionary को curly braces { } में लिखा जाता है।

💡 Definition:

A dictionary is an unordered collection of key-value pairs where each key is unique. Dictionaries are mutable and written in curly braces { }.

🔹 Syntax:

dict_name = {
    key1: value1,
    key2: value2,
    key3: value3
}
  

🔹 Example:

student = {"name": "Amit", "age": 20, "course": "Python"}
print(student)
  

Output:
{'name': 'Amit', 'age': 20, 'course': 'Python'}

🧩 Characteristics of Dictionaries

• ✅ Data stored as key : value pairs
• ✅ Unordered (from Python 3.7+, maintains insertion order)
• ✅ Mutable — can change, add, or remove pairs
• 🚫 Keys must be unique and immutable
• ✅ Values can be any data type

🧱 Creating Dictionaries

empty_dict = {}
student = {"name": "Ravi", "age": 18, "grade": "A"}
numbers = {1: "one", 2: "two", 3: "three"}
nested = {"person": {"name": "Amit", "age": 22}}
  

🎯 Accessing Elements

student = {"name": "Amit", "age": 20, "course": "Python"}
print(student["name"])
print(student.get("age"))
  

Output:
Amit
20

✍️ Adding and Updating Values

student = {"name": "Amit", "age": 20}
student["course"] = "Python"
student["age"] = 21
print(student)
  

Output:
{'name': 'Amit', 'age': 21, 'course': 'Python'}

❌ Removing Items

student = {"name": "Amit", "age": 20, "course": "Python"}
student.pop("age")       # removes key
del student["course"]    # delete key
student.clear()          # removes all
print(student)
  

Output:
{}

📋 Dictionary Methods

🔍 Iterating Through Dictionary

student = {"name": "Amit", "age": 20, "course": "Python"}
for key, value in student.items():
    print(key, ":", value)
  

Output:
name : Amit
age : 20
course : Python

🧮 Built-in Functions

data = {"a": 1, "b": 2, "c": 3}
print(len(data))
print(max(data))
print(min(data))
print(str(data))
  

Output:
3
c
a
{'a': 1, 'b': 2, 'c': 3}

🔗 Combining Dictionaries

d1 = {"a": 1, "b": 2}
d2 = {"c": 3, "d": 4}
d1.update(d2)
print(d1)
  

Output:
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

💻 Practical Programs

text = "banana"
freq = {}
for ch in text:
    freq[ch] = freq.get(ch, 0) + 1
print(freq)
    

d1 = {"x": 10, "y": 20}
d2 = {"z": 30}
merged = {**d1, **d2}
print(merged)
    

data = {"a": 100, "b": 200, "c": 300}
print("Sum =", sum(data.values()))
    

data = {"id": 1, "name": "Amit"}
if "id" in data:
    print("Key found")
    

data = {"a": 10, "b": 25, "c": 15}
max_key = max(data, key=data.get)
print("Key with max value:", max_key)
    

keys = ["name", "age", "city"]
values = ["Ravi", 20, "Delhi"]
info = dict(zip(keys, values))
print(info)
    

students = {
  "101": {"name": "Amit", "age": 20},
  "102": {"name": "Ravi", "age": 22}
}
print(students["102"]["name"])
    

data = {"a": 1, "b": 2, "c": 1}
unique = {}
for k, v in data.items():
    if v not in unique.values():
        unique[k] = v
print(unique)
    

data = {"a": 10, "b": 20, "c": 30}
swapped = {v: k for k, v in data.items()}
print(swapped)
    

data = {"a": 5, "b": 15, "c": 25}
filtered = {k: v for k, v in data.items() if v > 10}
print(filtered)
    

💡 Interview Questions

• Q: Are dictionaries ordered?
  A: Yes, from Python 3.7+, they maintain insertion order.
• Q: Can a dictionary have duplicate keys?
  A: No, keys must be unique. If repeated, last value overrides previous one.
• Q: Can we use list as a key?
  A: No, keys must be immutable (only string, number, or tuple allowed).
• Q: How to merge two dictionaries?
  A: Using update() or unpacking operator {**d1, **d2}.

🧠 Summary

• Dictionaries store key-value pairs and are mutable.
• Keys must be unique and immutable.
• Provide fast lookups and flexible structure.
• Used for mapping, configurations, JSON data, etc.

📘 Introduction

Python में Set एक unordered, mutable collection है जो unique elements को store करता है। यानी set में कोई भी duplicate value नहीं होती। Set का use mathematical set operations जैसे Union, Intersection, Difference के लिए किया जाता है।

💡 Definition:

A set is an unordered collection of unique and immutable elements enclosed in curly braces { }.

🔹 Syntax:

set_name = {element1, element2, element3, ...}
  

🔹 Example:

fruits = {"apple", "banana", "cherry"}
print(fruits)
  

Output:
{'banana', 'cherry', 'apple'}

🧩 Characteristics of Sets

• ✅ Unordered – No fixed sequence
• ✅ Mutable – Can add or remove items
• 🚫 No duplicate values allowed
• ✅ Elements must be immutable (numbers, strings, tuples)
• 🚫 Does not support indexing or slicing

🧱 Creating Sets

empty_set = set()          # not {}
numbers = {1, 2, 3, 4}
mixed = {10, "Python", 3.14, True}
  

🎯 Adding and Removing Elements

s = {10, 20, 30}
s.add(40)         # Add one element
s.update([50, 60])  # Add multiple elements
s.remove(20)      # Remove specific element
s.discard(100)    # No error if not found
print(s)
  

Output:
{40, 10, 50, 30, 60}

📋 Common Set Methods

➕ Set Operations

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
print("Union:", A | B)
print("Intersection:", A & B)
print("Difference:", A - B)
print("Symmetric Difference:", A ^ B)
  

Output:
Union: {1, 2, 3, 4, 5, 6}
Intersection: {3, 4}
Difference: {1, 2}
Symmetric Difference: {1, 2, 5, 6}

🔍 Membership Test

colors = {"red", "green", "blue"}
print("red" in colors)
print("yellow" not in colors)
  

Output:
True
True

🧮 Built-in Functions

nums = {10, 20, 30, 40, 50}
print(len(nums))
print(max(nums))
print(min(nums))
print(sum(nums))
  

Output:
5
50
10
150

💻 Practical Programs

nums = [1, 2, 2, 3, 4, 4, 5]
unique = set(nums)
print(unique)
    

A = {1, 2, 3, 4}
B = {3, 5, 6, 2}
common = A & B
print("Common:", common)
    

A = {1, 2, 3, 4}
B = {3, 4, 5}
print(A - B)
    

word = "programming"
vowels = {'a', 'e', 'i', 'o', 'u'}
result = set(word) & vowels
print(result)
    

sentence = "python is easy and python is powerful"
words = set(sentence.split())
print("Unique words:", len(words))
    

A = {1, 2, 3}
B = {1, 2, 3}
print(A == B)
    

A = {1, 2}
B = {1, 2, 3, 4}
print(A.issubset(B))
print(B.issuperset(A))
    

A = {1, 2, 3}
B = {3, 4, 5}
print(A ^ B)
    

A = {10, 20, 30}
A.clear()
print(A)
    

nums = [1, 2, 2, 3, 3, 4]
unique_list = list(set(nums))
print(unique_list)
    

💡 Interview Questions

• Q: Why sets don’t allow duplicates?
  A: Because sets internally use hashing, and each hash must be unique.
• Q: Can we store list in a set?
  A: No, because lists are mutable (unhashable).
• Q: How do you add multiple elements at once?
  A: Using update() method.
• Q: What is the difference between remove() and discard()?
  A: remove() gives error if element not found, discard() does not.

🧠 Summary

• Set is an unordered, mutable collection of unique elements.
• Used for mathematical operations like union/intersection.
• No duplicate or indexing allowed.
• Best for fast membership testing and unique data storage.

📘 Introduction

Python में Indexing, Slicing, और Concatenation sequence data types (जैसे list, string, tuple) के साथ काम करने के लिए basic और powerful concepts हैं। इनका use data को access, extract और combine करने के लिए किया जाता है।

🧱 1️⃣ Indexing

Indexing का मतलब होता है किसी sequence के element को उसकी position (index number) से access करना। Python में indexing 0 से शुरू होती है।

💡 Syntax:

sequence[index]
  

📘 Example (String):

name = "PYTHON"
print(name[0])   # First character
print(name[3])   # Fourth character
print(name[-1])  # Last character
  

Output:
P
H
N

📘 Example (List):

fruits = ["apple", "banana", "cherry", "mango"]
print(fruits[1])
print(fruits[-2])
  

Output:
banana
cherry

✂️ 2️⃣ Slicing

Slicing का मतलब है किसी sequence का हिस्सा (subsequence) निकालना। यह तीन parameters पर आधारित होता है:

• start → जहाँ से slice शुरू होता है
• stop → जहाँ slice रुकता है (excluded)
• step → कितनी दूरी पर elements लिए जाएँ

💡 Syntax:

sequence[start : stop : step]
  

📘 Example (String Slicing):

text = "PYTHON"
print(text[0:3])   # P, Y, T
print(text[2:5])   # T, H, O
print(text[:4])    # P, Y, T, H
print(text[2:])    # T, H, O, N
print(text[::-1])  # Reverse string
  

Output:
PYT
THO
PYTH
THON
NOHTYP

📘 Example (List Slicing):

numbers = [10, 20, 30, 40, 50, 60]
print(numbers[1:4])
print(numbers[:3])
print(numbers[::2])
print(numbers[::-1])
  

Output:
[20, 30, 40]
[10, 20, 30]
[10, 30, 50]
[60, 50, 40, 30, 20, 10]

🔗 3️⃣ Concatenation

Concatenation का मतलब है दो या अधिक sequences को जोड़ना (combine करना)। Python में + operator से concatenation किया जाता है।

📘 Example (String Concatenation):

a = "Hello"
b = "World"
result = a + " " + b
print(result)
  

Output:
Hello World

📘 Example (List Concatenation):

list1 = [1, 2, 3]
list2 = [4, 5, 6]
merged = list1 + list2
print(merged)
  

Output:
[1, 2, 3, 4, 5, 6]

📘 Example (Tuple Concatenation):

t1 = (10, 20)
t2 = (30, 40)
print(t1 + t2)
  

Output:
(10, 20, 30, 40)

🧮 Advanced Slicing Examples

data = "INFORMATION"
print(data[0:5])      # First 5 characters
print(data[-5:])      # Last 5 characters
print(data[::2])      # Every second character
print(data[::-2])     # Reverse skip 2 chars
  

Output:
INFOR
ATION
IFRMTN
NTROI

📘 Slicing with Step Values

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(nums[::3])
print(nums[1:8:2])
print(nums[5:2:-1])
  

Output:
[1, 4, 7]
[2, 4, 6, 8]
[6, 5, 4]

💻 Practical Programs

text = "python"
rev = text[::-1]
print(rev)
    

word = "programming"
print(word[:3] + word[-3:])
    

A = [1, 2, 3]
B = [4, 5, 6, 7]
merged = A + B
print(merged)
print("Total Length:", len(merged))
    

nums = [10, 20, 30, 40, 50, 60]
print(nums[:2] + nums[-2:])
    

txt = "PYTHONPROGRAM"
print(txt[::2])
    

boys = ("Amit", "Ravi")
girls = ("Neha", "Pooja")
students = boys + girls
print(students)
    

A = [10, 20, 30]
B = A[:]
print(B)
    

text = input("Enter a word: ")
print("First 3 letters:", text[:3])
print("Last 3 letters:", text[-3:])
    

nums = [1, 2, 3, 4, 5]
print(nums[::-1])
    

word = "madam"
if word == word[::-1]:
    print("Palindrome")
else:
    print("Not Palindrome")
    

💬 Interview Questions

• Q: What does slicing return?
  A: A new subsequence (string, list, or tuple).
• Q: Is slicing mutable?
  A: No, slicing itself creates a new object; original sequence remains unchanged.
• Q: Can we slice a tuple?
  A: Yes, slicing works on tuples but the result is a new tuple.
• Q: What is difference between indexing and slicing?
  A: Indexing fetches one element; slicing fetches a range of elements.
• Q: What is concatenation operator?
  A: The + operator joins two sequences of same type.

🧠 Summary

• Indexing → Access single element by position.
• Slicing → Extract a range using start:stop:step.
• Concatenation → Combine multiple sequences.
• Works with strings, lists, and tuples.
• Powerful tool for data manipulation and copying.

📘 Introduction

Python में हर object (जैसे list, tuple, string, set, dictionary आदि) memory में एक reference के रूप में store होता है। Mutability यह बताती है कि कोई object memory में बदल सकता है या नहीं।

• ✅ Mutable objects – जिन्हें हम change (modify) कर सकते हैं।
• 🚫 Immutable objects – जिन्हें एक बार बनाने के बाद बदला नहीं जा सकता।

💡 Simple Meaning:

- Mutable → Changeable in place (same memory id)
- Immutable → Creates new object when changed

🧱 Examples of Mutable & Immutable Types

🔹 1️⃣ Mutable Objects Example

# Lists are mutable
fruits = ["apple", "banana", "cherry"]
print(id(fruits))  # memory id before change

fruits.append("mango")
print(fruits)
print(id(fruits))  # memory id remains same
  

Output:
2638412471552
['apple', 'banana', 'cherry', 'mango']
2638412471552 (same id → object modified in place)

🔹 2️⃣ Immutable Objects Example

# Strings are immutable
text = "Python"
print(id(text))  # before change

text = text + "3.11"
print(text)
print(id(text))  # new id created
  

Output:
1890314117296
Python3.11
1890314117360 (new id → new object created)

💡 How Mutability Works Internally

जब आप mutable object (जैसे list या dict) को modify करते हैं, Python उसी memory address पर changes करता है। लेकिन immutable object (जैसे string, tuple, int) को बदलने की कोशिश करने पर Python एक new object बनाता है।

a = 10
b = a
print(id(a), id(b))  # same id initially

b = b + 5
print(id(a), id(b))  # new id for b (immutable)
  

Output:
145231232
145231280 (b changes → new object created)

🧩 Example: Mutable List vs Immutable Tuple

# List example
A = [1, 2, 3]
B = A
B.append(4)
print("A:", A)
print("B:", B)

# Tuple example
X = (1, 2, 3)
Y = X
Y = Y + (4,)
print("X:", X)
print("Y:", Y)
  

Output:
A: [1, 2, 3, 4]
B: [1, 2, 3, 4]
X: (1, 2, 3)
Y: (1, 2, 3, 4)

📘 Mutable Dictionary Example

student = {"name": "Amit", "age": 20}
print(id(student))

student["age"] = 21
print(student)
print(id(student))  # same id (changed in place)
  

Output:
2168547857808
{'name': 'Amit', 'age': 21}
2168547857808 (same)

🔍 Check Mutability using id()

a = "Hello"
print(id(a))
a += " World"
print(id(a))  # new object (immutable)

b = [1, 2, 3]
print(id(b))
b.append(4)
print(id(b))  # same object (mutable)
  

Output:
Different id for string
Same id for list

💻 Practical Programs

L = [1, 2, 3]
print("Before:", L)
L[0] = 100
print("After:", L)
    

s = "hello"
try:
    s[0] = "H"
except TypeError as e:
    print(e)
    

num = 5
print(id(num))
num += 1
print(id(num))
    

data = {"x": 10, "y": 20}
data["z"] = 30
print(data)
    

t = (1, 2, 3)
try:
    t[1] = 99
except TypeError:
    print("Tuple is immutable")
    

💬 Interview Questions

• Q: What is mutability in Python?
  A: The ability of an object to change its content without changing its identity (memory address).
• Q: Is string mutable?
  A: No, string is immutable.
• Q: Which data types are mutable?
  A: Lists, Dictionaries, Sets.
• Q: Which data types are immutable?
  A: Strings, Tuples, Integers, Floats.
• Q: How to test mutability?
  A: By comparing id() before and after modification.

🧠 Summary

• Mutability defines if an object can be changed after creation.
• Mutable: list, dict, set → changeable in place.
• Immutable: str, tuple, int, float → new object created when modified.
• Check memory ids using id() function.

💡 Example 1: Modifying a List (Mutable Object)

Lists mutable होते हैं — यानी इनकी values बदलने पर object का id() नहीं बदलता।

numbers = [10, 20, 30]
print("Before:", numbers)
print("Memory ID:", id(numbers))

numbers.append(40)
print("After:", numbers)
print("Memory ID:", id(numbers))  # Same ID
  

Output:
Before: [10, 20, 30]
After: [10, 20, 30, 40]
Same memory id → Mutable

💡 Example 2: String Modification (Immutable)

Strings immutable होते हैं — किसी भी परिवर्तन से नया object बनता है।

text = "Python"
print("Before ID:", id(text))
text += "3.11"
print("After ID:", id(text))
  

Output:
Different IDs → Immutable

💡 Example 3: Modifying a Dictionary (Mutable)

Dictionaries mutable होते हैं — नए key-value pair जोड़ने पर भी id वही रहती है।

student = {"name": "Amit", "age": 20}
print("Before ID:", id(student))
student["grade"] = "A"
print(student)
print("After ID:", id(student))
  

Output:
Same ID → Dictionary is mutable

💡 Example 4: Tuples are Immutable

Tuple के elements को बदला नहीं जा सकता — कोशिश करने पर error आता है।

data = (1, 2, 3)
try:
    data[0] = 99
except TypeError as e:
    print(e)
  

Output:
'tuple' object does not support item assignment

💡 Example 5: Mutable Inside Immutable (Nested Example)

Tuple immutable होता है, लेकिन अगर उसके अंदर list हो तो list mutable रहती है।

t = (1, [2, 3], 4)
print("Before:", t)
t[1].append(99)
print("After:", t)
  

Output:
Before: (1, [2, 3], 4)
After: (1, [2, 3, 99], 4)

💡 Example 6: Set Modification

Set mutable होता है — elements add/remove किए जा सकते हैं।

colors = {"red", "green"}
print("Before:", colors)
colors.add("blue")
print("After:", colors)
  

Output:
Before: {'red', 'green'}
After: {'red', 'blue', 'green'}

💡 Example 7: Integer Immutability

Integers immutable होते हैं — एक नई value assign करने से नया object बनता है।

x = 10
print("Before ID:", id(x))
x += 5
print("After ID:", id(x))
  

Output:
Different IDs → Integers are immutable

💡 Example 8: Copying Mutable Objects

जब दो variables एक ही list को refer करते हैं तो एक को बदलने से दूसरा भी बदल जाता है।

A = [1, 2, 3]
B = A  # Both refer to same object
B.append(4)
print("A:", A)
print("B:", B)
print("Same ID?", id(A) == id(B))
  

Output:
A: [1, 2, 3, 4]
B: [1, 2, 3, 4]
Same ID? True → Mutability confirmed