After this section
- \n
- You will be able to read tables represented as lists of lists \n
- You will be able to traverse rows and columns \n
- You will know when named dictionary fields are clearer than positional columns \n
In parts 1-4, you learned about the fundamental building blocks of programs and the most common shapes used to organise data. In parts 5-8, you'll be learning two interrelated things:
- \n
- More complex data structures, particular quirks and commonly used ready functions \n
- How to use the building blocks you now know to solve problems \n
Becoming a proficient programmer requires a lot of practice, sometimes even quite mechanical practice. It also involves developing problem solving skills and applying intuition. This is why there are a lot of exercises of different kinds on this course. Some of them ask you to quite straightforwardly apply what you have learnt in the material, but some of them are intentionally more challenging and open-ended.
Some of the exercises might at first seem overwhelming, but this is nothing to worry about. None of the exercises is strictly mandatory. You can find more details about passing the course on the page on grading.
The exercises are not in any specific order of difficulty. Each section usually introduces some new programming concepts, and these are then practised with both simpler and more complicated exercises. If you come across an exercise that feels too difficult, move on to the next one. You can always come back to the more difficult exercises if you have time later.
Working with tables
Part 4 introduced tables represented as lists of lists. Here we will use that data shape to traverse rows, columns and regions. The following list of rows represents this table:
| Name | \nAge | \nHeight | \n
|---|---|---|
| Betty | \n10 | \n1.37 | \n
| Peter | \n7 | \n1.25 | \n
| Emily | \n32 | \n1.64 | \n
| Alan | \n39 | \n1.78 | \n
However, only you as the creator of the data knows that row[0] is the name, row[1] is the age, and row[2] is the height, as these are not stored in the list of lists itself.
Since a table is a list containing lists, the individual elements within the table can be accessed using consecutive square brackets. The first index refers to the row, and the second to the column. Indexing starts from zero, so for example my_table[0][1] refers to the second item on the first row.
my_table = [[\"Betty\", 10, 1.37], [\"Peter\", 7, 1.25], [\"Emily\", 32, 1.64], [\"Alan\", 39, 1.78]]\nprint(my_table[0][1])\nmy_table[1][0] = \"John\"\nprint(my_table)10\n[[\"Betty\", 10, 1.37], [\"John\", 7, 1.25], [\"Emily\", 32, 1.64], [\"Alan\", 39, 1.78]]
Like any other list, the rows of the table can be traversed with a for loop. The following code prints out each row of the table on a separate line:
my_table = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n\nfor row in my_table:\n print(row)[1, 2, 3]\n[4, 5, 6]\n[7, 8, 9]
Likewise, nested loops can be used to access the individual elements. The following code prints out each element in the table on a separate line with the help of two for loops:
my_table = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n\nfor row in my_table:\n print(\"a new row\")\n for element in row:\n print(element)a new row\n1\n2\n3\na new row\n4\n5\n6\na new row\n7\n8\n9
Visualising code containing lists within lists
Programs containing lists within lists can feel hard to grasp at first. The visualisation tool from Python Tutor is a great help in understanding how they work. The following is a visualisation of the example above:
\n \n \n![\"5](\"/programming-digital-humanities/static/10e6583e2d3db7e04fba937644e94e43/87a80/5_1_2.png\" "\\"5")
\n The image above reveals that a 3 by 3 table technically consists of four lists. The first list represents the entire table. The three remaining lists are items in the first list, and represent the rows.
As multidimensional lists can be traversed with nested loops, it would be natural to think of the lists themselves as nested, but the image above shows us this isn't actually so. Instead, the list representing the whole table \"points\" to each individual list representing a row in the table.
In the image above the execution has progressed to the second row of the table, and this list is what the variable row currently refers to. The variable element contains the element the execution is currently at. The value stored in element is the middle item in the list, i.e. 5.
Accessing items in a table
Accessing a single row within a table is simple - just choose the desired row. The following function calculates the sum of the elements on a chosen row:
def sum_of_row(my_table, row_no: int):\n # choose the desired row from within the table\n row = my_table[row_no]\n row_sum = 0\n for item in row:\n row_sum += item\n\n return row_sum\n\nm = [[4, 2, 3, 2], [9, 1, 12, 11], [7, 8, 9, 5], [2, 9, 15, 1]]\n\nmy_sum = sum_of_row(m, 1)\nprint(my_sum) # prints out 33 (which equals 9 + 1 + 12 + 11)Working with columns within a table is slightly more complicated, as the table is stored by rows:
def sum_of_column(my_table, column_no: int):\n # go through each row and select the item at the chosen position\n column_sum = 0\n for row in my_table:\n column_sum += row[column_no]\n\n return column_sum\n\nm = [[4, 2, 3, 2], [9, 1, 12, 11], [7, 8, 9, 5], [2, 9, 15, 1]]\n\nmy_sum = sum_of_column(m, 2)\nprint(my_sum) # prints out 39 (which equals 3 + 12 + 9 + 15)The column handled here consists of the elements at index 2 on each row.
The visualisation tool is definitely recommended for understanding how these functions work.
Changing the value of a single element within the table is simple: choose a row within the table, and then a column within the row:
def change_value(my_table, row_no: int, column_no: int, new_value: int):\n # choose the desired row\n row = my_table[row_no]\n # select the correct item within the row\n row[column_no] = new_value\n\nm = [[4, 2, 3, 2], [9, 1, 12, 11], [7, 8, 9, 5], [2, 9, 15, 1]]\n\nprint(m)\nchange_value(m, 2, 3, 1000)\nprint(m)[[4, 2, 3, 2], [9, 1, 12, 11], [7, 8, 9, 5], [2, 9, 15, 1]]\n[[4, 2, 3, 2], [9, 1, 12, 11], [7, 8, 9, 1000], [2, 9, 15, 1]]
Notice how above we used the indexes of the row and column to access a chosen element. If we want to change the contents of the table, we have to access the elements by their indexes. This means that we can't use a simple for item in list loop to traverse the table if we want to change the contents of the table.
Instead, we will have to keep track of the indexes of the elements, for example with a while loop, or a for loop using the range function. The following code increases the value of each element in the table by one:
m = [[1,2,3], [4,5,6], [7,8,9]]\n\nfor i in range(len(m)): # using the number of rows in the table\n for j in range(len(m[i])): # using the number of items on each row\n m[i][j] += 1\n\nprint(m)[[2, 3, 4], [5, 6, 7], [8, 9, 10]]
The outer loop goes through indexes from zero to the length of the table, that is, the number of rows in the table. The inner loop goes through indexes from zero to the length of each row within the table.
Mode: Code review and repair
The starter contains a function named count_matching_elements(my_table: list, element: int). It is meant to count how many values in a two-dimensional list match element, but its loop currently visits only the first row.
Before editing the function, predict what the starter will return for each call below. Run the code and compare the results with your predictions.
print(count_matching_elements([[1, 2, 1]], 1))\nprint(count_matching_elements([[1, 2, 1], [1, 1], [2]], 1))Then repair the function so that it visits every value in every row. It must not change the original table.
An example of how the function should work:
m = [[1, 2, 1], [0, 3, 4], [1, 0, 0]]\nprint(count_matching_elements(m, 1))3
Mode: Independent practice
Survey responses have been split into labels and stored as a list of rows. Each row may contain a different number of labels:
responses = [\n [\"history\", \"art\"],\n [\"music\"],\n [\"history\", \"history\", \"music\"]\n]Please write a function named count_labels(table: list, label: str), which returns the total number of occurrences of label anywhere in the table. Repeated labels in the same row count separately. The function must not change the table.
print(count_labels(responses, \"history\"))\nprint(count_labels(responses, \"science\"))3\n0
A two-dimensional array as a data structure in a game
A table can be a very useful data structure in many different games. For example, the grid of a sudoku game in the image below
\n \n \n![\"5](\"/programming-digital-humanities/static/5a4d938ae5202e8db72b179ff4d76293/d68e4/5_1_3.png\" "\\"5")
\n can be represented in table form like so:
sudoku = [\n [9, 0, 0, 0, 8, 0, 3, 0, 0],\n [0, 0, 0, 2, 5, 0, 7, 0, 0],\n [0, 2, 0, 3, 0, 0, 0, 0, 4],\n [0, 9, 4, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 7, 3, 0, 5, 6, 0],\n [7, 0, 5, 0, 6, 0, 4, 0, 0],\n [0, 0, 7, 8, 0, 3, 9, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0, 3],\n [3, 0, 0, 0, 0, 0, 0, 0, 2]\n]Here the value zero represents an empty square, as zero is not an acceptable value in a finished sudoku puzzle.
Here is a simple function for printing out the above sudoku grid:
def print_grid(sudoku):\n for row in sudoku:\n for square in row:\n if square > 0:\n print(f\" {square}\", end=\"\")\n else:\n print(\" _\", end=\"\")\n print()\n\nprint_grid(sudoku)The printout should look like this::
\n 9 _ _ _ 8 _ 3 _ _\n _ _ _ 2 5 _ 7 _ _\n _ 2 _ 3 _ _ _ _ 4\n _ 9 4 _ _ _ _ _ _\n _ _ _ 7 3 _ 5 6 _\n 7 _ 5 _ 6 _ 4 _ _\n _ _ 7 8 _ 3 9 _ _\n _ _ 1 _ _ _ _ _ 3\n 3 _ _ _ _ _ _ _ 2\nAny common game with a gameboard layout can be modelled in a similar fashion. Among others, chess, Minesweeper, Battleship or Mastermind are all based on a two-dimensional grid. For sudoku, it is natural to use numbers to represent the game state, but for other games, different methods may be better.
Consolidation: Sudoku traversals
The next four exercises deliberately revisit the same grid from different directions. This repetition is useful if indexing and nested loops are not yet fluent. Exercises 05-04 to 05-06 practise the individual traversals independently; 05-07 then combines them.
Mode: Independent practice
Please write a function named row_correct(sudoku: list, row_no: int), which takes a two-dimensional array representing a sudoku grid, and an integer referring to a single row, as its arguments. Rows are indexed from 0.
The function should return True or False, depending on whether the row is filled in correctly, that is, whether it contains each of the numbers 1 to 9 at most once.
sudoku = [\n [9, 0, 0, 0, 8, 0, 3, 0, 0],\n [2, 0, 0, 2, 5, 0, 7, 0, 0],\n [0, 2, 0, 3, 0, 0, 0, 0, 4],\n [2, 9, 4, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 7, 3, 0, 5, 6, 0],\n [7, 0, 5, 0, 6, 0, 4, 0, 0],\n [0, 0, 7, 8, 0, 3, 9, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0, 3],\n [3, 0, 0, 0, 0, 0, 0, 0, 2]\n]\n\nprint(row_correct(sudoku, 0))\nprint(row_correct(sudoku, 1))True\nFalse
Mode: Independent practice
Please write a function named column_correct(sudoku: list, column_no: int), which takes a two-dimensional array representing a sudoku grid, and an integer referring to a single column, as its arguments. Columns are indexed from 0.
The function should return True or False, depending on whether the column is filled in correctly, that is, whether it contains each of the numbers 1 to 9 at most once.
sudoku = [\n [9, 0, 0, 0, 8, 0, 3, 0, 0],\n [2, 0, 0, 2, 5, 0, 7, 0, 0],\n [0, 2, 0, 3, 0, 0, 0, 0, 4],\n [2, 9, 4, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 7, 3, 0, 5, 6, 0],\n [7, 0, 5, 0, 6, 0, 4, 0, 0],\n [0, 0, 7, 8, 0, 3, 9, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0, 3],\n [3, 0, 0, 0, 0, 0, 0, 0, 2]\n]\n\nprint(column_correct(sudoku, 0))\nprint(column_correct(sudoku, 1))False\nTrue
Mode: Independent practice
Please write a function named block_correct(sudoku: list, row_no: int, column_no: int), which takes a two-dimensional array representing a sudoku grid, and two integers referring to the row and column indexes of a single square, as its arguments. Rows and columns are indexed from 0.
The function should return True or False depending on whether the 3 by 3 block to the right and down from the given indexes is filled in correctly. That is, whether the block contains each of the numbers 1 to 9 at most once.
In a real game of sudoku there are only 9 blocks to check, and these are located at indexes (0, 0), (0, 3), (0, 6), (3, 0), (3, 3), (3, 6), (6, 0), (6, 3) and (6, 6). However, you do not need to mind this. Just look at the 3 by 3 block to the right and down from whatever indices you're given.
sudoku = [\n [9, 0, 0, 0, 8, 0, 3, 0, 0],\n [2, 0, 0, 2, 5, 0, 7, 0, 0],\n [0, 2, 0, 3, 0, 0, 0, 0, 4],\n [2, 9, 4, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 7, 3, 0, 5, 6, 0],\n [7, 0, 5, 0, 6, 0, 4, 0, 0],\n [0, 0, 7, 8, 0, 3, 9, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0, 3],\n [3, 0, 0, 0, 0, 0, 0, 0, 2]\n]\n\nprint(block_correct(sudoku, 0, 0))\nprint(block_correct(sudoku, 1, 2))False\nTrue
The first function call should check the 3 by 3 block beginning with the square at indexes 0, 0:
\n9 0 0\n2 0 0\n0 2 0\n
The second function call should check the 3 by 3 block beginning with the square at row 1, column 2:
\n0 2 5\n0 3 0\n4 0 0\n
This second block would not be checked in an actual game of sudoku, but as the logic is the same, your function should allow for it to be checked.
Mode: Agent-assisted change
Copy your row_correct, column_correct and block_correct functions from the three previous exercises into the starter. The supplied sudoku_grid_correct(sudoku: list) coordinator is incomplete: it checks all rows and columns, but the assertion in the main program still fails.
Follow the agent-assisted workflow from Working with AI from Part 5 onward:
- \n
- Specify what
sudoku_grid_correctmust check and what the failing grid demonstrates. \n - Ask an agent to inspect the coordinator and propose a repair without rewriting your three helper functions. \n
- Inspect the proposed change. Identify the loop values used as the starting row and column of each block, and explain why those values visit all nine blocks exactly once. \n
- Apply and verify the repair. Add one more assertion of your own for a grid which is invalid because of a row or a column. \n
The function should check each of the nine rows, columns and 3 by 3 blocks in the grid. If all contain each of the numbers 1 to 9 at most once, the function returns True. If any line, column or 3 by 3 block has the same number more than once, the function returns False.
The image of a sudoku grid above these exercises has the nine blocks within the grid indicated with thicker borders. These are the blocks the function should check, and they begin at the indexes (0, 0), (0, 3), (0, 6), (3, 0), (3, 3), (3, 6), (6, 0), (6, 3) and (6, 6).
sudoku1 = [\n [9, 0, 0, 0, 8, 0, 3, 0, 0],\n [2, 0, 0, 2, 5, 0, 7, 0, 0],\n [0, 2, 0, 3, 0, 0, 0, 0, 4],\n [2, 9, 4, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 7, 3, 0, 5, 6, 0],\n [7, 0, 5, 0, 6, 0, 4, 0, 0],\n [0, 0, 7, 8, 0, 3, 9, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0, 3],\n [3, 0, 0, 0, 0, 0, 0, 0, 2]\n]\n\nprint(sudoku_grid_correct(sudoku1))\n\nsudoku2 = [\n [2, 6, 7, 8, 3, 9, 5, 0, 4],\n [9, 0, 3, 5, 1, 0, 6, 0, 0],\n [0, 5, 1, 6, 0, 0, 8, 3, 9],\n [5, 1, 9, 0, 4, 6, 3, 2, 8],\n [8, 0, 2, 1, 0, 5, 7, 0, 6],\n [6, 7, 4, 3, 2, 0, 0, 0, 5],\n [0, 0, 0, 4, 5, 7, 2, 6, 3],\n [3, 2, 0, 0, 8, 0, 0, 5, 7],\n [7, 4, 5, 0, 0, 3, 9, 0, 1]\n]\n\nprint(sudoku_grid_correct(sudoku2))False\nTrue
The first grid fails due to e.g. row 1 having more than one 2, column 0 having more than one 2 and the first 3x3 block at (0,0) - (2,2) having more than one 2.