Table of Contents
- Introduction
- Prerequisites
- Setting Up the Game Board
- Taking Turns
- Checking for a Winner
- Playing the Game
- Conclusion
Introduction
In this tutorial, we will learn how to create a simple Tic Tac Toe game using Python. Tic Tac Toe, also known as Noughts and Crosses, is a classic game played on a grid of 3x3 squares. The goal of the game is to form a line of three identical symbols (either X or O) vertically, horizontally, or diagonally.
By the end of this tutorial, you will have a functioning Tic Tac Toe game that you can play in the command line.
Prerequisites
To follow along with this tutorial, you should have a basic understanding of the Python programming language. It would be helpful to know about lists, loops, and basic control flow in Python.
You will also need to have Python installed on your computer. You can download Python from the official website and follow the installation instructions for your operating system.
Setting Up the Game Board
Let’s start by setting up the game board. We’ll represent the game board as a list of lists, where each inner list represents a row on the grid. We’ll use the characters ‘X’, ‘O’, and ‘ ‘ (space) to represent the player symbols and empty squares, respectively.
python
board = [
[' ', ' ', ' '],
[' ', ' ', ' '],
[' ', ' ', ' ']
]
To display the game board, we can define a function called display_board:
python
def display_board(board):
for row in board:
print('|'.join(row))
print('-' * 5)
This function iterates over each row in the board and joins the symbols with vertical bars. It also prints a line of dashes after each row to separate them.
Taking Turns
Next, we need to implement the logic for taking turns. We’ll use a variable called current_player to keep track of the current player. The variable will be initialized to either ‘X’ or ‘O’ at the start of the game.
We can create a function called switch_players to alternate the value of current_player between ‘X’ and ‘O’:
python
def switch_players(current_player):
return 'O' if current_player == 'X' else 'X'
To take a turn, we’ll prompt the current player to enter their move. The player will input the row and column numbers where they want to place their symbol. We’ll validate the input to ensure it’s within the range of the board and the corresponding square is empty.
Using a loop, we can continue to prompt the player for input until they provide a valid move. Once a valid move is made, we’ll update the game board with the player’s symbol.
Let’s define a function called take_turn to handle this logic:
```python
def take_turn(board, current_player):
while True:
row = int(input(“Enter the row number (0-2): “))
col = int(input(“Enter the column number (0-2): “))
if 0 <= row <= 2 and 0 <= col <= 2 and board[row][col] == ' ':
board[row][col] = current_player
break
else:
print("Invalid move. Try again.")
``` ## Checking for a Winner
After each turn, we need to check if the current player has won the game. To do this, we’ll define a function called check_winner that checks all possible winning combinations.
There are eight possible winning combinations in Tic Tac Toe: three horizontal lines, three vertical lines, and two diagonal lines. We’ll iterate over each of these combinations and check if the symbols match.
Here’s a possible implementation of the check_winner function:
```python
def check_winner(board, symbol):
# Check rows
for row in board:
if row.count(symbol) == 3:
return True
# Check columns
for col in range(3):
if board[0][col] == board[1][col] == board[2][col] == symbol:
return True
# Check diagonals
if board[0][0] == board[1][1] == board[2][2] == symbol or \
board[0][2] == board[1][1] == board[2][0] == symbol:
return True
return False
``` ## Playing the Game
Now that we have all the necessary functions, we can put everything together and start playing the game.
We’ll define a main function called play_game that handles the game loop. This function will alternate between players and call the take_turn and check_winner functions accordingly.
Here’s an example implementation of the play_game function:
```python
def play_game():
board = [
[’ ‘, ‘ ‘, ‘ ‘],
[’ ‘, ‘ ‘, ‘ ‘],
[’ ‘, ‘ ‘, ‘ ‘]
]
current_player = ‘X’
while True:
display_board(board)
take_turn(board, current_player)
if check_winner(board, current_player):
print(f"Player {current_player} wins!")
break
current_player = switch_players(current_player)
``` To start the game, simply call the `play_game` function:
```python
play_game()
``` ## Conclusion
Congratulations! You have successfully created a simple Tic Tac Toe game in Python. Throughout this tutorial, we learned how to set up the game board, take turns, check for a winner, and play the game.
Feel free to enhance the game by adding additional features, such as checking for a draw or implementing a graphical user interface.
You can now apply your knowledge of Python to create other interactive games and explore more complex programming concepts.