Tuples and Dictionaries Class 11: Operations, Methods and Programs in Python

What Tuples and Dictionaries is about

Weightage: This chapter is part of Unit II, Computational Thinking and Programming - 1, which carries 45 of the 70 theory marks in the school annual exam together with Introduction to Problem Solving, Getting Started with Python, Flow of Control, Strings, Lists and Introduction to Python Modules.Source: CBSE Computer Science (083) syllabus 2026-27, Class XI distribution of marks, Unit II Computational Thinking and Programming - 1

Key concepts

Tuples: creation, indexing and immutability

NCERT section NCERT 10.1

A tuple is an ordered sequence of items, of any types, separated by commas and usually written in round brackets: t = (10, 'ten', 10.5). The comma makes the tuple, not the brackets: t = 1, 2, 3 is a tuple, but (5) is just the int 5, and a one-item tuple needs a trailing comma: (5,). () is the empty tuple; tuple(seq) converts a sequence: tuple('abc') = ('a', 'b', 'c').

Indexing and slicing work as for strings and lists (slices give new tuples). Tuples are immutable: t[0] = 1 raises TypeError, and there are no append or remove methods. But if a tuple contains a mutable item such as a list, that list itself can still be changed. Use a tuple for data that should not change (days of the week, coordinates, a date of birth); tuples can also be dictionary keys, lists cannot.

Worked example

Give type() of each: a = (7), b = (7,), c = 7, 8, d = ('7'). Then say what t = (1, [2, 3]); t[1].append(4); print(t) shows.

Try it first, then show the solutionSolution

1. (7) is just 7 in brackets: int. (7,) is a tuple. 7, 8 is a tuple. ('7') is a str.
2. t[1] is a list inside the tuple; appending changes the list, not which object the tuple holds.

Answer: int, tuple, tuple, str; t prints (1, [2, 3, 4]).

Tuple operations and functions

NCERT section NCERT 10.2, 10.3

• Concatenation t1 + t2 gives a new tuple: (1, 2) + (3,) = (1, 2, 3). Adding a non-tuple, as in (1, 2) + 3, raises TypeError.
• Repetition (0,) * 3 = (0, 0, 0).
• Membership x in t / not in t.
• Slicing t[1:3], t[::-1].

Methods and functions: len(t), tuple(seq), t.count(x) (occurrences), t.index(x) (first position; ValueError if absent), sorted(t) (returns a sorted list, not a tuple), min(t), max(t), sum(t) (numbers only). Because tuples are immutable, they have only the two methods count() and index().

Worked example

t = (4, 9, 2, 9, 7). Give t + (1,), t[1:4], t.count(9), t.index(9), sorted(t), max(t) - min(t), sum(t) / len(t).

Try it first, then show the solutionSolution

1. (4, 9, 2, 9, 7, 1); slice (9, 2, 9).
2. 9 occurs twice; first at index 1.
3. sorted gives the list [2, 4, 7, 9, 9].
4. 9 - 2 = 7; 31 / 5 = 6.2.

Answer: (4, 9, 2, 9, 7, 1), (9, 2, 9), 2, 1, [2, 4, 7, 9, 9], 7, 6.2

Tuple assignment and nested tuples

NCERT section NCERT 10.4, 10.5

Tuple assignment (unpacking) assigns the items of a tuple on the right to the names on the left, in order: (name, roll, marks) = ('Asha', 7, 91). The number of names must equal the number of items, or Python raises ValueError. The right side is evaluated completely first, which is why a, b = b, a swaps two values. The right side can be any expression giving a tuple, e.g. q, r = 17 // 5, 17 % 5.

A nested tuple has tuples as items: records = (('Asha', 91), ('Ravi', 78)). records[1][0] is 'Ravi'. Traverse with a loop, often unpacking each inner tuple: for name, m in records: ...

Worked example

Give the output:

x, y, z = 3, 'b', (5, 6)
p, q = z
print(x * y, p + q)
st = (('Neha', 82), ('Arjun', 95), ('Sara', 88))
for name, m in st:
    if m > 85:
        print(name, end=' ')

Try it first, then show the solutionSolution

1. x = 3, y = 'b', z = (5, 6); unpacking z gives p = 5, q = 6.
2. 3 * 'b' = 'bbb'; 5 + 6 = 11.
3. Inner tuples unpacked: Arjun (95) and Sara (88) are above 85.

Answer: bbb 11
Arjun Sara

Tuple programs: statistics, linear search, frequency

