Working with Lists and Dictionaries

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

One variable, many values

A single variable holding a single number cannot store the marks of 40 students or the phone numbers in your contacts. Python gives you two containers for this job. A list is an ordered row of items you reach by position. A dictionary is a lookup table you reach by name. Most output prediction questions in this chapter are about what happens to the container after each statement, so the skill to build is tracing: write the container down, apply one statement, write it again.

Lists: ordered and mutable

A list is an ordered sequence of one or more elements, enclosed in square brackets and separated by commas. Unlike a string, which holds only characters, a list can hold elements of different data types: integers, floats, strings, tuples or even another list (a nested list).

Indexing: forward and backward

Each element has an index. The first element has index 0, the second 1, and so on. Negative indices count from the end, so -1 is the last element. An index that does not exist raises an IndexError.

The index can be any expression that gives an integer. With n = len(list1), the last element is list1[n-1] and the first element is list1[-n].

Worked example: indexing. Let list1 = [2, 4, 6, 8, 10, 12].

The common wrong step is to read list1[6] as the last element of a six element list. The last valid positive index is len(list1) - 1, which is 5.

Lists are mutable. You can change an element after the list is created, in the same list.

List operations

Concatenation does not change the original lists. It creates a new list, so to keep the result you must assign it, for example new_list = list1 + list2. The + operator needs a list on both sides. Joining a list and a string raises a TypeError.

Pause and predict: after a = [1, 2, 3] and b = [4], you write a + b on its own line. What are a and b afterwards?

Check your answer: unchanged. a is still [1, 2, 3] and b is still [4]. The joined list [1, 2, 3, 4] was created and then thrown away because it was not assigned to anything.

Slicing: the stop index is never included

Slicing takes out a part of a list as a new list. In list1[start:stop:step], the slice begins at start, stops before stop, and moves by step. A missing start means the beginning, a missing stop means the end, and a missing step means 1.

Why the stop is excluded. list1[2:6] has $6 - 2 = 4$ elements. With the stop excluded, the number of elements is simply stop minus start, and list1[:3] + list1[3:] rebuilds the whole list without overlap.

Worked example: slicing. Let list1 = ['Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow', 'Black']. Indices are 0 to 6.

An out of range slice never raises an error, but an out of range single index does. That is the usual trap.

Beyond the textbook. For the exam: a slice makes a new list, and a stop beyond the end is cut off. In reality: the same notation works on strings and tuples, and list1[::-1] is the standard way to reverse a copy of any sequence without changing the original. Why it matters: once you read [start:stop:step] fluently, a whole family of questions on strings, tuples and later chapters becomes the same question.

Traversing a list

To traverse a list means to visit every element. There are two ways with a for loop.

Both loops print Red, Green and Blue, one per line, so six lines in total. The first loop gives you the element. The second gives you the index, and you read the element with list1[i]. Use the second form when you need the position too. range(len(list1)) runs from 0 to the length minus one, which are exactly the valid indices.

List methods and built in functions

A method is a function that belongs to an object and is called with a dot, as in list1.append(50). The most testable fact about methods is what they return and whether they change the list.

append versus extend.

append adds one item, even if that item is itself a list, so the length grows by 1. extend adds each item of the other list, so the length grows by the length of the other list.

remove versus pop. remove(30) deletes the value 30 (its first occurrence only). pop(3) deletes the item at index 3 and gives it back. For [10, 20, 30, 40, 50, 30], remove(30) leaves [10, 20, 40, 50, 30].

sort versus sorted. sort() rearranges the list itself. sorted() leaves the original alone and makes a new list.

Why the return value matters. sort() returns None. If you write list1 = list1.sort(), list1 becomes None and you have lost your data. The same holds for append, extend, insert, remove and reverse. They change the list and return nothing useful.

Worked example: trace a sequence of methods. Start with list1 = [10, 20, 30, 40, 50].

The printed output is [70, 60, 40, 30, 25, 20]. The common wrong step is to print list1.reverse() expecting a reversed list. That prints None.

Worked example: predict the output. These are typical questions on slices, sort, sorted and del.

The second output is the original order because sorted(list1) builds a new list that was not stored. The del myList[::2] removes indices 0, 2, 4, 6 and 8, so the elements 2, 4, 6, 8 and 10 remain.

Beyond the textbook. For the exam: sort() works on a list of numbers or a list of strings. In reality: sorting a list that mixes numbers and strings, such as [3, 'a', 1], raises a TypeError, because Python cannot decide whether 3 is smaller than 'a'. Why it matters: "sorting needs comparable items" is an easy way to explain an error message if one appears in a question.

Pause and predict: a = [3, 1, 2] and then b = a.sort(). What are a and b?

Check your answer: a is [1, 2, 3] and b is None. The method sorted a itself and returned nothing.

