• Print
This chapter is from the book

## 5.16 Two-Dimensional Lists

Lists can contain other lists as elements. A typical use of such nested (or multidimensional) lists is to represent tables of values consisting of information arranged in rows and columns. To identify a particular table element, we specify two indices—by convention, the first identifies the element’s row, the second the element’s column.

Lists that require two indices to identify an element are called two-dimensional lists (or double-indexed lists or double-subscripted lists). Multidimensional lists can have more than two indices. Here, we introduce two-dimensional lists.

#### Creating a Two-Dimensional List

Consider a two-dimensional list with three rows and four columns (i.e., a 3-by-4 list) that might represent the grades of three students who each took four exams in a course:

`In : a = [[77, 68, 86, 73], [96, 87, 89, 81], [70, 90, 86, 81]]`

Writing the list as follows makes its row and column tabular structure clearer:

`a = [[77, 68, 86, 73],  # first student's grades      [96, 87, 89, 81],  # second student's grades       [70, 90, 86, 81]]  # third student's grades`

#### Illustrating a Two-Dimensional List

The diagram below shows the list a, with its rows and columns of exam grade values:

#### Identifying the Elements in a Two-Dimensional List

The following diagram shows the names of list a’s elements:

Every element is identified by a name of the form a[i][j]a is the list’s name, and i and j are the indices that uniquely identify each element’s row and column, respectively. The element names in row 0 all have 0 as the first index. The element names in column 3 all have 3 as the second index.

In the two-dimensional list a:

• 77, 68, 86 and 73 initialize a, a, a and a, respectively,

• 96, 87, 89 and 81 initialize a, a, a and a, respectively, and

• 70, 90, 86 and 81 initialize a, a, a and a, respectively.

A list with m rows and n columns is called an m-by-n list and has m × n elements.

The following nested for statement outputs the rows of the preceding two-dimensional list one row at a time:

```In : for row in a:
...:     for item in row:
...:         print(item, end=' ')
...:     print()
...:
77 68 86 73
96 87 89 81
70 90 86 81```

#### How the Nested Loops Execute

Let’s modify the nested loop to display the list’s name and the row and column indices and value of each element:

```In : for i, row in enumerate(a):
...:     for j, item in enumerate(row):
...:         print(f'a[{i}][{j}]={item} ', end=' ')
...:     print()
...:
a=77  a=68  a=86  a=73
a=96  a=87  a=89  a=81
a=70  a=90  a=86  a=81  ```

The outer for statement iterates over the two-dimensional list’s rows one row at a time. During each iteration of the outer for statement, the inner for statement iterates over each column in the current row. So in the first iteration of the outer loop, row 0 is

`          [77, 68, 86, 73]`

and the nested loop iterates through this list’s four elements a=77, a=68, a=86 and a=73.

In the second iteration of the outer loop, row 1 is

`         [96, 87, 89, 81]`

and the nested loop iterates through this list’s four elements a=96, a=87, a=89 and a=81.

In the third iteration of the outer loop, row 2 is

`         [70, 90, 86, 81]`

and the nested loop iterates through this list’s four elements a=70, a=90, a=86 and a=81.

In the “Array-Oriented Programming with NumPy” chapter, we’ll cover the NumPy library’s ndarray collection and the Pandas library’s DataFrame collection. These enable you to manipulate multidimensional collections more concisely and conveniently than the two-dimensional list manipulations you’ve seen in this section.