Lists

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 9.

One list, two names, two surprises

Imagine you make a shopping list on paper and your friend says "give me a copy". If you hand over the same sheet and then add milk, your friend's list has milk too. If you photocopy it first, adding milk changes only yours. Python lists behave exactly like this. Writing list2 = list1 hands over the same sheet, not a photocopy. Most of the hard CUET questions on this chapter come from this one fact, together with a second one: some list methods change the list and return nothing, which makes print(list1.sort()) display None.

What is a list?

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 mix integers, floats, strings, tuples and even other lists. Most importantly, a list is mutable: its contents can be changed after it is created.

The first is a list of even numbers, the second of vowels, the third of mixed types, and the fourth is a nested list: a list whose elements are themselves lists.

Indexing and mutability

Elements are accessed exactly like characters of a string. Indices start at 0 and run to $n - 1$ going forwards, or from $-1$ down to $-n$ going backwards. list1[15] raises IndexError: list index out of range. The index can be an expression that evaluates to an integer, such as list1[1 + 4].

Because lists are mutable, you can assign to a position.

Here is how a list and a string differ in the one place that matters most.

List operations

Concatenation and repetition build a new list and leave the originals unchanged. To keep the result you must assign it. Concatenation needs a list on both sides: [1, 2, 3] + "abc" raises a TypeError. Membership tests for a whole element, so 'Gre' in ['Red', 'Green'] is False.

Slicing follows the rules you saw for strings: start included, stop excluded, an out of range stop is trimmed, and a start beyond the stop gives an empty list.

Worked example: slicing a list. Let list1 = ['Red','Green','Blue','Cyan','Magenta','Yellow','Black'] (indices 0 to 6).

Traversing a list

You can visit every element in three ways.

To change elements while looping, use the index form. Assigning to the loop variable in for item in list1 only changes item, not the list.

List methods and built in functions

A method is called with a dot, such as list1.append(50). The big question for each method is: does it change the list in place, or return a new value?

Adding elements

Removing elements

Searching and counting

Ordering

Measuring and converting

Worked example: append or extend? Start with list1 = [10, 20, 30] each time.

Append adds its argument as a single element, so a list argument becomes a nested list. Extend unpacks its argument and adds the items one by one.

Worked example: tracing a sequence of changes. Start with L = [10, 20, 30, 40].

A common mistake is to confuse remove and pop: remove(30) looks for the value 30, but pop(3) removes the item at index 3.

Pause and predict: L = [3, 1, 2]. What do print(L.sort()) and then print(L) show? What if the first line were print(sorted(L))?

Check your answer: L.sort() sorts the list in place and returns None, so the first print shows None and the second shows [1, 2, 3]. With sorted(L) the first print shows the new sorted list [1, 2, 3], while L itself would still be [3, 1, 2].

Beyond the textbook. For the exam: sort() changes the list and sorted() returns a new one. In reality: the reason sort() returns None is a deliberate design choice, so that nobody mistakes an in place change for a copy. The pattern is general: in Python, methods that modify a mutable object in place return None. Whenever you see x = x.sort(), suspect a bug, because x becomes None.

Nested lists

When a list is an element of another list, you need two indices to reach inside it. list1[i][j] first picks the element i (the inner list) and then element j of that.

Worked example: reading a nested list. Let stRecord = ['Raman', 'A-36', [56, 98, 99, 72, 69], 78.8].

Copying lists: aliasing

The statement list2 = list1 does not create a new list. It makes list2 a second name (an alias) for the same list object. A change through either name is visible through both.

Worked example: the alias trap.

To get a real, independent copy there are three methods.

After a real copy, list1.append(10) changes only list1.

Beyond the textbook. For the exam: slicing, list() and copy.copy() each make an independent copy. In reality: all three make a shallow copy. The outer list is new, but any inner lists are still shared. With a = [1, [2, 3]] and b = copy.copy(a), running b[1].append(9) changes the inner list seen through both a and b. When you need every level duplicated, use copy.deepcopy(a).

Beyond the textbook. For the exam: + creates a new list. In reality: the shorthand += behaves differently on lists: it extends the existing list in place. After a = [1, 2, 3] and b = a, the statement a = a + [4] leaves b as [1, 2, 3], because a now refers to a new list. But a += [4] changes the shared list, and b becomes [1, 2, 3, 4] too. This is why the textbook asks you to distinguish list1 * 2, list1 *= 2 and list1 = list1 * 2: the first creates a list that is thrown away, the second changes list1 itself, and the third rebinds list1 to a new list.

A list as an argument to a function

When you pass a list to a function, you pass a reference to the same list object. This leads to two cases, and the difference is a very popular question.

Worked example: in place change.

list2 and list1 have the same id(), so each list2[i] += 5 edits the caller's list.

Worked example: reassignment.

The assignment makes list2 refer to a brand new list, so its id() changes and the connection to list1 is cut. The caller's list is untouched.

Pause and predict: a function contains L = L + [1] and is called with x = [5]. What is x afterwards? What if the line were L.append(1)?

Check your answer: with L = L + [1], a new list is created and stored in the local name, so x is still [5]. With L.append(1), the shared list is changed in place, so x becomes [5, 1].

Two classic list programs

Worked example: linear search. The function checks the elements one by one and returns the index where the number is found, or None if it never is.

The function returns index 2, which a user would report as position 3 (the program prints result + 1). return None is reached only if the loop finishes without a match.

Worked example: average marks. To average the marks of 5 students, the program starts with an empty list, uses append() inside a loop to collect each mark, then sums them in a function and divides by n. For the marks 45, 89, 79, 76, 55 the total is 344, and $344 / 5 = 68.8$.

Exam traps

60-second revision

Where this chapter connects

• Previous: Strings introduced indexing, slicing, concatenation and membership, all of which work the same way on lists.
• Next: Tuples and Dictionaries compares the mutable list with the immutable tuple, and adds the key based dictionary.
• Also related: Functions explains parameters and return values, and Working with Lists and Dictionaries in the Informatics Practices course extends the same ideas.