Lists

A list is Python's way of holding many values under one name, in order. Without lists you would write m1 = 88, m2 = 92, m3 = 76 — and then be stuck the moment a fourth student joins the class. With a list, the count stops mattering.

You write a list inside square brackets, items separated by commas. Two things surprise students who have seen arrays in C++ or Java: a Python list does not require all items to be of the same type, and it has no fixed size.

Worked example 1 — creating lists

marks = [88, 92, 76, 95, 61]
names = ['Aarav', 'Diya', 'Kabir']
mixed = [101, 'Aarav', 88.5, True]
empty = []

print(marks)
print(names)
print(mixed)
print(empty, len(empty))
print(len(marks), len(mixed))
print(type(marks))

print(list('IRCTC'))
print(list(range(1, 6)))
print(list((10, 20, 30)))

Output

[88, 92, 76, 95, 61]
['Aarav', 'Diya', 'Kabir']
[101, 'Aarav', 88.5, True]
[] 0
5 4

['I', 'R', 'C', 'T', 'C']
[1, 2, 3, 4, 5]
[10, 20, 30]

Three things to take from that output. [] is a perfectly valid empty list of length 0. len(mixed) is 4 — len() counts items, never the characters inside them. And list() is a built-in type conversion: hand it a string and you get a list of characters, hand it a range and you get the numbers, hand it a tuple and you get the same items as a list. list() with nothing inside gives [].

Indexing

Every item sits at a numbered position called its index. Counting starts at 0, not 1. The reason is worth knowing: an index is really a distance from the start. The first item is 0 steps away from the beginning, the second is 1 step away. Python also allows negative indexes, counted from the right end.

Worked example 2 — indexing forwards and backwards

students = ['Aarav', 'Diya', 'Kabir', 'Meera', 'Rohan']

print(students[0])
print(students[3])
print(students[-1])
print(students[-5])
print(len(students))
print(students[len(students) - 1])

Output

Aarav
Meera
Rohan
Aarav
5
Rohan

Now the error you must be able to name in the exam. A 5-item list has valid indexes 0 to 4, so asking for index 5 stops the program:

students = ['Aarav', 'Diya', 'Kabir', 'Meera', 'Rohan']
print(students[5])

Error output

IndexError: list index out of range

That is why students[len(students)] is always wrong and students[len(students) - 1] is always the last item. Negative indexes exist precisely so you never have to write that subtraction: students[-1] is shorter and cannot be got wrong.

Worked example 3 — lists are mutable, strings are not

marks = [88, 92, 76]
print('before:', marks)
marks[1] = 97
print('after :', marks)

marks[-1] = 80
print('after :', marks)

Output

before: [88, 92, 76]
after : [88, 97, 76]
after : [88, 97, 80]

marks[1] = 97 changes the list itself — no new list is made. Try the same instruction on a string and Python refuses:

name = 'Aarav'
name[0] = 'B'

Error output

TypeError: 'str' object does not support item assignment

A string refuses because strings are immutable. This one difference explains most of the trick questions later in the chapter, so fix it in your head now: a list can be edited in place; a string cannot.

Once you have a list, four operators do most of the everyday work: +, *, in and slicing. The important habit to build is asking, for each one, does this change my list or hand me a new one? For all four the answer is: a new list, original untouched.

Worked example 1 — concatenation, repetition, membership

a = [1, 2, 3]
b = [4, 5]

print(a + b)
print(a)
print(b * 3)
print([0] * 5)
print([1, 2] * 0)

print(3 in a)
print(6 in a)
print(6 not in a)
print('Diya' in ['Aarav', 'Diya', 'Kabir'])

nested = [[1, 2], [3, 4]]
print([1, 2] in nested)
print(1 in nested)

Output

[1, 2, 3, 4, 5]
[1, 2, 3]
[4, 5, 4, 5, 4, 5]
[0, 0, 0, 0, 0]
[]
True
False
True
True
True
False

Read line 2 carefully: after a + b, a is still [1, 2, 3]. Concatenation builds a third list and throws it away unless you store it. [0] * 5 is the standard way to set up a list of five zeros before filling it in, and repeating a list zero (or a negative number of) times gives the empty list.

