Tuples and Dictionaries – NCERT Class 11 Computer Science Chapter 10 – Tuple Operations and Dictionary Handling in Python

Enhanced Full Chapter Summary & Precise Notes from NCERT PDF (22 Pages)

Overview & Key Concepts

Exact Definition: "A tuple is an ordered sequence of elements of different data types... enclosed in parenthesis and separated by commas."

Introduction: Builds on sequences (Ch5); Tuples: Immutable ordered; Dicts: Mutable mapping of keys:values.
Chapter Structure: Tuples (intro/access/ops/methods/assign/nested/handling); Dicts (intro/creation/access/mutable/ops/traverse/methods/manip).
2025 Relevance: Tuples for fixed data (e.g., coords in ML); Dicts for JSON/web data; Immutability for safety in APIs.

10.1 Introduction to Tuples

Precise: Ordered seq of mixed types; () commas; Indexed from 0; Single elem needs comma.

Precise Example 10.1: Tuple Creation (SVG)

10.1.1 Accessing Elements

Precise: Indexing/slicing like lists; [0] first, [-1] last; IndexError out-range.

Precise Table 10.1: Indexing (2,4,6,8,10,12) (SVG)

10.1.2 Immutability

Precise: Cannot change elems; TypeError; But mutable elems (lists) can change.

10.2-10.6 Tuples Ops/Methods/Handling

Precise: + * in/not in slicing; len() tuple() count() index() sorted() min/max/sum; Assign unpack; Nested; Programs 10-1 to 10-4.

10.7-10.12 Dictionaries

Precise: {key:value} mutable; Keys immutable unique; Access [key]; in/not in; Traverse for key/value/items(); Methods: len dict keys values items get update del clear; Programs 10-5 to 10-8.

Enhanced Features (2025)

Full PDF integration, expanded programs (10-1 to 10-8), SVGs (indexing/slicing), detailed tables/examples, NCERT Exercises Q&A updated, 10-Q quiz. Focus: Immutable vs mutable collections.

Exam Tips

Predict outputs (unpacking/indexing); Write UDFs (swap/nested); List methods (Tables 10.1-10.2); Explain immutability/mutability; Practice traversal/dict manip.

Tuples Basics - Creation, Indexing & Immutability Expanded

Core: Ordered immutable seq; () commas; Access [index]; Single: (20,).

10.1.1 Indexing (Detailed)

Syntax: t[0] first; t[-1] last; Slice [n:m].
Example: (2,4,6,8,10,12)[0] → 2; [3] → 8.

Indexing Flow (SVG)

Immutability:

t[4]=10 → TypeError; But t[3][1]=10 if list inside.

Tip: 2025: Tuples in data pipelines for fixed schemas.

Tuple Operations - Concat, Rep, Mem, Slice Expanded

Core: + * in [n:m:k].

10.2 Operations (Detailed)

Concat: (1,3,5)+(2,4,6) → (1,3,5,2,4,6).
Rep: ('Hello',)*4 → ('Hello',)*4.
Mem: 5 in t → True.
Slice: t[2:7] → Subtuple; [::2] even indices.

Slicing Example (SVG)

Example: Slicing

t = (10,20,30,40,50,60,70,80)
print(t[2:7])  # (30,40,50,60,70)
print(t[::-1])  # (80,70,60,50,40,30,20,10)

Tip: 2025: Tuple slicing in NumPy arrays.

Tuple Methods & Built-in Functions - Table 10.1 Expanded

Core: len() tuple() count() index() sorted() min/max/sum.

Method	Description	Example
len()	Number of elems	len((1,2,3)) → 3
tuple()	Create from seq	tuple([1,2]) → (1,2)
count(x)	Occurrences	(1,2,1).count(1) → 2
index(x)	First index	(1,2,3).index(2) → 1
sorted()	New sorted list	sorted((3,1,2)) → [1,2,3]
min()	Smallest	min((1,2,3)) → 1
max()	Largest	max((1,2,3)) → 3
sum()	Sum elems	sum((1,2,3)) → 6

Tip: 2025: Tuples in set operations for unique data.

Tuple Handling - Programs 10-1 to 10-4 Expanded

