Professional project
Python code solution and explanation

Introduction

Tic tac toe is a classic paper-pencil game played among young children across the world, and it’s widely known for its simple rules. It is played by marking an X or an O on a 3×3 grid. The first person to mark three of their signs in a vertical, horizontal, or diagonal row, wins the game. 

But today, we will be making a text-based tic tac toe game in Python, for you to enjoy with your friends and family!

Step Breakdown

Let’s break this game down into smaller steps.

1. Making the board and displaying it
2. Playing the game
3. Checking win
4. Checking tie
5. Flipping player

With this overview, we broadly know what to do and check each item while making our game. 

solution

So, I would say the whole program revolves around the board, and you’ll see why. The best way to make the board will be to use a dictionary (aka hashmap). We can make each position on the board a key-value pair, so if we call on the position of the board, we will receive the value stored inside. For each position on the board, we can make it an underscore starting off.

board = {
   1: "_",
   2: "_",
   3: "_",
   4: "_",
   5: "_",
   6: "_",
   7: "_",
   8: "_",
   9: "_",
}

For this project, the board positions will be numbered like this.

Now how will we display the board? Since we know we’ll have to display the board every turn, we can save it in a function. Inside, it’ll print a new line to distinguish the turns. Then, we can print the 3×3 grid. All we have to do is for each position, call on board and the position (eg. board[1]). This will output the value stored in that position. Starting off, all of the values will be underscores, but as we progress, there will be X’s and O’s saved in these positions.

def print_board():
   print("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
   print(f"{board[1]}  |  {board[2]}  |  {board[3]}")
   print(f"--------------")
   print(f"{board[4]}  |  {board[5]}  |  {board[6]}")
   print(f"--------------")
   print(f"{board[7]}  |  {board[8]}  |  {board[9]}")

Now we have to allow the users to play the game. Starting off, it’ll be X’s turn. We can make turn into a variable, and at the end of the loop, it’ll switch from X to O, and vice versa. We can make a while loop that doesn’t stop until the game is over (either a win or a tie). First, we have to print the board, and we have a special function just for that. Now we want the input from the player, and we can save that to place. Now, what if the player accidentally entered a position that was already taken? We can check to make sure if the position that the player entered is not equal to an underscore (the position is already taken previously). Then we can print a message and ask the player to enter it again. But the player might enter a taken position again, so we’ll have to use a while loop. When that is done and we’ve made sure that the position is not taken, we can change board[place] to equal turn (player’s sign), so that the next time the board is displayed, the underscore will be replaced by the player’s sign. 

turn = "X"
game_over = False
 
while not game_over:
   print_board()
 
   place = int(input(f"{turn}'s turn: "))
   while board[place] != "_":
       place = int(input(f"Whoops! That place is already taken, {turn}. Try that again: "))
 
   board[place] = turn

Once the player has taken his turn, we have to check for a winning scenario. We can make a function that simply returns if out of 8 possible winning combinations, one is true.

def check_winner():
   return ((board[1] == board[2] == board[3] == turn) or  # top row
           (board[4] == board[5] == board[6] == turn) or  # middle row
           (board[7] == board[8] == board[9] == turn) or  # bottom row
           (board[1] == board[4] == board[7] == turn) or  # first column
           (board[2] == board[5] == board[8] == turn) or  # second column
           (board[3] == board[6] == board[9] == turn) or  # third column
           (board[1] == board[5] == board[9] == turn) or  # left diagonal
           (board[3] == board[5] == board[7] == turn))    # right diagonal

But wait, after the player’s turn, it’s also possible that there’s a tie, and the whole board has been covered. We can make another function for that. It simply checks if all of the positions don’t have an underscore in them, meaning they’re all taken up by X’s and O’s.

def check_tie():
   return board[1] != "_" and board[2] != "_" and board[3] != "_" and
 board[4] != "_" and board[5] != "_" and board[6] != "_" and board[7] != "_" and board[8] != "_" and board[9] != "_"

Since both functions return either true or false, we can put it in an if statement, and check if they’re true. If there is a winner or a tie, we print the board one last time and give a small message. Then we can set game_over to True so the while loop doesn’t run again, and the program stops. 

   if check_winner():
       print_board()
       print(f"Good job! {turn} won!")
       game_over = True
   if check_tie():
       print_board()
       print("Woah, it's a tie.")
       game_over = True

In the end, we need a way to switch turns, from X to O, and vice versa. We can use an if-else statement which flips the turn. And that should be the end of our code.

   if turn == "X":
       turn = "O"
   elif turn == "O":
       turn = "X"

final code

To view my full code, please visit my GitHub repository:
https://github.com/Gursehaj-Singh/tic-tac-toe

board = {
   1: "_",
   2: "_",
   3: "_",
   4: "_",
   5: "_",
   6: "_",
   7: "_",
   8: "_",
   9: "_",
}
 
 
def print_board():
   print("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
   print(f"{board[1]}  |  {board[2]}  |  {board[3]}")
   print(f"--------------")
   print(f"{board[4]}  |  {board[5]}  |  {board[6]}")
   print(f"--------------")
   print(f"{board[7]}  |  {board[8]}  |  {board[9]}")
 
 
def check_winner():
   return ((board[1] == board[2] == board[3] == turn) or  # top row
           (board[4] == board[5] == board[6] == turn) or  # middle row
           (board[7] == board[8] == board[9] == turn) or  # bottom row
           (board[1] == board[4] == board[7] == turn) or  # first column
           (board[2] == board[5] == board[8] == turn) or  # second column
           (board[3] == board[6] == board[9] == turn) or  # third column
           (board[1] == board[5] == board[9] == turn) or  # left diagonal
           (board[3] == board[5] == board[7] == turn))    # right diagonal
 
 
def check_tie():
   return board[1] != "_" and board[2] != "_" and board[3] != "_" and \
          board[4] != "_" and board[5] != "_" and board[6] != "_" and \
          board[7] != "_" and board[8] != "_" and board[9] != "_"
 
 
turn = "X"
game_over = False
 
while not game_over:
   print_board()
 
   place = int(input(f"{turn}'s turn: "))
   while board[place] != "_":
       place = int(input(f"Whoops! That place is already taken, {turn}. Try that again: "))
 
   board[place] = turn
 
   if check_winner():
       print_board()
       print(f"Good job! {turn} won!")
       game_over = True
   if check_tie():
       print_board()
       print("Woah, it's a tie.")
       game_over = True
 
   if turn == "X":
       turn = "O"
   elif turn == "O":
       turn = "X"

example run

~~~~~~~~~~~~~~~~~~~~~~~~~~~~
_  |  _  |  _
--------------
_  |  _  |  _
--------------
_  |  _  |  _
X's turn: 1
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
X  |  _  |  _
--------------
_  |  _  |  _
--------------
_  |  _  |  _
O's turn: 5
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
X  |  _  |  _
--------------
_  |  O  |  _
--------------
_  |  _  |  _
X's turn: 9
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
X  |  _  |  _
--------------
_  |  O  |  _
--------------
_  |  _  |  X
O's turn: 7
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
X  |  _  |  _
--------------
_  |  O  |  _
--------------
O  |  _  |  X
X's turn: 3
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
X  |  _  |  X
--------------
_  |  O  |  _
--------------
O  |  _  |  X
O's turn: 2
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
X  |  O  |  X
--------------
_  |  O  |  _
--------------
O  |  _  |  X
X's turn: 6
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
X  |  O  |  X
--------------
_  |  O  |  X
--------------
O  |  _  |  X
Good job! X won!