One of the central ideas behind the minimax algorithm is the idea of exploring future hypothetical board states. Essentially, we’re saying if we were to make this move, what would happen. As a result, as we’re implementing this algorithm in our code, we don’t want to actually make our move on the board. We want to make a copy of the board and make the move on that one.
Let’s look at how copying works in Python. Let’s say we have a board that looks like this
my_board = [ ["X", "2", "3"], ["O", "O", "6"], ["X", "8", "9"] ]
If we want to create a copy of our board our first instinct might be to do something like this
new_board = my_board
This won’t work the way we want it to! Python objects are saved in memory, and variables point to a location in memory. In this case, new_board
, and my_board
are two variables that point to the same object in memory. If you change a value in one, it will change in the other because they’re both pointing to the same object.
One way to solve this problem is to use the deepcopy()
function from Python’s copy
library.
new_board = deepcopy(my_board)
new_board
is now a copy of my_board
in a different place in memory. When we change a value in new_board
, the values in my_board
will stay the same!
Instructions
Let’s begin by failing to create a deep copy of my_board
. Create a variable named new_board
and set it equal to my_board
.
Call the select_space()
function using new_board
as a parameter to put an "O"
in the center of the board. Print out both new_board
and my_board
using print_board()
to see if making a move on the new board affected the old board.
Change how you create new_board
. Set it equal to deepcopy(my_board)
. What happens when you call select_space()
now?