~/Lists

17.1 Creating a List

The simplest way is to write a comma-separated list of values inside square brackets.

empty    = []                            # empty list — length 0
marks    = [85, 72, 91, 68, 77]          # 5 integers
names    = ["Aarav", "Kavya", "Ishan"]    # 3 strings
mixed    = [1, "two", 3.0, True, [4, 5]]  # any types, even a nested list
single   = [42]                          # one-element list

print(type(marks))          # <class 'list'>

The list() constructor converts any iterable to a list:

print(list("Python"))            # ['P', 'y', 't', 'h', 'o', 'n']
print(list(range(1, 6)))         # [1, 2, 3, 4, 5]
print(list())                    # [] — empty list

17.2 Indexing — Accessing an Element

Like strings, lists support both positive (from the left, 0-based) and negative (from the right, −1 is last) indices.

marks = [85, 72, 91, 68, 77]

print(marks[0])        # 85   — first
print(marks[-1])       # 77   — last
print(marks[2])        # 91
# print(marks[10])     ❌ IndexError: list index out of range

17.3 List Operations

Every sequence operation you already know from strings works on lists.

17.3.1 Concatenation +

a = [1, 2, 3]
b = [4, 5]
print(a + b)              # [1, 2, 3, 4, 5]

17.3.2 Repetition *

print([0] * 5)            # [0, 0, 0, 0, 0] — great for "fill-with-zeros"
print(["ab", "cd"] * 2)     # ['ab', 'cd', 'ab', 'cd']

17.3.3 Membership in / not in

marks = [85, 72, 91, 68]
print(91 in marks)       # True
print(100 not in marks)  # True

17.3.4 Slicing [start:stop:step]

Slicing returns a new list. The same rules as strings and range(): stop is excluded; defaults are start 0, stop len(), step 1.

nums = [10, 20, 30, 40, 50, 60]

print(nums[1:4])          # [20, 30, 40]
print(nums[:3])           # [10, 20, 30]
print(nums[3:])           # [40, 50, 60]
print(nums[::2])          # [10, 30, 50] — every 2nd
print(nums[::-1])         # [60, 50, 40, 30, 20, 10] — reverse
print(nums[-2:])          # [50, 60] — last two

17.3.5 Length — len()

print(len([10, 20, 30]))   # 3
print(len([]))              # 0

17.4 Lists Are Mutable

Unlike strings, lists let you modify an item by assignment, delete items, and change the list's length in place.

marks = [85, 72, 91, 68]

marks[0] = 90                   # replace the first mark
print(marks)                   # [90, 72, 91, 68]

marks[1:3] = [75, 80, 85]         # slice-replace — length changes
print(marks)                   # [90, 75, 80, 85, 68]

del marks[0]                   # remove element at index 0
print(marks)                   # [75, 80, 85, 68]

a = [1, 2, 3]
b = a
b.append(99)
print(a)                 # [1, 2, 3, 99]  — surprise!

c = a.copy()             # or a[:]
c.append(42)
print(a)                 # unchanged

17.5 Traversing a List

marks = [85, 72, 91, 68]

# (1) direct — best when only values are needed
for m in marks:
    print(m, end=" ")          # 85 72 91 68

# (2) by index — best when you also need to write back
for i in range(len(marks)):
    marks[i] += 5                # grace marks
print(marks)                  # [90, 77, 96, 73]

# (3) index + value together
for i, m in enumerate(marks):
    print(i, "→", m)

# (4) while-loop form
i = 0
while i < len(marks):
    print(marks[i])
    i += 1

17.6 Built-in FUNCTIONS that work on Lists

These are ordinary functions called as fn(list) — not methods.

marks = [85, 72, 91, 68, 77]
print(len(marks))           # 5
print(max(marks))           # 91
print(min(marks))           # 68
print(sum(marks))           # 393
print(sum(marks) / len(marks))  # 78.6  — mean
print(sorted(marks))        # [68, 72, 77, 85, 91]  — NEW list, marks unchanged

17.7 Built-in METHODS on Lists

17.7.1 Adding items — append, extend, insert

a = [1, 2]
a.append([3, 4])
print(a)                # [1, 2, [3, 4]]   — one element, itself a list

b = [1, 2]
b.extend([3, 4])
print(b)                # [1, 2, 3, 4]     — items "unpacked" and added individually

17.7.2 Removing items — remove, pop, clear

17.7.3 Querying items — count and index

17.7.4 Ordering — sort, reverse, sorted

L = [3, 1, 4]
L = L.sort()         # ❌ L is now None — .sort() returns None
print(L)             # None

17.7.5 Other handy methods — copy

a = [1, 2, 3]
b = a.copy()          # independent copy
b.append(99)
print(a)             # [1, 2, 3]  — unchanged
print(b)             # [1, 2, 3, 99]

17.7.6 One-page cheat sheet

17.8 Nested Lists

A nested list is a list whose items are themselves lists — the natural way to represent a grid, table or matrix.

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(matrix[0])          # [1, 2, 3]   — row 0
print(matrix[1][2])       # 6           — row 1 column 2
print(len(matrix))        # 3           — number of rows
print(len(matrix[0]))     # 3           — number of columns

Two indices in a row give a single cell: matrix[row][col]. To visit every cell use nested loops:

students = [
    ["Aarav", 85, 72, 91],
    ["Kavya", 90, 88, 94],
    ["Ishan", 68, 75, 80]
]

for row in students:
    name = row[0]
    total = sum(row[1:])
    print(f"{name}: total = {total}")

Output:

Aarav: total = 248
Kavya: total = 272
Ishan: total = 223

17.9 Worked Programs

17.9.1 Maximum, Minimum, Mean of a list

nums = [23, 45, 11, 78, 56, 34]

# maximum
largest = nums[0]
for x in nums[1:]:
    if x > largest:
        largest = x

# minimum
smallest = nums[0]
for x in nums[1:]:
    if x < smallest:
        smallest = x

# mean
total = 0
for x in nums:
    total += x
mean = total / len(nums)

print("Max =", largest)
print("Min =", smallest)
print("Mean =", mean)

Max = 78
Min = 11
Mean = 41.166666666666664

print(max(nums), min(nums), sum(nums)/len(nums))

17.9.2 Linear search

Scan the list one element at a time, stopping as soon as the target is found. The natural use-case for break — or for-else.

nums  = [23, 45, 11, 78, 56, 34]
target = int(input("Search for: "))

for i in range(len(nums)):
    if nums[i] == target:
        print(target, "found at index", i)
        break
else:                                # for-else: runs only when no break
    print(target, "is not in the list")

Search for: 78     →  78 found at index 3
Search for: 99     →  99 is not in the list

17.9.3 Frequency of each element

Count how many times each unique value appears in a list. Two equivalent approaches:

nums = [1, 2, 3, 2, 1, 3, 1, 4]

for x in set(nums):                  # set removes duplicates
    print(x, "→", nums.count(x))

1 → 3
2 → 2
3 → 2
4 → 1

nums = [1, 2, 3, 2, 1, 3, 1, 4]
freq = {}
for x in nums:
    if x in freq:
        freq[x] += 1
    else:
        freq[x] = 1
print(freq)                        # {1: 3, 2: 2, 3: 2, 4: 1}

17.9.4 Bonus — Swap even-position and odd-position elements

One of the CBSE suggested practicals: swap elements at even indices with the ones at odd indices.

L = [10, 20, 30, 40, 50, 60]

for i in range(0, len(L) - 1, 2):
    L[i], L[i+1] = L[i+1], L[i]

print(L)             # [20, 10, 40, 30, 60, 50]

17.10 List vs String — Side-by-Side