How Do You Work with Nested Lists?

A nested list is a list whose items are themselves lists. The clearest way to build one is with a list comprehension, and the clearest way to read one is with a loop that goes row by row. The earlier questions in this topic covered ordinary lists, so this answer builds directly on that foundation and adds the idea of a list inside a list.

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

# Build a table from scratch, one row at a time.
table = []
for row in range(2):
    new_row = []
    for col in range(3):
        new_row.append(row * 3 + col)
    table.append(new_row)
print(table)   # [[0, 1, 2], [3, 4, 5]]

# Read the table row by row.
for row in matrix:
    print(row)

# Flatten the table into one list.
flat = []
for row in matrix:
    for value in row:
        flat.append(value)
print(flat)    # [1, 2, 3, 4, 5, 6]

The flattening loop has two loops inside it, and the order matters. The outer loop walks through the rows, and the inner loop walks through the values of one row. That is why the values come out row by row. If you swap the two loops, the program tries to walk through the individual numbers and it fails with an error.

Reading one value from a nested list uses two sets of square brackets. The expression matrix[0][1] means the second value of the first row. You can also unpack a whole row at once, like first, second, third = row, and that works as long as every row has the same number of values. If one row is shorter, Python raises a ValueError and tells you that the values did not match up.

Two things are worth remembering when you build nested structures. The first one is that each inner list must be built separately. Writing [[]] * 3 creates three references to the same inner list, so changing one of them changes all three. The second one is that a plain copy of the outer list still shares the inner objects, so a change inside one row is visible from every place that row is used.

Nested indexing is simply indexing that you do twice. The first index picks the row, and the second index picks one value inside that row.

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

print(rows[0][1])    # 2
print(rows[-1][0])   # 3

try:
    print(rows[5])
except IndexError as error:
    print('IndexError:', error)

try:
    print(rows[0][9])
except IndexError as error:
    print('IndexError:', error)

Both failures raise an IndexError, but they happen for different reasons. The first one is a missing row, because the outer index 5 is past the end of the outer list. The second one is a missing column, because the row exists but the value at position 9 does not exist inside it.

The important practical detail is that the error message does not tell you which of the two dimensions failed. The wording is almost the same in both cases, so the only clue is which line of your own code appears in the traceback. That is exactly why it is better to detect uneven rows yourself before you start reading values from them.

Uneven rows are the real danger when you work with nested lists. If one row has three values and another row has two, then rows[1][2] raises an error only for the short row. Code that works on the first row then fails in a confusing way on the second one. When the shape is not guaranteed, check it at the start with something like all(len(row) == 3 for row in rows). Or use a structure that cannot become uneven in the first place, such as a tuple of tuples, a numpy array, or a list of dataclasses with fixed fields.

The decision comes down to two simple questions. Does the structure always have the same shape, and do the items inside it have names?

A nested list is the right choice for a grid of values where the position is the only thing that identifies an item. A matrix of numbers, a game board, and a table of measurements all fit that description. It is compact, and it slices neatly with two indexes. Its weakness is that nothing stops the rows from becoming different lengths, and a position by itself carries no meaning at all.

A tuple of tuples is the fixed version of the same idea. Use it when the structure is fixed and should not change, when it is small, or when you need it to be hashable so that it can be used as a dictionary key or placed in a set. It also shows your intent clearly, because a tuple of tuples reads like a set of records that will not be changed.

A dictionary, or a list of dictionaries, is the right choice when the fields have names. The moment you find yourself writing rows[0][2] and trying to remember what the number 2 means, that is the signal to switch to a dictionary or to a dataclass with named attributes. A dataclass goes one step further, because it gives you the names, a helpful printed form, and type checking all at the same time.

The practical advice for an interview is to choose the most descriptive structure that is not more complicated than the problem really needs. Use nested lists for grids, dictionaries for records, and a dataclass when you want records with named fields and validation. When the shape truly matters, it is worth mentioning numpy, because it forces a rectangular array and gives you fast operations on the whole table for free.