1   Why Do We Need Lists?

Imagine you are writing a program to track the scores of five students. Without lists, you might write:

score1 = 85
score2 = 42
score3 = 91
score4 = 67
score5 = 55

This works for five students. But what about thirty? Or three hundred? And how would you loop over them, sort them, or find the highest? You would need separate code for every single variable.

With a list, all five scores live together under one name:

scores = [85, 42, 91, 67, 55]

Now you can loop over them, sort them, slice them, and pass them to a function — all in one step.

2   Creating a List

A list is written with square brackets [ ], with items separated by commas. You can put any type of value inside — integers, floats, strings, booleans, or even a mix.

scores     = [85, 42, 91, 67, 55]           # integers
prices     = [9.99, 14.50, 3.75]             # floats
names      = ["Alice", "Bob", "Carol"]       # strings
flags      = [True, False, True, True]       # booleans
mixed      = [1, "hello", 3.14, True]        # mixed types (valid, but unusual)
empty      = []                              # an empty list — valid and useful

2.1   The Vocabulary of Lists

3   Accessing Items

List indexing works identically to string indexing from Article 7 — zero-based, supports negative indices, and raises an IndexError if you go out of range.

fruits = ["apple", "banana", "cherry", "date", "elderberry"]
#           0         1          2        3          4

print(fruits[0])    # apple      — first item
print(fruits[2])    # cherry     — index 2
print(fruits[-1])   # elderberry — last item
print(fruits[-2])   # date       — second to last

Slicing also works exactly as in Article 7:

print(fruits[1:3])    # ['banana', 'cherry']
print(fruits[:2])     # ['apple', 'banana']
print(fruits[-2:])    # ['date', 'elderberry']
print(fruits[::-1])   # ['elderberry', 'date', 'cherry', 'banana', 'apple']

3.1   Checking the Length

The built-in len() function returns the number of items in a list. You will use this constantly — in loops, in conditions, in slice calculations:

scores = [85, 42, 91, 67, 55]
print(len(scores))         # 5

# The last valid index is always len(list) - 1
print(scores[len(scores) - 1])    # 55 — same as scores[-1]

4   Modifying a List

Unlike strings, lists are mutable — you can change them after creation. Python gives you several ways to modify a list: replacing items, adding new ones, and removing existing ones.

4.1   Replacing an Item

Use the index on the left side of an assignment to replace a specific item:

scores = [85, 42, 91, 67, 55]
scores[1] = 78            # replace the item at index 1
print(scores)             # [85, 78, 91, 67, 55]

4.2   Adding Items

fruits = ["apple", "banana"]

fruits.append("cherry")
print(fruits)               # ['apple', 'banana', 'cherry']

fruits.insert(1, "avocado")
print(fruits)               # ['apple', 'avocado', 'banana', 'cherry']

fruits.extend(["date", "elderberry"])
print(fruits)               # ['apple', 'avocado', 'banana', 'cherry', 'date', 'elderberry']

4.3   Removing Items

colours = ["red", "green", "blue", "green", "yellow"]

colours.remove("green")       # removes the FIRST "green"
print(colours)                # ['red', 'blue', 'green', 'yellow']

last = colours.pop()
print(last)                   # yellow
print(colours)                # ['red', 'blue', 'green']

del colours[0]
print(colours)                # ['blue', 'green']

5   Looping Over Lists

Looping and lists were made for each other. A for loop steps through every item in a list automatically — no index needed, no counter to manage.

5.1   The Basic for Loop

names = ["Alice", "Bob", "Carol"]

for name in names:
    print("Hello,", name + "!")

Output:

Hello, Alice!
Hello, Bob!
Hello, Carol!

5.2   When You Need the Index Too: enumerate()

Sometimes you need both the item and its position. Rather than using range(len(list)), Python provides the cleaner built-in enumerate(), which gives you both at once:

students = ["Alice", "Bob", "Carol", "Dan"]

# Without enumerate — works but clunky
for i in range(len(students)):
    print(i + 1, students[i])

# With enumerate — cleaner and more readable
for i, student in enumerate(students, start=1):
    print(i, student)

Both produce the same output:

1 Alice
2 Bob
3 Carol
4 Dan

5.3   Building a List Inside a Loop

One of the most common patterns is starting with an empty list and building it up inside a loop — the collector pattern from Article 5:

scores = [78, 92, 55, 84, 40, 67, 38, 95]
passing = []

for score in scores:
    if score >= 60:
        passing.append(score)

print("Passing scores:", passing)
print("Pass rate:", len(passing), "out of", len(scores))

6   Useful List Methods and Functions

Python gives lists a rich set of built-in methods. Here are the ones you will use most often:

6.1   Sorting

scores = [85, 42, 91, 67, 55]

scores.sort()                     # sorts IN PLACE — modifies the original list
print(scores)                     # [42, 55, 67, 85, 91]