The last two in results are the exam point. [1, 2] in nested is True but 1 in nested is False, because in compares against the top-level items only — and the top-level items of nested are two lists, not four numbers.

Concatenation also insists that both sides are lists. Joining a list to a string is not allowed:

a = [1, 2, 3]
print(a + 'hi')

Error output

TypeError: can only concatenate list (not "str") to list

Worked example 2 — slicing

t = [10, 20, 30, 40, 50, 60, 70]

print(t[1:4])
print(t[:3])
print(t[4:])
print(t[:])
print(t[-3:])
print(t[:-2])
print(t[::2])
print(t[1::3])
print(t[::-1])
print(t[5:2])
print(t[2:100])
print(t)

Output

[20, 30, 40]
[10, 20, 30]
[50, 60, 70]
[10, 20, 30, 40, 50, 60, 70]
[50, 60, 70]
[10, 20, 30, 40, 50]
[10, 30, 50, 70]
[20, 50]
[70, 60, 50, 40, 30, 20, 10]
[]
[30, 40, 50, 60, 70]
[10, 20, 30, 40, 50, 60, 70]

Remember the contrast: t[100] raises IndexError, but t[2:100] quietly gives you whatever exists. Slicing forgives out-of-range numbers, plain indexing does not.

Worked example 3 — slice assignment and del (these DO change the list)

q = [10, 20, 30, 40, 50]

q[1:3] = [99]
print(q)

q[1:2] = [21, 22, 23]
print(q)

del q[0]
print(q)

del q[1:3]
print(q)

Output

[10, 99, 40, 50]
[10, 21, 22, 23, 40, 50]
[21, 22, 23, 40, 50]
[21, 40, 50]

Two items were replaced by one, then one by three. The list simply resizes — an array in C++ could never do that.

Worked example 4 — traversing a list

There are two loop shapes you must be able to write. Use for item in L when you only need the values. Use for i in range(len(L)) when you need the position — for printing the index, or for changing items, since the loop variable in the first shape is only a copy of the value.

fees = [12000, 15500, 9800, 20000]

for f in fees:
    print(f, end=' ')
print()

for i in range(len(fees)):
    print('Index', i, '-> Rs', fees[i])

i = 0
while i < len(fees):
    print(fees[i] * 2, end=' ')
    i += 1
print()

total = 0
for f in fees:
    total += f
print('Total collected: Rs', total)

for i in range(len(fees)):
    fees[i] = fees[i] + 500
print(fees)

Output

12000 15500 9800 20000 
Index 0 -> Rs 12000
Index 1 -> Rs 15500
Index 2 -> Rs 9800
Index 3 -> Rs 20000
24000 31000 19600 40000 
Total collected: Rs 57300
[12500, 16000, 10300, 20500]

The last loop actually edits the list, because fees[i] = ... writes back into the list. Had you written for f in fees: f = f + 500, nothing would change — f is just a name holding a copy of the number.

The trap: never delete from a list you are looping over

L = [2, 4, 6, 8]
for x in L:
    if x % 2 == 0:
        L.remove(x)
print('after the loop:', L)

M = [2, 4, 6, 8]
keep = []
for x in M:
    if x % 2 != 0:
        keep.append(x)
print('safe version   :', keep)

Output

after the loop: [4, 8]
safe version   : []

Every number was even, so the first loop should have emptied the list — it left two behind. The loop tracks positions internally; each removal shifts everything left and the loop skips the item that slid into the vacated slot. The fix is to build a new list of what you want to keep — here nothing was odd, so keep is correctly empty.

Methods are written with a dot: L.append(4). Almost every list method changes the list in place and returns None. Only count(), index() and pop() report a useful value back, and only sorted() and L.copy() hand you a new list. Keep this table in front of you while revising.

Worked example 1 — append() vs extend(), exam trap number one

a = [1, 2, 3]
a.append(4)
print('append(4)     :', a, 'len =', len(a))

a.append([5, 6])
print('append([5,6]) :', a, 'len =', len(a))

b = [1, 2, 3]
b.extend([5, 6])
print('extend([5,6]) :', b, 'len =', len(b))

c = [1, 2]
c.extend('hi')
print("extend('hi')  :", c)

d = [1, 2]
d.append('hi')
print("append('hi')  :", d)