Core: Nested, swap, circle func, input max/min.

Program 10-1: Nested Student Records

# Program 10-1
st = ((101,"Aman",98),(102,"Geet",95),(103,"Sahil",87),(104,"Pawan",79))
print("S_No"," Roll_No","   Name"," Marks")
for i in range(0,len(st)):
    print((i+1),'\t',st[i][0],'\t',st[i][1],'\t',st[i][2])

Output: S_No Roll_No Name Marks
1 101 Aman 98
2 102 Geet 95
3 103 Sahil 87
4 104 Pawan 79

Program 10-2: Swap Numbers

# Program 10-2
num1 = int(input('Enter the first number: '))
num2 = int(input('Enter the second number: '))
print("\nNumbers before swapping:")
print("First Number:",num1)
print("Second Number:",num2)
(num1,num2) = (num2,num1)
print("\nNumbers after swapping:")
print("First Number:",num1)
print("Second Number:",num2)

Output: Enter first:5 Enter second:10
Before:5 10 After:10 5

Program 10-3: Circle Area/Circum

# Program 10-3
def circle(r):
    area = 3.14*r*r
    circumference = 2*3.14*r
    return (area,circumference)
radius = int(input('Enter radius of circle: '))
area,circumference = circle(radius)
print('Area of circle is:',area)
print('Circumference of circle is:',circumference)

Output: Enter radius:5
Area:78.5 Circum:31.4

Program 10-4: Input n Numbers Max/Min

# Program 10-4
numbers = tuple()
n = int(input("How many numbers you want to enter?: "))
for i in range(0,n):
    num = int(input())
    numbers = numbers +(num,)
print('\nThe numbers in the tuple are:')
print(numbers)
print("\nThe maximum number is:")
print(max(numbers))
print("The minimum number is:")
print(min(numbers))

Output: How many:5
9 8 10 12 15
Tuple:(9,8,10,12,15) Max:15 Min:8

Tip: 2025: Tuple unpacking in ML data returns.

Dictionaries Basics - Creation, Accessing & Mutability Expanded

Core: {key:value} ordered; Keys immutable unique; Access [key]; Mutable.

10.7.1 Creation (Detailed)

Syntax: {} or dict(); key:value pairs.
Example: {'Mohan':95,'Ram':89}.

Creation Flow (SVG)

Mutability:

d['key']='new'; del d['key'].

Tip: 2025: Dicts in REST APIs for JSON.

Dictionary Operations - Membership, Traversing Expanded

Core: in/not in; for key in d; for k,v in d.items().

10.9-10.10 Operations (Detailed)

Mem: 'Ram' in d → True.
Traverse: for key in d: print(key, d[key]).

Example: Traverse

d = {'Mohan':95,'Ram':89,'Suhel':92,'Sangeeta':85}
for key,value in d.items():
    print(key,':',value)

Tip: 2025: Dict comprehension for data transforms.

Dictionary Methods & Built-in Functions - Table 10.2 Expanded

Core: len() dict() keys() values() items() get() update() del clear().

Method	Description	Example
len()	Num pairs	len(d) → 4
dict()	From pairs	dict([('a',1)]) → {'a':1}
keys()	List keys	d.keys() → dict_keys(['Mohan',...])
values()	List values	d.values() → dict_values([95,...])
items()	Key-val tuples	d.items() → dict_items([('Mohan',95),...])
get(k)	Value or None	d.get('Ram') → 89
update(other)	Merge dicts	d.update({'new':10})
del d[k]	Delete pair	del d['Ram']
clear()	Empty dict	d.clear() → {}

Tip: 2025: defaultdict for counters in analytics.

Dictionary Handling - Programs 10-5 to 10-8 Expanded

Core: ODD dict ops; Employee dict; Char count; Num to words.

Program 10-5: ODD Dict Operations

ODD = {1:'One',3:'Three',5:'Five',7:'Seven',9:'Nine'}
print(ODD.keys())  # dict_keys([1,3,5,7,9])
print(ODD.values())  # dict_values(['One',...])
print(ODD.items())  # dict_items([(1,'One'),...])
print(len(ODD))  # 5
print(7 in ODD)  # True
print(2 in ODD)  # False
print(ODD.get(9))  # 'Nine'
del ODD[9]
print(ODD)  # {1:'One',...}

