Select Medium / माध्यम चुनें:

CBSE • Class XI • Computer Science • Ch 10

Estimated Time: 45 Mins

Study Progress: In Progress

Tuples and Dictionaries

In CBSE Class 11 Computer Science, "Tuples and Dictionaries" provides an exhaustive master resource on immutable records and hash-table key-value mappings in Python. This comprehensive chapter covers tuple immutability, the single-element tuple comma rule, tuple packing and unpacking, dictionary associative key-value mapping architecture, key hashability requirements, dictionary traversal, dynamic updating, and dictionary methods (`keys()`, `values()`, `items()`, `get()`, `update()`, `pop()`, `popitem()`) aligned with the 2026–27 CBSE curriculum.

Take Chapter CBT Test View All Chapters

Overview Core Concepts Syntax & Core Commands Summary Self Check Take MCQ Test

Why Do Computers Need Both Unchangeable Records and Instant-Lookup Phonebooks?

Consider two different data scenarios in software: First, GPS coordinates for the Taj Mahal (27.1751, 78.0421). You would never want any function to accidentally modify latitude or longitude in memory. Second, a dictionary storing user profiles where you can instantly look up any username among 100 million accounts in less than a microsecond. To solve these dual challenges, Python provides two specialized data structures: Tuples (immutable sequences that guarantee data integrity) and Dictionaries (hash-map key-value stores that deliver O(1) constant-time lookups). How do tuples protect data from accidental corruption, and how do hash functions allow dictionaries to locate values instantaneously? This chapter masters advanced data structures.

Why This Chapter Matters

Tuples and dictionaries are fundamental to professional Python software architecture. Tuples are used everywhere data immutability and memory optimization are required—such as returning multiple values from functions, database query row representations, and dictionary keys. Dictionaries form the backbone of JSON APIs, configuration files, caching layers, and database records. Understanding dictionary hash tables and key immutability requirements is essential for every aspiring backend and data engineer.

Before You Begin (Prerequisites)

Lists, mutability vs immutability concepts.
Sequence indexing and slicing.
Looping constructs: iterating through collections.

What You Will Learn (Core Objectives)

Construct tuples and master the single-element comma rule (`t = (5,)` vs `t = (5)`).
Apply tuple packing and unpacking to swap variables and process function return values.
Explain tuple immutability and why tuples are hashable and valid as dictionary keys.
Construct dictionaries using key-value pairs and understand the hashability requirement for keys.
Access dictionary elements safely using `d.get(key, default)` to prevent `KeyError` exceptions.
Execute dictionary methods: `keys()`, `values()`, `items()`, `update()`, `pop()`, and `clear()`.
Traverse key-value pairs simultaneously using `for k, v in d.items():`.

Chapter Roadmap & Progression

1 1. Tuples: Immutable Ordered Record...

2 2. Dictionaries: Associative Key-Va...

3 3. Dictionary Methods & Iteration A...

Complete Concept Guide (100% Curriculum Coverage)

1. Tuples: Immutable Ordered Records

Understand

A Tuple is an immutable, ordered sequence of heterogeneous elements enclosed in parentheses (`(...)`):

The Single-Element Tuple Comma Rule (CRITICAL EXAM TRAP):

Parentheses alone do not make a tuple—parentheses are also used for mathematical grouping. To define a single-element tuple, a trailing comma is mandatory:

t1 = (5)    # NOT a tuple! Evaluates to integer: type(t1) is <class 'int'>
t2 = (5,)   # VALID single-element tuple: type(t2) is <class 'tuple'>

Tuple Packing and Unpacking

# Tuple Packing:
record = "Aarav", 11, 94.5    # Packed into tuple ('Aarav', 11, 94.5)

# Tuple Unpacking:
name, grade, marks = record   # Unpacks into 3 individual variables
print(name, marks)            # Aarav 94.5

2. Dictionaries: Associative Key-Value Mappings

Understand

A Dictionary is a mutable mapping data structure storing unordered (insertion-ordered in modern Python) pairs of `key: value` enclosed in curly braces (`{...}`):

Dictionary Key Requirements (The Hashability Law):