print('append returns:', [1, 2].append(3))
print('extend returns:', [1, 2].extend([3]))

Output

append(4)     : [1, 2, 3, 4] len = 4
append([5,6]) : [1, 2, 3, 4, [5, 6]] len = 5
extend([5,6]) : [1, 2, 3, 5, 6] len = 5
extend('hi')  : [1, 2, 'h', 'i']
append('hi')  : [1, 2, 'hi']
append returns: None
extend returns: None

Say it as a rule: append() adds exactly one item, whatever it is. extend() unpacks and adds each item separately. So append([5, 6]) makes the length go from 4 to 5 and buries a list inside a list, while extend([5, 6]) takes it from 3 to 5. Because extend() unpacks, it needs something it can walk through — a string works (characters go in one by one), a bare integer does not:

e = [1, 2]
e.extend(5)

Error output

TypeError: 'int' object is not iterable

Worked example 2 — insert, pop, remove, clear

q = ['Aarav', 'Diya', 'Kabir']
q.insert(1, 'Meera')
print(q)
q.insert(0, 'Rohan')
print(q)
q.insert(100, 'Zoya')
print(q)

x = q.pop()
print('popped', x, '->', q)
y = q.pop(0)
print('popped', y, '->', q)

n = [10, 20, 30, 20, 40]
n.remove(20)
print('after remove(20):', n)
print('remove returns  :', n.remove(20))
print('list now        :', n)

n.clear()
print('after clear():', n, len(n))

Output

['Aarav', 'Meera', 'Diya', 'Kabir']
['Rohan', 'Aarav', 'Meera', 'Diya', 'Kabir']
['Rohan', 'Aarav', 'Meera', 'Diya', 'Kabir', 'Zoya']
popped Zoya -> ['Rohan', 'Aarav', 'Meera', 'Diya', 'Kabir']
popped Rohan -> ['Aarav', 'Meera', 'Diya', 'Kabir']
after remove(20): [10, 30, 20, 40]
remove returns  : None
list now        : [10, 30, 40]
after clear(): [] 0

Four things to lock in. insert(i, x) puts x at index i and shifts everything from there to the right; an index past the end simply appends instead of erroring. pop() with no argument removes and returns the last item — this is the only removal method whose return value is worth catching. remove(x) deletes the first match by value only, which is why the first remove(20) left the second 20 alive. And clear() empties the list without destroying it.

Two removal errors are worth memorising. Removing a value that is not present:

n = [10, 30, 40]
n.remove(99)

Error output

ValueError: list.remove(x): x not in list

and popping from a list that is already empty:

n = []
n.pop()

Error output

IndexError: pop from empty list

Worked example 3 — count(), index(), and the aggregate functions

votes = ['UPI', 'Cash', 'UPI', 'Card', 'UPI', 'Cash']

print(votes.count('UPI'))
print(votes.count('NetBanking'))
print(votes.index('Cash'))
print(votes.index('Cash', 2))

nums = [5, 3, 5, 7, 5]
print(nums.count(5), nums.index(5), nums.index(5, 1))
print(len(votes), max(nums), min(nums), sum(nums))

Output

3
0
1
5
3 0 2
6 7 3 25

Note the asymmetry, which is a favourite one-mark question: a missing value makes count() return 0, but the same missing value makes index() stop the program:

votes = ['UPI', 'Cash', 'UPI', 'Card', 'UPI', 'Cash']
print(votes.index('NetBanking'))

Error output

ValueError: 'NetBanking' is not in list

Give index() a second argument and it starts hunting from that position, which is how you find the second occurrence.

Worked example 4 — sort() vs sorted(), exam trap number two

m = [88, 92, 76, 95, 61]

m.reverse()
print('after reverse():', m)
print('reverse returns:', [1, 2, 3].reverse())

m.sort()
print('after sort()   :', m)
print('sort returns   :', [3, 1, 2].sort())

orig = [88, 92, 76, 95, 61]
new = sorted(orig)
print('sorted() gives :', new)
print('original intact:', orig)

wrong = orig.sort()
print('wrong =', wrong)

Output