Program 10-6: Employee Dict

# Program 10-6
num = int(input("Enter the number of employees whose data to be stored: "))
count = 1
employee = dict()
while count <= num:
    name = input("Enter the name of the Employee: ")
    salary = int(input("Enter the salary: "))
    employee[name] = salary
    count += 1
print("\n\nEMPLOYEE_NAME\tSALARY")
for k in employee:
    print(k,'\t\t',employee[k])

Output: Enter num:5
Names/Sal: Tarun12000 Amina34000 ...
EMPLOYEE_NAME SALARY
'Tarun' 12000 ...

Program 10-7: Char Count in String

# Program 10-7
st = input("Enter a string: ")
dic = {}
for ch in st:
    if ch in dic:
        dic[ch] += 1
    else:
        dic[ch] = 1
for key in dic:
    print(key,':',dic[key])

Output: Enter:HelloWorld
H:1 e:1 l:3 o:2 W:1 r:1 d:1

Program 10-8: Num to Words

# Program 10-8
def convert(num):
    numberNames = {0:'Zero',1:'One',2:'Two',3:'Three',4:'Four',5:'Five',6:'Six',7:'Seven',8:'Eight',9:'Nine'}
    result = ''
    for ch in num:
        key = int(ch)
        value = numberNames[key]
        result = result + ' ' + value
    return result
num = input("Enter any number: ")
result = convert(num)
print("The number is:",num)
print("The numberName is:",result)

Output: Enter:6512
The number is:6512
The numberName is: Six Five One Two

Tip: 2025: Dicts in config files for apps.

NCERT Exercises - Questions & Answers

Based on full NCERT Chapter 10. Structured like textbook with full questions and detailed answers.

Question 1: Consider the following tuples, tuple1 and tuple2: tuple1 = (23,1,45,67,45,9,55,45) tuple2 = (100,200). Find the output...

i. print(tuple1.index(45))

Ans: 2

ii. print(tuple1.count(45))

Ans: 3

iii. print(tuple1 + tuple2)

Ans: (23, 1, 45, 67, 45, 9, 55, 45, 100, 200)

iv. print(len(tuple2))

Ans: 2

v. print(max(tuple1))

Ans: 67

vi. print(min(tuple1))

Ans: 1

vii. print(sum(tuple2))

Ans: 300

viii. print(sorted(tuple1)); print(tuple1)

Ans: [1, 9, 23, 45, 45, 45, 55, 67]
(23, 1, 45, 67, 45, 9, 55, 45)

Question 2: Consider the following dictionary stateCapital: stateCapital = {"AndhraPradesh":"Hyderabad", "Bihar":"Patna","Maharashtra":"Mumbai", "Rajasthan":"Jaipur"}. Find the output...

i. print(stateCapital.get("Bihar"))

Ans: Patna

ii. print(stateCapital.keys())

Ans: dict_keys(['AndhraPradesh', 'Bihar', 'Maharashtra', 'Rajasthan'])

iii. print(stateCapital.values())

Ans: dict_values(['Hyderabad', 'Patna', 'Mumbai', 'Jaipur'])

iv. print(stateCapital.items())

Ans: dict_items([('AndhraPradesh', 'Hyderabad'), ...])

v. print(len(stateCapital))

Ans: 4

vi. print("Maharashtra" in stateCapital)

Ans: True

vii. print(stateCapital.get("Assam"))

Ans: None

viii. del stateCapital["Rajasthan"]; print(stateCapital)

Ans: {'AndhraPradesh':'Hyderabad', 'Bihar':'Patna', 'Maharashtra':'Mumbai'}

Question 3: “Lists and Tuples are ordered”. Explain.

Ans:

Both maintain insertion order; Access by index; Tuples immutable, lists mutable.

Question 4: With the help of an example show how can you return more than one value from a function.

Ans:

def circle(r):
    return (3.14*r*r, 2*3.14*r)  # Tuple return
a,c = circle(5)  # Unpack