Keys Must Be Unique: Duplicate keys are not permitted; assigning to an existing key overwrites its previous value.
Keys Must Be Immutable: A key must belong to an immutable data type (`int`, `float`, `str`, `tuple`). A mutable type like a `list` or another `dict` cannot be a key and raises `TypeError: unhashable type: 'list'`!
Values Can Be Anything: Values can be mutable or immutable, unique or duplicated.

Safe Element Access: `dict[key]` vs `dict.get(key, default)`

student = {"name": "Sneha", "roll": 101}

# Direct indexing raises KeyError if key is absent:
# print(student["marks"]) # KeyError: 'marks'!

# Safe access with .get():
marks = student.get("marks", 0.0) # Returns 0.0 without crashing!
print(marks) # 0.0

3. Dictionary Methods & Iteration Algorithms

Understand & Reference

Method	Action	Example Code
`d.keys()`	Returns a view object of all keys.	`d.keys()` → `dict_keys(['a', 'b'])`
`d.values()`	Returns a view object of all values.	`d.values()` → `dict_values([10, 20])`
`d.items()`	Returns key-value pairs as a view of tuples.	`d.items()` → `dict_items([('a', 10), ('b', 20)])`
`d.update(other)`	Merges key-value pairs from `other` into `d`.	`d.update({'c': 30})`
`d.pop(key[, default])`	Removes `key` and returns its value.	`val = d.pop('a')`
`d.popitem()`	Removes and returns the last inserted `(key, value)` tuple.	`k, v = d.popitem()`
`d.clear()`	Empties the dictionary.	`d.clear()` → `{}`

Simultaneous Key-Value Traversal:

grades = {"Aarav": 95, "Sneha": 98, "Rohan": 88}
for student, score in grades.items():
    print(f"{student}: {score}")

Key Programming Syntax, Statements & Translator Rules

Dictionary Lookup Complexity

$$O(1) \text{ Average Time Complexity}$$

Hash table indexing enables instantaneous lookups regardless of dictionary size.

Key Hashability Condition

$$\text{hash}(key) \neq \text{Error} \iff key \in \text{Immutable Types}$$

Only hashable immutable objects can serve as dictionary keys.

Tuples vs Dictionaries Architecture Map

Chapter Summary & 10 Key Takeaways

Takeaway 1

A tuple is an ordered, immutable sequence of heterogeneous elements enclosed in parentheses `(...)`.

Takeaway 2

A single-element tuple requires a trailing comma: `t = (5,)`; omitting the comma creates an integer `(5)`.

Takeaway 3

Tuple packing groups values into a tuple; tuple unpacking extracts values into individual variables.

Takeaway 4

Because tuples are immutable, they are hashable and can serve as dictionary keys.

Takeaway 5

A dictionary is a mutable, associative mapping of `key: value` pairs enclosed in curly braces `{...}`.

Takeaway 6

Dictionary keys must be unique and immutable (`int`, `str`, `tuple`); values can be of any data type.

Takeaway 7

Using a mutable type (such as a list) as a dictionary key raises a `TypeError: unhashable type: 'list'`.

Takeaway 8

The `get(key, default)` method accesses values safely without triggering a `KeyError` if the key is absent.

Takeaway 9

`d.keys()`, `d.values()`, and `d.items()` return dynamic view objects of keys, values, and `(key, value)` tuples.

Takeaway 10

Dictionary lookups operate in $O(1)$ average time complexity due to internal hash table indexing.

Check Your Understanding (Diagnostic Practice Questions)

Diagnostic questions testing core conceptual clarity. Answers are hidden initially — solve each problem first, then click to reveal the step-by-step verified solution.

Explain why `t = (10)` is not a tuple in Python, while `t = (10,)` is. How does Python interpret `t = (10)`?

Reveal Answer & Explanation

Answer: In Python, parentheses are used for mathematical expression grouping (operator precedence). When Python sees `t = (10)`, it interprets the parentheses as mathematical grouping around the integer 10, resulting in `type(t)` being ``. To disambiguate and declare a single-element tuple, Python requires a trailing comma: `t = (10,)`.
Parentheses without a comma denote algebraic grouping; a comma creates a tuple.

