tic tac toe in python

3 min read 19-10-2024

Tic-Tac-Toe: A Python Programming Adventure

Tic-Tac-Toe, a classic game of strategy and wit, can be easily brought to life with Python programming. This article will guide you through the process of creating a playable Tic-Tac-Toe game using Python, drawing inspiration from the wisdom of the GitHub community.

Setting the Stage: Representing the Game

Let's start by defining how we'll represent the Tic-Tac-Toe board in Python. One common approach is using a list of lists, as demonstrated by GitHub user CodeMonkey:

board = [[" " for _ in range(3)] for _ in range(3)]

This creates a 3x3 list where each element initially represents an empty space (" ").

Player's Turn: Input and Validation

We need a way for players to input their moves. The code below, adapted from a GitHub repository by GameDev, takes player input and validates it:

def get_player_move(player):
    while True:
        try:
            row, col = map(int, input(f"Player {player}, enter your move (row, col): ").split(","))
            if 0 <= row <= 2 and 0 <= col <= 2 and board[row][col] == " ":
                return row, col
            else:
                print("Invalid move. Please try again.")
        except ValueError:
            print("Invalid input. Please enter two numbers separated by a comma.")

This function prompts the player to enter their move as a row and column number, ensuring the input is within the board boundaries and the selected cell is empty.

Checking for Wins: The Logic Behind the Game

The core of Tic-Tac-Toe lies in determining if a player has won. The following code snippet, inspired by TicTacToeGuru, checks for wins across rows, columns, and diagonals:

def check_win(player):
    # Check rows
    for i in range(3):
        if board[i][0] == player and board[i][1] == player and board[i][2] == player:
            return True
    # Check columns
    for i in range(3):
        if board[0][i] == player and board[1][i] == player and board[2][i] == player:
            return True
    # Check diagonals
    if board[0][0] == player and board[1][1] == player and board[2][2] == player:
        return True
    if board[0][2] == player and board[1][1] == player and board[2][0] == player:
        return True
    return False

This function iterates through rows, columns, and diagonals to see if any are filled with the same player's symbol.

The Game Loop: Bringing it All Together

Finally, we need to combine all the components into a game loop:

def play_game():
    current_player = "X"
    while True:
        print_board(board)
        row, col = get_player_move(current_player)
        board[row][col] = current_player
        if check_win(current_player):
            print_board(board)
            print(f"Player {current_player} wins!")
            break
        if all(cell != " " for row in board for cell in row):
            print_board(board)
            print("It's a draw!")
            break
        current_player = "O" if current_player == "X" else "X"

# Function to print the board (omitted for brevity)

This loop continues until a player wins or the board is full, switching between players with each turn.

Additional Considerations

This basic implementation can be further enhanced by adding features like:

A graphical user interface (GUI): Libraries like Tkinter or Pygame can be used to create a visually appealing game interface.
Computer opponent: You can implement an AI that chooses moves strategically, providing more challenging gameplay.
Multiplayer functionality: Allow two players to compete against each other over a network.

By integrating ideas from GitHub, this article demonstrates how to create a functional Tic-Tac-Toe game in Python.

Remember: Explore GitHub for more advanced Tic-Tac-Toe implementations, learn from other developers' code, and experiment to create your own unique game variations!