Question 5: What advantages do tuples have over lists?

Ans:

Faster iteration; Immutable (safety); Smaller memory; Hashable (keys in dicts/sets).

Question 6: When to use tuple or dictionary in Python. Give some examples...

Ans:

Tuple: Fixed data e.g., coords (x,y); Dict: Key-val e.g., student {'roll':101, 'name':'Aman'}.

Question 7: Prove with the help of an example that the variable is rebuilt in case of immutable data types.

Ans:

t = (1,2,3)
id1 = id(t)
t += (4,)
id2 = id(t)  # Different ID: new tuple

Question 8: TypeError occurs while statement 2... Give reason. How can it be corrected? tuple1 = (5) len(tuple1)

Ans:

Reason: (5) is int, not tuple. Correct: tuple1 = (5,); len((5,)) → 1.

Programming Problems

1. Write a program to read email IDs... usernames/domains tuples.

Ans:

emails = tuple()
n = int(input("Num emails: "))
for _ in range(n):
    email = input("Email: ")
    emails += (email,)
usernames = tuple(email.split('@')[0] for email in emails)
domains = tuple(email.split('@')[1] for email in emails)
print(emails, usernames, domains)

2. Input n students names tuple; Search name.

Ans:

names = tuple()
n = int(input("Num students: "))
for _ in range(n): names += (input("Name: "),)
search = input("Search name: ")
print(search in names)

3. Python program to find highest 2 values in dict.

Ans:

d = {'a':10,'b':20,'c':30,'d':40}
vals = sorted(d.values(), reverse=True)[:2]
print(vals)  # [40,30]

4. Create dict from string (char count).

Ans:

s = 'w3resource'
d = {}
for c in s: d[c] = d.get(c,0) + 1
print(d)  # {'w':1,'3':1,'r':2,...}

5. Friends names/phone dict; Ops a-f.

Ans:

friends = {}
n = int(input("Num friends: "))
for _ in range(n):
    name = input("Name: ")
    phone = input("Phone: ")
    friends[name] = phone
# a) for k,v in friends.items(): print(k,v)
# b) friends['new'] = '123'
# c) del friends['old']
# d) friends['exist'] = '456'
# e) print('name' in friends)
# f) for k in sorted(friends): print(k, friends[k])

Tip: Practice these for board exams; Focus on outputs and UDF logic.

Quick Revision Notes & Enhanced Mnemonics

Tuples

() commas; Immutable

Mnemonic: "PIC" (Parenthesis Immutable Commas).

Indexing

[0] first; Slice [n:m]

Mnemonic: "FS" (First Slice).

Ops

+ * in [::]

Mnemonic: "+*in Slice".

Methods

len count index min max

Mnemonic: "LCIMMS".

Dicts

{k:v} mutable keys unique

Mnemonic: "MKU" (Mutable Keys Unique).

Dict Methods

keys values items get update

Mnemonic: "KVI GU".

Overall: "Tuple Intro Ops Methods Handle Dict Intro Ops Methods Manip" (T I O M H D I O M M). Flashcards ready.

Interactive Quiz: 10 Updated Questions from Full Chapter

Added dict/tuple handling Qs.

Key Concepts & Processes - Expanded Table

Concept	Precise Description	Example	Process/2025 Note
Tuple Create	() commas mixed types	(1,'a', [1,2])	Single: (x,)
Indexing	[0 to n-1]; [-n to -1]	t[0] → First	Slice for subtuple
Immutability	No elem change	t[0]=2 Error	But mutable inside ok
Tuple Ops	+ * in [n:m:k]	(1,2)+(3,4)	Concat creates new
Tuple Methods	len count index sorted	t.count(1)	min/max for nums
Unpack	(a,b)=(1,2)	Assign tuple elems	Match num vars
Dict Create	{k:v} keys immutable	{'a':1}	Ordered pairs
Dict Access	d[k]; get(k)	d['a'] → 1	KeyError if missing
Dict Mutable	Add/mod/del	d['b']=2	update() merge
Traverse	for k in d; items()	Print key:val	sorted(keys)

Tip: 2025: Tuples/dicts in pandas DataFrames.