Can a list be used as a key in a Python dictionary? Can a tuple? Explain using Python's hashability rules.

Reveal Answer & Explanation

Answer: A list CANNOT be used as a dictionary key; doing so raises a `TypeError: unhashable type: 'list'`. This is because dictionary keys must be hashable—their hash value must remain constant throughout their lifetime. Because lists are mutable, their contents can change, which would corrupt the hash table. In contrast, a tuple containing only immutable elements is immutable and hashable, making it completely valid as a dictionary key.
Dictionary keys must be hashable and immutable; lists are mutable so cannot be keys.

Predict the output of the following code:

d = {"A": 1, "B": 2}
print(d.get("C", 100))
print(d.get("A", 100))
print(d["A"])

Reveal Answer & Explanation

Answer: Output:
100
1
1
Explanation: `"C"` is not in `d`, so `get("C", 100)` returns the default value `100`. `"A"` exists with value `1`, so `get("A", 100)` returns `1` (default ignored). `d["A"]` directly returns `1`.
get() returns value if key exists, otherwise returns the specified default.

What is tuple unpacking? Demonstrate how to swap two variables `a` and `b` in a single line using tuple unpacking.

Reveal Answer & Explanation

Answer: Tuple unpacking is the process of extracting the individual elements of a tuple directly into multiple distinct variables in a single statement.
Variable swapping:
a, b = b, a
Explanation: Python first evaluates the right side, packing `(b, a)` into a temporary tuple in memory. It then unpacks that tuple into the variables on the left side, swapping their values simultaneously without needing a temporary third variable.
a, b = b, a packs right-hand values into a temporary tuple, then unpacks into left.

Given the dictionary `scores = {"Rohan": 85, "Aarav": 92}`, write code to add "Sneha" with 96, update "Rohan" to 89, and remove "Aarav".

Reveal Answer & Explanation

Answer:

scores = {"Rohan": 85, "Aarav": 92}
scores["Sneha"] = 96      # Adds new key "Sneha"
scores["Rohan"] = 89      # Updates existing key "Rohan"
scores.pop("Aarav")       # Removes key "Aarav"
print(scores)             # {'Rohan': 89, 'Sneha': 96}

Assignment adds or updates; .pop(key) removes a key-value pair.

How do you iterate through a dictionary to print each key and its corresponding value? Write a code snippet using `.items()`.

Reveal Answer & Explanation

Answer:

student = {"name": "Priya", "age": 16, "city": "Kolkata"}
for key, value in student.items():
    print(f"{key} -> {value}")

for key, value in d.items(): iterates through unpacked key-value pairs.

What is the output of the following dictionary code?

d = {1: "One", 2: "Two"}
d[1] = "First"
d[True] = "TrueValue"
print(d)

Reveal Answer & Explanation

Answer: Output: `{1: 'TrueValue', 2: 'Two'}`
Explanation: In Python, `bool` is a subclass of `int`. The Boolean literal `True` evaluates to numeric integer `1` (in fact, `1 == True` is `True` and `hash(1) == hash(True)`). Therefore, `d[True]` points to the exact same key as `d[1]`, overwriting its value with `"TrueValue"`.
In Python, True equals integer 1; assigning to d[True] overwrites d[1].

Explain the difference between `d.pop(key)` and `del d[key]`.

Reveal Answer & Explanation

Answer: Both remove the key-value pair from dictionary `d`. However, `d.pop(key)` returns the removed value (and allows an optional default value to prevent errors if the key is missing: `d.pop(key, default)`). In contrast, `del d[key]` is a Python statement that deletes the key in-place, returns nothing, and strictly raises a `KeyError` if the key is absent.
pop() returns the removed value and supports defaults; del returns nothing.

Finished Studying This Chapter?

READY TO PRACTICE?

Timed CBT Practice Tests (Exam Simulator)

Put your concepts to the test with official curriculum-aligned Foundation and Advanced practice tests. Get instant accuracy scores, time metrics, and step-by-step verified explanations.

Foundation Test

15 MCQs • Core Concepts

Advanced Test

15 MCQs • HOTS & Traps