Nested Lists and Dictionaries in Python

Real data has layers

So far your lists have held simple values like numbers or words, and your dictionaries have mapped single keys to single values. But real information is rarely that flat. A class isn't just a list of names — it's a list of students, and each student has a name, an age and several scores. A chessboard is a grid of squares. A shopping app stores many orders, and each order contains many items.

To model layered data, Python lets you put collections inside collections. This is called nesting, and it is one of the most useful ideas in everyday programming.

Lists inside lists: a grid

The simplest nesting is a list of lists, which gives you a 2D grid:

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

print(grid[0])        # [1, 2, 3]   the whole first row
print(grid[1][2])     # 6           row 1, column 2
print(grid[2][0])     # 7           row 2, column 0

Reading the indexing carefully:

• grid is a list whose items are themselves lists (the rows).
• grid[0] selects the first inner list — an entire row.
• grid[1][2] does it in two steps: grid[1] gives the row [4, 5, 6], then [2] takes its third item, 6.

The rule is simple: each pair of brackets goes one level deeper, left to right.

Looping through a grid

To visit every cell, use two nested loops — the outer one walks the rows, the inner one walks the columns:

grid = [
    [1, 2, 3],
    [4, 5, 6],
]

for row in grid:
    for cell in row:
        print(cell, end=" ")
    print()                # newline after each row

This prints:

1 2 3
4 5 6

• for row in grid gives each inner list in turn.
• for cell in row then walks the items inside that row.
• end=" " keeps the numbers on one line; the bare print() after the inner loop starts a new line for the next row.

If nested loops are new to you, the lesson on nested loops and patterns shows more examples of this two-layer pattern.

A list of dictionaries: records

By far the most common nested structure in real programs is a list of dictionaries. Each dictionary is one record (think of a row in a spreadsheet), and the list holds them all:

students = [
    {"name": "Ada",     "age": 14, "score": 90},
    {"name": "Brahim",  "age": 15, "score": 76},
    {"name": "Chen",    "age": 14, "score": 88},
]

print(students[0])           # the whole first record
print(students[0]["name"])   # Ada
print(students[2]["score"])  # 88

• students[0] selects the first dictionary in the list.
• students[0]["name"] then reads the "name" value from that record: "Ada".
• Each record can have the same keys, giving you a clean, table-like structure.

Looping over records is now very natural:

for student in students:
    print(student["name"], "scored", student["score"])

Ada scored 90
Brahim scored 76
Chen scored 88

Each pass gives you one whole dictionary in student, and you read its fields by key.

A dictionary of dictionaries

Sometimes you want to look records up by a name rather than a position. Then use a dictionary whose values are themselves dictionaries:

players = {
    "ada":   {"score": 90, "level": 5},
    "brahim":{"score": 76, "level": 3},
}

print(players["ada"]["score"])   # 90
print(players["brahim"]["level"])# 3

# Add a new field to one record:
players["ada"]["wins"] = 12
print(players["ada"])            # {'score': 90, 'level': 5, 'wins': 12}

• players["ada"] fetches Ada's inner dictionary in one step — no scanning needed.
• A second ["score"] reaches into that inner dictionary.
• You can add or change inner fields just like any dictionary, e.g. players["ada"]["wins"] = 12.

Use a list of dicts when order matters or you process every record; use a dict of dicts when you mostly look records up by a unique name or id.

Reaching deep, safely

When data is nested several layers, two habits keep you sane. First, peel one layer at a time into named variables:

data = {"team": {"members": [{"name": "Ada"}, {"name": "Chen"}]}}

team = data["team"]
members = team["members"]
first = members[0]
print(first["name"])    # Ada

Each line names exactly one step, so a typo is easy to spot. Second, use .get() on dictionaries to avoid crashes when a key might be missing:

player = {"name": "Ada"}
print(player.get("score", 0))   # 0  (no 'score' key, so the default is used)

.get("score", 0) returns 0 instead of raising a KeyError when the key is absent — a safe way to read optional fields.

Worked example: a small gradebook

Let's combine the patterns. We have a list of student records and want to find the top scorer and the class average.

students = [
    {"name": "Ada",    "scores": [90, 85, 92]},
    {"name": "Brahim", "scores": [70, 75, 80]},
    {"name": "Chen",   "scores": [88, 91, 84]},
]

best_name = None
best_avg = -1
class_total = 0

for student in students:
    scores = student["scores"]
    avg = sum(scores) / len(scores)
    class_total += avg
    print(student["name"], "average:", round(avg, 1))
    if avg > best_avg:
        best_avg = avg
        best_name = student["name"]

print("Top student:", best_name, "with", round(best_avg, 1))
print("Class average:", round(class_total / len(students), 1))

Output:

Ada average: 89.0
Brahim average: 75.0
Chen average: 87.7
Top student: Ada with 89.0
Class average: 83.9

How it works:

1. Each student is a dictionary; student["scores"] is a nested list of that student's marks.
2. sum(scores) / len(scores) computes each personal average.
3. We track the best average seen so far in best_avg and remember the matching name — a classic "find the maximum" pattern.
4. class_total accumulates the averages so we can divide for the overall class average at the end.

This single small program touches every idea in the lesson: a list of dictionaries, a list nested inside each dictionary, and a loop that reaches into both layers.

Try it yourself

Build a tiny library catalogue:

• Make a list of dictionaries, each with "title", "author" and "available" (a boolean).
• Loop through and print only the books where "available" is True.
• Add a nested list of "tags" to each book and print the first tag of the first book with books[0]["tags"][0].
• Turn it into a dictionary of dictionaries keyed by title, and look one book up directly by its title.

When your records get more complex, see how the same data could be saved and reloaded in reading and writing files in Python.