after reverse(): [61, 95, 76, 92, 88]
reverse returns: None
after sort()   : [61, 76, 88, 92, 95]
sort returns   : None
sorted() gives : [61, 76, 88, 92, 95]
original intact: [88, 92, 76, 95, 61]
wrong = None

This is the mistake that costs marks every single year. L.sort() rearranges L and returns None, so wrong = orig.sort() stores None. Everything looks fine until the next line tries to use it:

orig = [88, 92, 76, 95, 61]
wrong = orig.sort()
print(wrong[0])

Error output

TypeError: 'NoneType' object is not subscriptable

Write L.sort() on a line by itself, or use sorted(L) when you want a sorted copy and need the original order preserved. Note also that reverse() is not a sort: it flips the list into its opposite order exactly as it stands, which is why [88, 92, 76, 95, 61] became [61, 95, 76, 92, 88] and not a descending list.

Worked example 5 — sorting options and what cannot be sorted

m = [88, 92, 76, 95, 61]
m.sort(reverse=True)
print(m)
print(sorted(m))
print(sorted(m, reverse=True))

names = ['diya', 'Aarav', 'kabir', 'Bhavna']
print(sorted(names))

print(sorted('IRCTC'))
print(sorted((30, 10, 20)))

Output

[95, 92, 88, 76, 61]
[61, 76, 88, 92, 95]
[95, 92, 88, 76, 61]
['Aarav', 'Bhavna', 'diya', 'kabir']
['C', 'C', 'I', 'R', 'T']
[10, 20, 30]

Capital letters sort before small letters because sorting compares ASCII codes, and every capital (65-90) is smaller than every small letter (97-122). sorted() accepts any iterable and always returns a list, which is why sorted('IRCTC') gives a list of characters and sorted((30, 10, 20)) turns a tuple into a list. Mixing numbers and strings fails, because Python has no rule for whether 3 comes before 'one':

print(sorted([3, 'one', 2]))

Error output

TypeError: '<' not supported between instances of 'str' and 'int'

Here is the idea that genuinely surprises people. A list variable does not hold the list. It holds a label pointing to the list, which lives somewhere in memory. The built-in id() shows you the address of that object. When you write b = a, Python copies the label, not the list — so now two names point at the same object. That is called aliasing.

Worked example 1 — b = a does not make a copy

a = [10, 20, 30]
b = a

print('id(a) == id(b) ?', id(a) == id(b))
print('same object?', a is b)

a.append(40)
print('a =', a)
print('b =', b)

b[0] = 99
print('a =', a)
print('b =', b)

a = a + [50]
print('after a = a + [50]')
print('a =', a)
print('b =', b)
print('same object?', a is b)

Output

id(a) == id(b) ? True
same object? True
a = [10, 20, 30, 40]
b = [10, 20, 30, 40]
a = [99, 20, 30, 40]
b = [99, 20, 30, 40]
after a = a + [50]
a = [99, 20, 30, 40, 50]
b = [99, 20, 30, 40]
same object? False

Printing id(a) on its own would show a long number such as 2933657855680, and that number is different on every machine and on every run — which is why the program above compares the two ids instead of printing them. What matters is only that they are equal. Appending to a changed what b shows, and assigning through b changed what a shows, because there is only one list.

The last part is the finer point. a = a + [50] builds a brand-new list and points a at it — that is rebinding, not mutating. b is left holding the old object, the ids stop matching, and the two names go their separate ways from then on. Compare: a.append(50) would have shown up in b. Same-looking operation, completely different effect.

Worked example 2 — three ways to make a real copy

a = [10, 20, 30]
b = a[:]
c = list(a)
d = a.copy()

print(a is b, a is c, a is d)
print(a == b, a == c, a == d)

a.append(40)
print('a =', a)
print('b =', b)
print('c =', c)
print('d =', d)

x = [[1, 2], [3, 4]]
y = x[:]
print('x is y ?', x is y)
y[0][0] = 99
print('x =', x)
print('y =', y)

Output

False False False
True True True
a = [10, 20, 30, 40]
b = [10, 20, 30]
c = [10, 20, 30]
d = [10, 20, 30]
x is y ? False
x = [[99, 2], [3, 4]]
y = [[99, 2], [3, 4]]

