Class 11 • Chapter 8

Lists

Chapter 8 introduces Lists, Python's most versatile data structure. It covers list creation, the concept of mutability, traversal techniques, and essential list methods.

16 note blocks4 exam topics

🎯 Exam Focus Areas

Clearly distinguish between Strings (Immutable) and Lists (Mutable).Understand the difference between `append()` (adds one item) and `extend()` (adds multiple items).Trace list slicing operations.Understand the difference between `pop()` (removes by index) and `remove()` (removes by value).

A variable can only hold a single piece of data. If you needed to store the grades of 100 students, creating 100 variables (`grade1`, `grade2`...) would be a nightmare. Python solves this with Lists. A List is a built-in data structure that allows you to store an ordered collection of multiple items inside a single variable. Lists are incredibly powerful, flexible, and heavily used in almost every Python script.

8.1 Creating and Accessing Lists

Lists are created by placing elements inside square brackets `[]`, separated by commas. Unlike arrays in C or Java, Python lists are heterogeneous, meaning they can hold items of completely different data types simultaneously.

# A homogeneous list (all integers)
scores = [95, 82, 75, 100]

# A heterogeneous list (mixed data types)
student_record = ["Basant", 17, True, 88.5]

# Accessing elements uses the exact same Indexing rules as strings
print(scores[0])       # Output: 95
print(student_record[-1]) # Output: 88.5

8.2 Lists are Mutable

CRITICAL RULE: Unlike strings, Lists are Mutable. This means you can freely change, add, or remove elements within the list without creating a brand new list in memory.

fruits = ["Apple", "Banana", "Cherry"]

# Modifying an existing element in place
fruits[1] = "Blueberry"

print(fruits) # Output: ['Apple', 'Blueberry', 'Cherry']

8.3 Traversing a List

Traversing means visiting every single element in the list, one by one. This is overwhelmingly done using a `for` loop.

colors = ["Red", "Green", "Blue"]

# The elegant Pythonic way to traverse
for color in colors:
    print(color)

# Traversing using index (Useful if you need to know the index number)
for i in range(len(colors)):
    print(f"Index {i} holds {colors[i]}")

8.4 List Operations

Just like strings, lists support concatenation, replication, and slicing.

1Concatenation (+): Joins two lists together. (e.g., `[1, 2] + [3, 4]` -> `[1, 2, 3, 4]`)
2Replication (*): Repeats the list. (e.g., `[0] * 3` -> `[0, 0, 0]`)
3Slicing: Extracts a sub-list. (e.g., `my_list[1:4]` returns a new list containing elements from index 1 to 3).

8.5 Built-in List Methods

Because lists are mutable, many list methods modify the list in-place and return `None`.

1list.append(item): Adds a single item to the very end of the list.
2list.extend(iterable): Appends all elements from another list/sequence to the end.
3list.insert(index, item): Inserts an item at a specific index, shifting other elements to the right.
4list.pop(index): Removes AND returns the item at the given index. If no index is provided, it pops the last item.
5list.remove(value): Removes the first occurrence of the specified value. Crashes if the value is not found.
6list.sort(): Sorts the list in ascending order in-place.
7list.reverse(): Reverses the order of elements in-place.

📝 Quick Revision Points

1Lists use square brackets `[]`.
2Lists are Mutable (changeable in place).
3Lists can hold mixed data types.
4`append(x)` adds `x` to the end.
5`extend([x,y])` merges lists.
6`pop(i)` removes index `i`. `remove(v)` removes value `v`.
7`sort()` and `reverse()` modify the list permanently.

← PreviousString Manipulation Next →Tuples

Loading notes...

# A homogeneous list (all integers) scores = [95, 82, 75, 100] # A heterogeneous list (mixed data types) student_record = ["Basant", 17, True, 88.5] # Accessing elements uses the exact same Indexing rules as strings print(scores[0]) # Output: 95 print(student_record[-1]) # Output: 88.5

colors = ["Red", "Green", "Blue"] # The elegant Pythonic way to traverse for color in colors: print(color) # Traversing using index (Useful if you need to know the index number) for i in range(len(colors)): print(f"Index {i} holds {colors[i]}")