Tuples and Dictionaries

Written and reviewed by Rohit Singh, Computer Science & Commerce faculty at UniDrill (MCA, Osmania University · 6 years teaching). Based on NCERT Computer Science Class XI, Chapter 10.

Two containers you already use without knowing it

Whenever a function returns two values, you get a tuple. Whenever you swap two variables with a, b = b, a, tuples do the work. And when you look up a friend's number in your phone, you search by name, not by position 1, 2, 3. That is how a dictionary works. This chapter finishes the family of Python data types: strings and lists you know, now the locked sequence (tuple) and the lookup table (dictionary).

What is a tuple?

A tuple is an ordered sequence of elements of any data types (integers, floats, strings, lists, even other tuples). The elements sit inside round brackets and are separated by commas. Indices start at 0, just as for strings and lists.

The last two show a tuple holding a list and a tuple holding another tuple (a nested tuple).

The single element trap. A tuple with one element needs a trailing comma. Without it, the brackets are just ordinary brackets around a number.

So a sequence of comma separated values without brackets is also treated as a tuple. This is exactly why len((5)) fails with a TypeError, because (5) is the integer 5.

Pause and predict: what is type(('a')), and what is type(('a',))?

Check your answer: ('a') is just the string 'a' in brackets, so its type is str. ('a',) has the comma, so its type is tuple. The comma, not the bracket, makes the tuple.

A tuple is immutable

You can read tuple elements by index and slice them like a list, but you cannot change them. tuple1[4] = 10 raises TypeError: 'tuple' object does not support item assignment.

There is one subtlety. A tuple is locked, but if one of its elements is a mutable object such as a list, that list can still be changed. The tuple continues to hold the same list.

Worked example: the tuple that seems to change.

By contrast, tuple2[0] = 5 would fail, because that tries to replace an element of the tuple itself.

Why use a tuple at all? A tuple is faster to iterate than a list, and data that must not change, such as the days of a week or a record, is safe in a tuple because it cannot be altered by accident. The textbook's rule of thumb: a list is typically used for items of the same type, and a tuple for items of different types.

Tuple operations

Because a tuple cannot be edited, "extending" it builds a new tuple: tuple6 = tuple6 + (6,) creates a new tuple and rebinds the name. The single element needs its comma, (6,), since tuple6 + (6) would try to add an integer to a tuple and fail.

Worked example: slicing a tuple. Let tuple1 = (10, 20, 30, 40, 50, 60, 70, 80), indices 0 to 7.

Tuple methods and built in functions

A tuple has only two methods of its own, count() and index(), because the others (append, remove, sort) would change it.

Tuple assignment: unpacking

Tuple assignment lets you put a tuple of variables on the left of = and assign them values from a tuple on the right. The two sides must have the same number of items. If the right side is an expression, it is evaluated first, and then assigned.

Worked example: swapping without a temporary variable. Because the whole right side is computed before any name on the left changes, a, b = b, a swaps cleanly. The same idea gives a trap: what do a, b = 1, 2 followed by a, b = b, a + b give?

The result is 2 3. If it had been done one name at a time (a = b then b = a + b), the second line would use the new a and give 4, which is the common wrong answer.

Nested tuples. A tuple of tuples is perfect for records, such as several students stored as st = ((101, "Aman", 98), (102, "Geet", 95)). Then st[0] is the first student's record, and st[0][1] is the name 'Aman'. A loop such as for i in range(0, len(st)) can print st[i][0], st[i][1] and st[i][2] as the columns.

Returning several values. A function can return a tuple, and unpacking receives it, so area, circumference = circle(5) works when circle returns (area, circumference). For a radius of 5 with 3.14 for $\pi$, the area is 78.5.

List or tuple?

What is a dictionary?

A dictionary is a mapping: it connects a set of keys to a set of values. One key together with its value is called an item (a key value pair). A colon separates the key from its value, items are separated by commas, and the whole thing sits inside curly braces. Instead of a position, each key acts as the index.

The first two are empty dictionaries. In dict3, the names are the keys and the marks are the values. Two rules decide what is legal.

If you use the same key twice, the last value wins and only one item remains. So {'a': 1, 'b': 2, 'a': 3} has length 2 and equals {'a': 3, 'b': 2}. A list cannot be a key, because it is mutable: {[1]: 2} raises a TypeError.

Beyond the textbook. For the exam: keys must be of an immutable type. In reality: the precise rule is that a key must be hashable, which means Python must be able to compute a fixed number for it. A tuple is hashable only if everything inside it is. So (1, 2) works as a key, but (1, [2]) does not, even though it is a tuple. Dictionaries use this number to jump straight to the right item, which is why a lookup stays fast whatever the size.

Accessing, adding and changing items

Use the key in square brackets. If the key is absent, you get a KeyError. Assigning to a key that exists modifies the value, and assigning to a new key adds an item. Since the order of the items does not matter for lookup, dict3['Ram'] is always 89.

Beyond the textbook. For the exam: a dictionary is accessed by key, never by position, so the order of items does not affect lookup. In reality: since Python 3.7, a dictionary also remembers the order in which items were inserted, so printing it or looping over it gives them back in that order. The textbook's own sample outputs show this. It is still not indexed by position: dict3[0] looks for a key named 0.

Traversing a dictionary

The second style uses tuple unpacking: each item arrives as a (key, value) tuple and is unpacked into two names.

Dictionary methods and built in functions

get or square brackets? d['Shyam'] stops the program with a KeyError when the key is missing, while d.get('Shyam') quietly returns None. The update() method changes only the dictionary it is called on, not the one passed in. And del d and d.clear() differ in one way: after clear() the empty dictionary still exists, but after del d the name itself is gone.

Beyond the textbook. For the exam: keys(), values() and items() return collections of the keys, values and pairs. In reality: they return view objects that stay linked to the dictionary. If you store k = d.keys() and later add an item to d, then k shows the new key as well. Wrap a view in list(...) when you want a fixed snapshot.

Worked example: a series of dictionary operations. Start with ODD = {1: 'One', 3: 'Three', 5: 'Five', 7: 'Seven', 9: 'Nine'}.

Counting characters with a dictionary

A dictionary is the natural tool for counting, since each letter is a key and its count is the value. The logic: if the character is already a key, add 1; otherwise create it with the count 1.

Worked example: character frequency of 'banana'.

The common wrong step is to write dic[ch] += 1 for a letter that is not yet a key: that raises a KeyError, which is why the if ch in dic check comes first.

Worked example: number to words. A dictionary maps each digit to its word, and the function looks up each digit of the input in turn. The input is read as a string, so each character is converted with int(ch) to match the integer keys.

For the input '6512' the loop makes four passes: the character '6' becomes the key 6 and adds ' Six', then '5' adds ' Five', '1' adds ' One' and '2' adds ' Two'. The returned text is ' Six Five One Two'. Without int(ch), the lookup numberNames['6'] would raise a KeyError, because the keys are integers and '6' is a string.

Choosing the right data type

Exam traps

60-second revision

Where this chapter connects

• Previous: Lists is the mutable cousin of the tuple, with the same indexing and slicing rules.
• Next: Societal Impact moves from programming to the effects of technology on society.
• Also related: Functions showed functions returning several values, which is a tuple at work, and Strings uses partition(), which returns a tuple of three parts.