The first two lines settle the difference between is and ==. a == b asks "same values?" and is True. a is b asks "same object in memory?" and is False. Appending to a now leaves all three copies alone, which is exactly what you wanted.

The last block is the honest footnote: x[:] copies the outer list but the two inner lists are still shared, so editing y[0][0] is visible in x. This is called a shallow copy. You will not be asked to fix it in Class 11, but you should recognise it if you see it.

Worked example 3 — the nested repetition trap

grid = [[0] * 3] * 3
print(grid)
grid[0][0] = 1
print(grid)
print(grid[0] is grid[1])

grid2 = [[0] * 3, [0] * 3, [0] * 3]
grid2[0][0] = 1
print(grid2)
print(grid2[0] is grid2[1])

Output

[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]
True
[[1, 0, 0], [0, 0, 0], [0, 0, 0]]
False

[[0] * 3] * 3 looks like a clean 3x3 grid and prints like one. But * repeats the reference, so all three rows are the same single row object — grid[0] is grid[1] is True — and setting one cell sets it in all three rows. Writing the three rows out separately, or building them one at a time with append(), gives three independent rows.

Worked example 4 — why a "backup" made with = is not a backup

This is where aliasing actually bites in a program. You keep a copy of a list before sorting it, then discover the copy got sorted too.

original = [30, 10, 20]
backup = original
original.sort()
print('original :', original)
print('backup   :', backup)
print('is backup a real copy?', original is not backup)

original2 = [30, 10, 20]
backup2 = original2[:]
original2.sort()
print('original2:', original2)
print('backup2  :', backup2)
print('is backup2 a real copy?', original2 is not backup2)

safe = sorted(original2, reverse=True)
print('sorted copy:', safe)
print('untouched  :', original2)

Output

original : [10, 20, 30]
backup   : [10, 20, 30]
is backup a real copy? False
original2: [10, 20, 30]
backup2  : [30, 10, 20]
is backup2 a real copy? True
sorted copy: [30, 20, 10]
untouched  : [10, 20, 30]

The first backup was never a backup — it was a second label on the very list that sort() rearranged. backup2 = original2[:] makes a genuine copy, so the original order survives. And the third block shows the neatest solution of all: sorted() gives you the sorted version and leaves the list alone, so you never need a backup in the first place.

A list item can itself be a list. That gives you a table: the outer list holds rows, each row holds the cells. This is exactly how a marksheet is stored before it is printed.

Worked example 1 — a nested list as a marksheet

report = [['Aarav', 88, 92, 76],
          ['Diya', 95, 89, 91],
          ['Kabir', 61, 70, 68]]

print(len(report))
print(len(report[0]))
print(report[0])
print(report[0][0])
print(report[1][2])
print(report[-1][-1])

for row in report:
    name = row[0]
    marks = row[1:]
    print(name, marks, 'total =', sum(marks),
          'avg =', round(sum(marks) / len(marks), 2))

report[2][1] = 71
print(report[2])

report.append(['Meera', 80, 85, 90])
print(len(report))
print(report[3])

Output

3
4
['Aarav', 88, 92, 76]
Aarav
89
68
Aarav [88, 92, 76] total = 256 avg = 85.33
Diya [95, 89, 91] total = 275 avg = 91.67
Kabir [61, 70, 68] total = 199 avg = 66.33
['Kabir', 71, 70, 68]
4
['Meera', 80, 85, 90]

Read report[1][2] left to right: report[1] picks the row ['Diya', 95, 89, 91], then [2] picks item 2 of that row, which is 89. len(report) counts rows and len(report[0]) counts the cells in a row. Slicing works inside a row too — row[1:] drops the name and leaves only the marks, ready for sum().

The aggregate built-in functions

nums = [88, 92, 76, 95, 61]
print(max(nums), min(nums), sum(nums), len(nums))

names = ['Aarav', 'Diya', 'Kabir', 'Bhavna']
print(max(names), min(names))

print(sum([]), len([]))

Output

95 61 412 5
Kabir Aarav
0 0

max() and min() work on strings too, using dictionary order — 'Kabir' is the largest name here. But sum() insists on numbers:

names = ['Aarav', 'Diya', 'Kabir', 'Bhavna']
print(sum(names))

Error output