NCERT section NCERT 10.6; syllabus suggested programs

Programs on tuples work like those on lists, using only reading operations: traverse with for, compare, count. Since a tuple cannot be changed, build any result (such as the list of values already counted) in a separate list. If input is needed, read the values into a list and convert with tuple() at the end.

Worked example

For temps = (31, 34, 29, 35, 34, 30, 34), print the mean (2 decimals), the minimum, the maximum and the frequency of 34, and search for 33.

Try it first, then show the solutionSolution

1. temps = (31, 34, 29, 35, 34, 30, 34)
   print(round(sum(temps) / len(temps), 2), min(temps), max(temps))
   print(temps.count(34))
   key = 33
   for i in range(len(temps)):
       if temps[i] == key:
           print('Found at index', i)
           break
   else:
       print(key, 'not found')

2. Sum 227 / 7 = 32.43. 34 appears three times. 33 is absent. (The else after a for loop runs only when the loop ends without break; a found flag works just as well.)

Answer: 32.43 29 35
3
33 not found

Dictionaries: creation and access by key

NCERT section NCERT 10.7, 10.9

A dictionary stores key: value pairs inside curly brackets: d = {'roll': 7, 'name': 'Asha', 'marks': 91}. It is a mapping: you look up a value by its key, not by position.

• Keys must be unique and of an immutable type (str, int, float, tuple); a list as a key raises TypeError. If a key is repeated when the dictionary is written, the last value wins.
• Values can be of any type and can repeat.
• {} is an empty dictionary; dict() also makes one, e.g. dict(a=1, b=2) or dict([('a', 1), ('b', 2)]).
• d[key] returns the value; a missing key raises KeyError. d.get(key) returns None (or a given default) instead of an error.
• key in d checks keys only.

Worked example

d = {'apple': 40, 'mango': 60, 'kiwi': 25}. Give d['mango'], d.get('grape'), d.get('grape', 0), 'kiwi' in d, 25 in d, and what d['grape'] does.

Try it first, then show the solutionSolution

1. 'mango' maps to 60.
2. 'grape' is not a key: get gives None, or the default 0.
3. 'kiwi' is a key: True. 25 is a value, not a key: False.
4. Indexing with a missing key raises KeyError.

Answer: 60, None, 0, True, False; d['grape'] raises KeyError.

Dictionaries are mutable: adding, modifying, deleting

NCERT section NCERT 10.8, 10.11

• Add a pair by assigning to a new key: d['pear'] = 50.
• Modify by assigning to an existing key: d['apple'] = 45 (the old value is replaced).
• del d[key] deletes a pair (KeyError if absent).
• d.pop(key[, default]) removes the key and returns its value; with a default, a missing key returns the default instead of raising KeyError.
• d.popitem() removes and returns the last inserted pair as a tuple (KeyError if the dictionary is empty).
• d.clear() empties the dictionary (it still exists, as {}).
• d.update(other) adds the pairs of another dictionary, overwriting values of keys that already exist.

Worked example

Give the output:

d = {'a': 1, 'b': 2}
d['c'] = 3
d['a'] = 10
d.update({'b': 20, 'd': 4})
print(d)
print(d.pop('c'), d.popitem(), d)

Try it first, then show the solutionSolution

1. Add 'c', change 'a': {'a': 10, 'b': 2, 'c': 3}.
2. update overwrites 'b' and adds 'd': {'a': 10, 'b': 20, 'c': 3, 'd': 4}.
3. pop('c') returns 3; popitem() removes the last pair ('d', 4).

Answer: {'a': 10, 'b': 20, 'c': 3, 'd': 4}
3 ('d', 4) {'a': 10, 'b': 20}

Traversing a dictionary and keys(), values(), items()

NCERT section NCERT 10.10, 10.11

for k in d: loops over the keys; use d[k] for the value. The views:

• d.keys(): all keys, e.g. dict_keys(['a', 'b'])
• d.values(): all values
• d.items(): all pairs as (key, value) tuples; for k, v in d.items(): unpacks each pair

Convert a view with list() when a list is needed. len(d) is the number of pairs. On a dictionary, max(d), min(d) and sorted(d) work on the keys; for values use max(d.values()) or sorted(d.values()).

Worked example

sal = {'Ravi': 42000, 'Meera': 55000, 'Joseph': 38000}. Print each name with salary, then the sorted names, the highest salary and who earns it.

Try it first, then show the solutionSolution