scores.sort(reverse=True)         # sorts in descending order
print(scores)                     # [91, 85, 67, 55, 42]

# sorted() returns a NEW sorted list — original is unchanged
original = [85, 42, 91, 67, 55]
ranked = sorted(original)
print(original)                   # [85, 42, 91, 67, 55] — unchanged
print(ranked)                     # [42, 55, 67, 85, 91]

6.2   Searching

fruits = ["apple", "banana", "cherry", "banana"]

# Check membership
print("banana" in fruits)         # True
print("mango" in fruits)          # False

# Find the index of the first occurrence
print(fruits.index("banana"))     # 1

# Count how many times a value appears
print(fruits.count("banana"))     # 2

6.3   Other Handy Built-ins

7   Copying Lists — A Subtle Trap

This section covers one of the most surprising behaviours beginners encounter with lists. Read it carefully — it has caught out almost every programmer at least once.

7.1   Assignment Does Not Copy a List

When you write b = a for a simple variable, b gets its own copy of the value. Lists do not work this way. When you write b = a for a list, b and a both point to the same list in memory. Changing one changes the other:

original = [1, 2, 3, 4, 5]
alias = original              # NOT a copy — both point to the same list

alias.append(6)
print(original)               # [1, 2, 3, 4, 5, 6] — also changed!
print(alias)                  # [1, 2, 3, 4, 5, 6]

7.2   How to Actually Copy a List

There are three common ways to make a true independent copy:

original = [1, 2, 3, 4, 5]

copy_a = original.copy()      # using .copy()
copy_b = original[:]          # using a full slice
copy_c = list(original)       # using the list() constructor

copy_a.append(99)
print(original)               # [1, 2, 3, 4, 5] — unchanged
print(copy_a)                 # [1, 2, 3, 4, 5, 99]

All three methods produce an independent shallow copy. Any of them is fine — .copy() is the most readable and self-documenting.

8   Lists of Lists

A list can contain any value — including other lists. This is called a nested list, and it is a natural way to represent grid-like or tabular data: rows of a table, a game board, a matrix of values.

# A class's scores — three students, three tests each
results = [
    [85, 90, 78],    # Alice's scores
    [42, 55, 61],    # Bob's scores
    [91, 88, 95],    # Carol's scores
]

# Access a whole row (one student's scores)
print(results[0])           # [85, 90, 78]

# Access a single score — row then column
print(results[0][1])        # 90  (Alice's second test)
print(results[2][0])        # 91  (Carol's first test)

The notation results[row][column] reads left to right: first pick the row, then pick the item within that row.

8.1   Looping Over a Nested List

results = [
    ["Alice", 85, 90, 78],
    ["Bob",   42, 55, 61],
    ["Carol", 91, 88, 95],
]

for row in results:
    name   = row[0]
    scores = row[1:]           # slice off the name, keep the scores
    avg    = sum(scores) / len(scores)
    print(f"  {name:<8} average: {avg:.1f}")

Output:

  Alice    average: 84.3
  Bob      average: 52.7
  Carol    average: 91.3

9   Putting It All Together

Here is a complete program that uses the most important list operations from this article. Read it carefully and predict the output before running it.

def get_scores(n):
    """Collects n scores from the user and returns them as a list."""
    scores = []
    for i in range(1, n + 1):
        while True:
            score = int(input(f"  Enter score {i} of {n}: "))
            if 0 <= score <= 100:
                break
            print("  Please enter a score between 0 and 100.")
        scores.append(score)
    return scores

def analyse(scores):
    """Returns a dict of summary statistics for a list of scores."""
    passing = [s for s in scores if s >= 60]
    return {
        "count":   len(scores),
        "highest": max(scores),
        "lowest":  min(scores),
        "average": round(sum(scores) / len(scores), 1),
        "passing": len(passing),
    }

def print_report(scores, stats):
    """Prints a formatted report."""
    ranked = sorted(scores, reverse=True)

    print("\n=== Score Report ===")
    print(f"  Scores entered : {scores}")
    print(f"  Ranked (high→low): {ranked}")
    print(f"  Highest : {stats['highest']}")
    print(f"  Lowest  : {stats['lowest']}")
    print(f"  Average : {stats['average']}")
    print(f"  Passing : {stats['passing']} / {stats['count']}")


# ── Main ──────────────────────────────────────────────────────────
print("Enter 5 student scores:")
scores = get_scores(5)
stats  = analyse(scores)
print_report(scores, stats)

Things to notice:

• get_scores() builds a list using the collector pattern with .append() inside a loop.
• analyse() uses a list comprehension ([s for s in scores if s >= 60]) — a compact way to build a filtered list. This is introduced properly in a later article, but you can read it as: "a list of every s in scores where s >= 60."
• sorted(scores, reverse=True) creates a ranked copy without modifying scores — so the original order is preserved for the report.
• The functions communicate entirely through parameters and return values — no global lists are modified.

10   Final Check: The Big Picture

11   Quick-Reference Summary