TypeError: unsupported operand type(s) for +: 'int' and 'str'

The empty list is the edge case to remember: sum([]) is a peaceful 0, but max([]) and min([]) have nothing to return and raise ValueError:

print(max([]))

Error output

ValueError: max() iterable argument is empty

(The exact wording of that message changed between Python versions — older releases say max() arg is an empty sequence — but it is a ValueError either way.)

Program 1 — maximum, minimum and mean of a list of numbers

The exam usually wants the loop version, so learn both and cross-check one against the other.

marks = [88, 92, 76, 95, 61, 84]

print('--- using built-in functions ---')
print('Maximum:', max(marks))
print('Minimum:', min(marks))
print('Sum    :', sum(marks))
print('Mean   :', sum(marks) / len(marks))
print('Mean   :', round(sum(marks) / len(marks), 2))

print('--- using a loop (exam version) ---')
hi = marks[0]
lo = marks[0]
total = 0
for m in marks:
    if m > hi:
        hi = m
    if m < lo:
        lo = m
    total += m
print('Maximum:', hi)
print('Minimum:', lo)
print('Mean   :', round(total / len(marks), 2))

Output

--- using built-in functions ---
Maximum: 95
Minimum: 61
Sum    : 496
Mean   : 82.66666666666667
Mean   : 82.67
--- using a loop (exam version) ---
Maximum: 95
Minimum: 61
Mean   : 82.67

Start hi and lo at marks[0], never at 0. If you start hi at 0 the program breaks for all-negative data, and if you start lo at 0 it will report 0 as the minimum of a list that has no zero in it. The mean uses /, so it is always a float — round(x, 2) makes it printable.

The same thing with the statistics module

import statistics

marks = [88, 92, 76, 95, 61]
print('mean  :', statistics.mean(marks))
print('median:', statistics.median(marks))
print('mean of a copy still works:', statistics.mean(sorted(marks)))

Output

mean  : 82.4
median: 88
mean of a copy still works: 82.4

Program 2 — linear search on a list of numbers

Linear search means: walk from the start, compare each item with the key, stop the moment it matches. It is the only search you can use when the list is not sorted.

rolls = [1102, 1107, 1115, 1121, 1130]

key = 1115
pos = -1
for i in range(len(rolls)):
    if rolls[i] == key:
        pos = i
        break
if pos == -1:
    print(key, 'not found')
else:
    print(key, 'found at index', pos, '- that is position', pos + 1)

key = 1200
pos = -1
for i in range(len(rolls)):
    if rolls[i] == key:
        pos = i
        break
if pos == -1:
    print(key, 'not found')
else:
    print(key, 'found at index', pos)

print(1115 in rolls)
print(rolls.index(1115))

Output

1115 found at index 2 - that is position 3
1200 not found
True
2

The pattern is fixed and worth memorising: set pos = -1 before the loop, overwrite it on a match, break out, then test pos == -1 afterwards. -1 is used as the "not found" marker because it can never be a real result of range(len(L)). Python's own in and index() do the same job, but an exam question that says "using linear search" wants the loop written out.

Program 3 — counting the frequency of elements

votes = ['UPI', 'Cash', 'UPI', 'Card', 'UPI', 'Cash', 'Card', 'UPI']

done = []
for v in votes:
    if v not in done:
        print(v, '->', votes.count(v))
        done.append(v)

nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
seen = []
freq = []
for n in nums:
    if n not in seen:
        seen.append(n)
        freq.append(nums.count(n))
print(seen)
print(freq)

maxpos = 0
for i in range(len(freq)):
    if freq[i] > freq[maxpos]:
        maxpos = i
print('Most frequent value:', seen[maxpos], 'occurring', freq[maxpos], 'times')

Output

UPI -> 4
Cash -> 2
Card -> 2
[3, 1, 4, 5, 9, 2, 6]
[2, 2, 1, 3, 1, 1, 1]
Most frequent value: 5 occurring 3 times

The done list is what stops UPI from being reported four times. count() gives the number, and the not in check gives each distinct value exactly one turn. The second half stores the distinct values and their counts in two parallel lists, so seen[i] and freq[i] always describe the same value — then finding the most frequent element is the same maximum loop as before, run on freq but remembering the position rather than the value.