1. sal = {'Ravi': 42000, 'Meera': 55000, 'Joseph': 38000}
   for name, s in sal.items():
       print(name, s)
   print(sorted(sal), max(sal))
   high = max(sal.values())
   for name in sal:
       if sal[name] == high:
           print(name, high)

2. sorted(sal) and max(sal) use the keys (names); max(sal.values()) is 55000.

Answer: Ravi 42000
Meera 55000
Joseph 38000
['Joseph', 'Meera', 'Ravi'] Ravi
Meera 55000

fromkeys(), copy() and setdefault()

NCERT section NCERT 10.11

• dict.fromkeys(keys[, value]) makes a new dictionary with the given keys, all with the same value (None if no value is given): dict.fromkeys(['a', 'b'], 0) = {'a': 0, 'b': 0}.
• d.copy() returns a new dictionary with the same pairs (a shallow copy); changing the copy's pairs does not change d. In contrast, e = d makes an alias.
• d.setdefault(key[, default]): if key exists, returns its value and changes nothing; if not, adds key with the default (None if not given) and returns the default. It is handy for counting and grouping.

Worked example

Give the output:

d = dict.fromkeys(['x', 'y'], 0)
e = d.copy()
e['x'] = 5
print(d, e)
print(d.setdefault('x', 9), d.setdefault('z', 9), d)

Try it first, then show the solutionSolution

1. fromkeys gives {'x': 0, 'y': 0}; e is a separate copy, so only e changes.
2. 'x' exists: setdefault returns 0 and changes nothing. 'z' is missing: added with 9, which is returned.

Answer: {'x': 0, 'y': 0} {'x': 5, 'y': 0}
0 9 {'x': 0, 'y': 0, 'z': 9}

Counting characters with a dictionary

NCERT section NCERT 10.12; syllabus suggested program

A dictionary is the natural tool for frequencies: each distinct item becomes a key and its count the value. The pattern is: if the key is already present, add 1; otherwise start it at 1. The same can be written as d[ch] = d.get(ch, 0) + 1. After the loop, traverse with items() to print the counts.

Worked example

Count how many times each character appears in 'banana' and print the dictionary and the most frequent character.

Try it first, then show the solutionSolution

1. s = 'banana'
   freq = {}
   for ch in s:
       if ch in freq:
           freq[ch] += 1
       else:
           freq[ch] = 1
   print(freq)
   best = ''
   for ch in freq:
       if best == '' or freq[ch] > freq[best]:
           best = ch
   print(best, freq[best])

2. Keys appear in the order first seen: b, a, n.

Answer: {'b': 1, 'a': 3, 'n': 2}
a 3

Tuples and Dictionaries in real life

Each concept, met in an everyday situation. Read the situation, answer the question in your own words, then compare with the model answer. The one-line hook is what to remember.

Topics in this chapter

• Dictionaries: Keys, Values, get, items, update and Counting Characters (CBSE 11)
• Tuples: Immutability, Operations, Tuple Assignment and Programs (CBSE 11)

Tuples and Dictionaries: syntax and key facts

One-item tuple

(x,) is a tuple; (x) is just x

The comma makes the tuple.

Tuple methods

count(x), index(x); functions len, tuple, sorted (→ list), min, max, sum

No methods that change a tuple.

Dictionary access

d[k] (KeyError if missing); d.get(k, default); k in d checks keys

Keys unique and immutable.

Dictionary changes

1. 1.d[k] = v (add or modify); del d[k]; pop(k)
2. 2.value; popitem()
3. 3.last pair; clear(); update(other)

update overwrites existing keys.

Views

keys(), values(), items() → (key, value) pairs

max/min/sorted on d work on keys.

Counting pattern

d[x] = d.get(x, 0) + 1

Or setdefault(x, 0) then d[x] += 1.

How the school exam asks Tuples and Dictionaries

The question patterns to expect, and the method that works for each.

Tricks to remember Tuples and Dictionaries

Short memory aids. Say each one aloud once, then use it on a question the same day.

• Comma, not bracket

  A tuple is born from a comma: (5,) yes, (5) no.

  Use it when: One-item tuple questions.

• Tuple has two tools

  count and index are the only tuple methods: C-I.

  Use it when: Listing tuple methods.

• get is gentle, [ ] is strict

  d.get(k) quietly gives None; d[k] shouts KeyError.

  Use it when: Missing-key questions.

• pop gives the value, popitem gives the pair

  pop(key) → value; popitem() → (key, value) of the last item.

  Use it when: Return values.