List programs

Worked example: average of marks. The program reads n marks into a list and then adds them up. Suppose n = 5 and the marks are 45, 89, 79, 76 and 55.

Worked example: search a list. The program searches for a number and reports its position (counting from 1). With the list [23, 567, 12, 89, 324] and the searched number 12:

The variable position starts at -1 as a flag meaning "not found". The match happens at index 2, so position becomes 3 and the else branch prints it. The common wrong step is to print position + 1 again and report 4.

A menu driven list program. The chapter's longest program shows a menu and runs one operation based on the choice. The pattern is one if, many elif branches and a final else for an invalid choice. Each branch calls one method.

Starting from [22, 4, 16, 38, 13], choice 8 sorts in reverse and gives [38, 22, 16, 13, 4], and then choice 5 with position 2 pops 16 and gives [38, 22, 13, 4]. Programs like this check the position first (if i < len(myList)), because a position past the end would cause an IndexError.

Dictionaries: key value pairs

A dictionary is a mapping between a set of keys and a set of values. Each key value pair is an item. A colon separates a key from its value, items are separated by commas, and the whole thing is in curly braces.

Rules for dictionary keys. Keys must be unique and of an immutable type: a number, a string or a tuple. Values can repeat and can be of any type, including mutable ones.

Why you use keys, not positions. The key 'Ram' always maps to 89, wherever the item sits in the dictionary. The key acts as the index. Asking for a key that does not exist raises a KeyError.

Beyond the textbook. For the exam: a dictionary is a mapping that you read by key, not by position, and it is described as an unordered collection. In reality: in current Python versions a dictionary remembers the order in which items were added, so printing it shows them in insertion order. Lookup is still always by key. Why it matters: you never need position to read a value, so the exam answer and the real behaviour never conflict in a question that asks you to predict output.

Membership. The operator in checks the keys, not the values.

The second line is False because 92 is a value, not a key.

Dictionaries are mutable. Assigning to a new key adds an item. Assigning to an existing key overwrites its value.

Pause and predict: d = {'a': 1, 'b': 2}, then d['b'] = 5 and d['c'] = 7. What is len(d)?

Check your answer: 3. The key 'b' already existed, so its value was replaced and no item was added. The key 'c' is new, so it adds one item. The dictionary holds a, b and c.

Traversing a dictionary

Dictionary methods and built in functions

get versus square brackets. dict1['Sohan'] raises a KeyError for a missing key, but dict1.get('Sohan') returns None quietly. Use get when the key might be absent.

clear versus del. After dict1.clear() the dictionary still exists and is empty ({}). After del dict1 the name itself is gone.

Beyond the textbook. For the exam: keys(), values() and items() give the keys, values and key value pairs, and the output is printed as dict_keys([...]) and so on. In reality: these return special view objects, not ordinary lists. Wrap them in list() if you need a list, for example list(dict1.keys()). Why it matters: it explains the dict_keys( wrapper in the output and why you cannot index the result directly.

Worked example: the ODD dictionary. Build ODD = {1:'One', 3:'Three', 5:'Five', 7:'Seven', 9:'Nine'} and predict.

Worked example: state capitals. With stateCapital = {"Assam":"Guwahati", "Bihar":"Patna", "Maharashtra":"Mumbai", "Rajasthan":"Jaipur"}:

Dictionary programs

Worked example: count characters. The program counts how many times each character appears in a string. For the input HelloWorld:

Why it works. The dictionary starts empty. For each character, if it is already a key, add 1 to its count. If not, create the key with count 1. In HelloWorld, the letter l appears at three places (in "Hello" twice and in "World" once), so its count goes 1, 2, 3. The letter o appears twice, and every other letter once. The capital H and W are separate keys from any lower case letters because Python is case sensitive.

Worked example: number to words. A dictionary maps each digit to its word, and the program converts each character of the input.

The step key = int(ch) is needed because input() gives a string of characters, but the dictionary keys are integers. Without it, numberNames['6'] would raise a KeyError. The extra space before "Six" in the output comes from the way result is built.

Worked example: employees and salaries. The program stores name : salary pairs by assigning employee[name] = salary inside a loop. It reads n names and salaries, and then prints each item using for k in employee: print(k, employee[k]). With names Tarun, Amina and Joseph and salaries 12000, 34000 and 24000, the dictionary becomes three items, one per employee, and the loop prints them in the order they were stored.

Exam traps

60-second revision

Where this chapter connects

• Previous: Brief Overview of Python introduces the list, tuple and dictionary types, loops and range() that this chapter uses throughout.
• Next: Understanding Data uses lists of numbers for mean, median, mode and range.
• Related: Lists and Tuples and Dictionaries in the Computer Science course cover the same ideas in more depth.