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,
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
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!
Let’s begin by failing to create a deep copy of
my_board. Create a variable named
new_board and set it equal to
select_space() function using
new_board as a parameter to put an
"O" in the center of the board. Print out both
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