• Dictionary functions see keys

  max, min, sorted and in on a dictionary look only at keys.

  Use it when: Output questions.

Tuples and Dictionaries: exam-level solved questions

Ordered from exam level to HOTS. Cover the solution, write your own, then compare step by step.

a, b, c = (1, 2, 3)
a, b, c = c, a, b
print(a, b, c)
q, r = divmod(29, 6)
print(q, r)

d = {'P': 3, 'C': 4, 'M': 5}
d.setdefault('B', 2)
d.setdefault('P', 9)
x = d.pop('C')
d['M'] += x
print(d)
print(sorted(d), max(d.values()), list(d.items())[0])

Case-study practice (Section E style)

Read the situation, then answer every part. In a school exam set on the board pattern this is a 4-mark question split into 1 + 1 + 1 + 1 marks.

Where the marks are

How a typical answer is split into step marks. Show every step: a right final answer alone rarely earns full marks.

Where students lose marks in Tuples and Dictionaries

The slips examiners see most often, and what to write instead.

• ✗Mistake: Writing a one-item tuple without a comma

  (5) is the int 5.

  Wrong working

  t = (5)
  print(type(t)) → tuple

  Right working

  t = (5,) → <class 'tuple'>

  ✓Do this: Always add a trailing comma for one item.

  Usually costs: 1 mark

• ✗Mistake: Saying sorted(t) returns a tuple

  sorted always returns a list.

  Wrong working

  sorted((3, 1, 2)) = (1, 2, 3)

  Right working

  sorted((3, 1, 2)) = [1, 2, 3]; tuple(sorted(t)) gives a tuple

  ✓Do this: Wrap with tuple() if a tuple is needed.

  Usually costs: 1 mark

• ✗Mistake: Using in to search dictionary values

  in checks keys only.

  Wrong working

  60 in {'mango': 60} → True

  Right working

  60 in d → False; 60 in d.values() → True

  ✓Do this: Use d.values() for values.

  Usually costs: 1 mark

• ✗Mistake: Expecting update() to keep old values

  update overwrites the value of any key that already exists.

  Wrong working

  {'a': 1}.update({'a': 2}) leaves 'a' as 1

  Right working

  'a' becomes 2

  ✓Do this: Check for common keys before updating.

  Usually costs: 1 mark

• ✗Mistake: Using a list as a dictionary key

  Keys must be immutable; lists are mutable.

  Wrong working

  d = {[1, 2]: 'pair'}

  Right working

  d = {(1, 2): 'pair'}

  ✓Do this: Use a tuple instead of a list.

  Usually costs: 1 mark

NCERT exercise guide: Tuples and Dictionaries

What each exercise in the NCERT chapter tests, how to approach it, and a question of the same kind solved step by step. Questions here are written in our own words.

t = ('x', 'y') * 2 + ('z',)
print(t, t.index('y'), t.count('x'))
d = {1: 'one', 2: 'two'}
d[3] = d[1] + d[2]
print(d.get(4, 'none'), len(d), d[3])

Practice questions on Tuples and Dictionaries

Write each answer on paper first. Open the hint only if you are stuck, and the answer only when you have finished.

1. Q1 · 1 mark · MCQExam level

   Which of these creates a tuple? (a) t = (4) (b) t = [4] (c) t = 4, (d) t = {4}

   Hint

   Look for the comma.

   Answer

   (c) t = 4,

2. Q2 · 2 marks · Short answerExam level

   Give the output: t = (5, 1, 8, 1); print(t.count(1), t.index(8), sorted(t), sum(t[1:]))

   Hint

   sorted gives a list.

   Answer

   2 2 [1, 1, 5, 8] 10

3. Q3 · 1 mark · Very short answerHarder exam level

   d = {'a': 1, 'b': 2}. Give the output of print(d.pop('a'), d.pop('z', 0), d)

   Hint

   Default value avoids KeyError.

   Answer

   1 0 {'b': 2}

4. Q4 · 1 mark · MCQHarder exam level

   Assertion (A): A dictionary can have a tuple as a key but not a list. Reason (R): Dictionary keys must be of an immutable type. Choose (a) both true, R explains A (b) both true, R does not explain A (c) A true, R false (d) A false, R true.

   Hint

   Why is a list rejected?

   Answer

   (a)

5. Q5 · 2 marks · Short answerHarder exam level

   Predict the output:

   d = {}
   for ch in 'level':
       d[ch] = d.get(ch, 0) + 1
   print(d, len(d), max(d), min(d.values()))

   Hint

   max(d) compares keys.

   Answer

   {'l': 2, 'e': 2, 'v': 1} 3 v 1

6. Q6 · 3 marks · Short answerExam level

   Write a program to input 5 numbers into a tuple and print the largest, smallest and mean, and how many times the largest occurs.

   Hint

   Build a list, then tuple().

   Answer

   L = []
   for i in range(5):
   L.append(int(input()))
   t = tuple(L)
   print(max(t), min(t), sum(t) / len(t), t.count(max(t)))

7. Q7 · 3 marks · Short answerHOTS / competency

   Give the output:

   x = {'k': [1, 2]}
   y = x.copy()
   y['k'].append(3)
   y['j'] = 0
   print(x, y)

   Hint

   copy() is shallow: the list inside is shared.

   Answer

   {'k': [1, 2, 3]} {'k': [1, 2, 3], 'j': 0}

8. Q8 · 2 marks · Short answerHarder exam level

   Write a program that takes a dictionary of states and capitals and prints it sorted by state name, with the capitals in uppercase.

   Hint

   sorted(d) gives keys in order.

   Answer

   cap = {'Kerala': 'Thiruvananthapuram', 'Bihar': 'Patna', 'Goa': 'Panaji'}
   for s in sorted(cap):
   print(s, cap[s].upper())
   Output: Bihar PATNA / Goa PANAJI / Kerala THIRUVANANTHAPURAM

9. Q9 · 1 mark · Very short answerExam level

   Why does a, b = 10 fail while a, b = 10, 20 works? Name the error.

   Hint

   Unpacking needs a sequence.

   Answer

   10 is a single int and cannot be unpacked into two names: TypeError (cannot unpack non-iterable int). 10, 20 is a tuple of two items.

10. Q10 · 3 marks · Short answerHOTS / competency

    Write a program to find which character occurs most often in 'mississippi' using a dictionary; if there is a tie, print all of them.

    Hint

    Find the highest count first, then all keys with it.

    Answer

    s = 'mississippi'
    f = {}
    for c in s:
    f[c] = f.get(c, 0) + 1
    hi = max(f.values())
    for c in f:
    if f[c] == hi:
    print(c, hi)
    Output: i 4 and s 4

11. Q11 · 2 marks · Short answerHarder exam level

    What is the difference between d.clear() and del d?

    Hint

    Does the name still exist afterwards?

    Answer

    d.clear() empties the dictionary, which still exists as {}. del d deletes the name d itself; using d afterwards gives NameError.

12. Q12 · 1 mark · Very short answerHarder exam level

    Give the output: print(dict.fromkeys((1, 2), 'x'), tuple({'a': 1, 'b': 2}))

    Hint

    tuple() of a dictionary takes its keys.

    Answer

    {1: 'x', 2: 'x'} ('a', 'b')

Test your recall

Answer in your head or on paper first, then open the card. Pulling an answer out of memory makes it stick far better than re-reading.

1. 1.Is a tuple mutable?Show answer

   No.

2. 2.What does (1, 2) * 2 give?Show answer

   (1, 2, 1, 2).

3. 3.What error does a, b = (1, 2, 3) give?Show answer

   ValueError (too many values to unpack).

4. 4.What does d.get('x') return when 'x' is not a key?Show answer

   None.

5. 5.What does popitem() remove?Show answer

   The last inserted key-value pair, returned as a tuple.

6. 6.What does dict.fromkeys('ab') give?Show answer

   {'a': None, 'b': None}.

7. 7.What does len() of a dictionary count?Show answer

   The number of key-value pairs.

8. 8.Can a tuple be a dictionary key?Show answer

   Yes, if its items are immutable.

Quick revision checklist

The night before the exam: can you do each of these without looking?

• ☐Tuple: immutable ordered sequence; (x,) for one item; t[0] = ... is a TypeError.
• ☐Tuple methods: count, index; sorted(t) returns a list.
• ☐Unpacking: a, b, c = t needs exactly 3 items; a, b = b, a swaps.
• ☐Dictionary: {key: value}; keys unique and immutable; values any type.
• ☐d[k] raises KeyError if missing; d.get(k) gives None or a default.
• ☐Add/modify: d[k] = v; delete: del, pop (value), popitem (last pair), clear.
• ☐update merges and overwrites; fromkeys makes keys with one value; setdefault adds only if missing.
• ☐keys(), values(), items(); in, max, min, sorted work on keys.

Tuples and Dictionaries: frequently asked questions