Xo Game In Python | Condition For Wiining

Playing computer games is a great way to unwind or challenge yourself. Some people even do it professionally. It’s also fun and educational to build your own computer games. In this tutorial, you’ll build a classic tic-tac-toe game using Python and Tkinter.

With this project, you’ll go through the thought processes required for creating your own game. You’ll also learn how to integrate your diverse programming skills and knowledge to develop a functional and fun computer game.

In this tutorial, you’ll learn how to:

• Program the classic tic-tac-toe game’s logic using Python
• Create the game’s graphical user interface (GUI) using the Tkinter tool kit
• Integrate the game’s logic and GUI into a fully functional computer game

As mentioned, you’ll be using the Tkinter GUI framework from the Python standard library to create your game’s interface. You’ll also use the model-view-controller pattern and an object-oriented approach to organize your code. For more on these concepts, check out the links in the prerequisites.

To download the entire source code for this project, click the link in the box below:

Get Source Code: Click here to get access to the source code that you’ll use to build your tic-tac-toe game.

Rules of Game

1. Traditionally the first player plays with “X”. So you can decide who wants to go with “X” and who wants to go with “O”.
2. Only one player can play at a time.
3. If any of the players have filled a square, then the other player and the same player cannot override that square.
4. There are only two conditions that may match will be a draw or may win.
5. The player who succeeds in placing three respective marks (X or O) in a horizontal, vertical, or diagonal row wins the game.

Requirements

The requirement for building the tic tac toe python are listed below:

• Good knowledge of Python Basics and refreshing the topics as mentioned under the subheading Pre-requisites.
• Command line Interface or any local Terminal to build the tic tac toe python.
• Text editor: We can use either VSCode Python 3 installed on your machine or we can implement the source code with any Python online compiler as well.

Demo: A Tic-Tac-Toe Game in Python

In this step-by-step project, you’ll build a tic-tac-toe game in Python. You’ll use the Tkinter tool kit from the Python standard library to create the game’s GUI. In the following demo video, you’ll get a sense of how your game will work once you’ve completed this tutorial:

Your tic-tac-toe game will have an interface that reproduces the classic three-by-three game board. The players will take turns making their moves on a shared device. The game display at the top of the window will show the name of the player who gets to go next.

If a player wins, then the game display will show a winning message with the player’s name or mark (X or O). At the same time, the winning combination of cells will be highlighted on the board.

Finally, the game’s File menu will have options to reset the game if you want to play again or to exit the game when you’re done playing.

If this sounds like a fun project to you, then read on to get started!

Prerequisites

To complete this tic-tac-toe game project, you should be comfortable or at least familiar with the concepts and topics covered in the following resources:

• Python GUI Programming With Tkinter
• Object-Oriented Programming (OOP) in Python 3
• Python “for” Loops (Definite Iteration)
• When to Use a List Comprehension in Python
• Model-View-Controller (MVC) Explained – With Legos
• Dictionaries in Python
• How to Iterate Through a Dictionary in Python
• Main Functions in Python
• Write Pythonic and Clean Code With namedtuple

If you don’t have all of the suggested knowledge before starting this tutorial, that’s okay. You’ll learn by doing, so go ahead and give it a whirl! You can always stop and review the resources linked here if you get stuck.

Step 1: Set Up the Tic-Tac-Toe Game Board With Tkinter

To kick things off, you’ll start by creating the game board. Before doing this, you need to decide how to organize the code for your tic-tac-toe game. Because this project will be fairly small, you can initially keep all the code in a single

.py

file. This way, running the code and executing your game will be more straighforward.

Go ahead and fire up your favorite code editor or IDE. Then create a

tic_tac_toe.py

file in your current working directory:


# tic_tac_toe.py """A tic-tac-toe game built with Python and Tkinter."""


Throughout this tutorial, you’ll be incrementally adding code to this file, so keep it open and near. If you want to get the entire code for this tic-tac-toe game project, then you can click the following collapsible section and copy the code from it:


"""A tic-tac-toe game built with Python and Tkinter.""" import tkinter as tk from itertools import cycle from tkinter import font from typing import NamedTuple class Player(NamedTuple): label: str color: str class Move(NamedTuple): row: int col: int label: str = "" BOARD_SIZE = 3 DEFAULT_PLAYERS = ( Player(label="X", color="blue"), Player(label="O", color="green"), ) class TicTacToeGame: def __init__(self, players=DEFAULT_PLAYERS, board_size=BOARD_SIZE): self._players = cycle(players) self.board_size = board_size self.current_player = next(self._players) self.winner_combo = [] self._current_moves = [] self._has_winner = False self._winning_combos = [] self._setup_board() def _setup_board(self): self._current_moves = [ [Move(row, col) for col in range(self.board_size)] for row in range(self.board_size) ] self._winning_combos = self._get_winning_combos() def _get_winning_combos(self): rows = [ [(move.row, move.col) for move in row] for row in self._current_moves ] columns = [list(col) for col in zip(*rows)] first_diagonal = [row[i] for i, row in enumerate(rows)] second_diagonal = [col[j] for j, col in enumerate(reversed(columns))] return rows + columns + [first_diagonal, second_diagonal] def toggle_player(self): """Return a toggled player.""" self.current_player = next(self._players) def is_valid_move(self, move): """Return True if move is valid, and False otherwise.""" row, col = move.row, move.col move_was_not_played = self._current_moves[row][col].label == "" no_winner = not self._has_winner return no_winner and move_was_not_played def process_move(self, move): """Process the current move and check if it's a win.""" row, col = move.row, move.col self._current_moves[row][col] = move for combo in self._winning_combos: results = set(self._current_moves[n][m].label for n, m in combo) is_win = (len(results) == 1) and ("" not in results) if is_win: self._has_winner = True self.winner_combo = combo break def has_winner(self): """Return True if the game has a winner, and False otherwise.""" return self._has_winner def is_tied(self): """Return True if the game is tied, and False otherwise.""" no_winner = not self._has_winner played_moves = ( move.label for row in self._current_moves for move in row ) return no_winner and all(played_moves) def reset_game(self): """Reset the game state to play again.""" for row, row_content in enumerate(self._current_moves): for col, _ in enumerate(row_content): row_content[col] = Move(row, col) self._has_winner = False self.winner_combo = [] class TicTacToeBoard(tk.Tk): def __init__(self, game): super().__init__() self.title("Tic-Tac-Toe Game") self._cells = {} self._game = game self._create_menu() self._create_board_display() self._create_board_grid() def _create_menu(self): menu_bar = tk.Menu(master=self) self.config(menu=menu_bar) file_menu = tk.Menu(master=menu_bar) file_menu.add_command(label="Play Again", command=self.reset_board) file_menu.add_separator() file_menu.add_command(label="Exit", command=quit) menu_bar.add_cascade(label="File", menu=file_menu) def _create_board_display(self): display_frame = tk.Frame(master=self) display_frame.pack(fill=tk.X) self.display = tk.Label( master=display_frame, text="Ready?", font=font.Font(size=28, weight="bold"), ) self.display.pack() def _create_board_grid(self): grid_frame = tk.Frame(master=self) grid_frame.pack() for row in range(self._game.board_size): self.rowconfigure(row, weight=1, minsize=50) self.columnconfigure(row, weight=1, minsize=75) for col in range(self._game.board_size): button = tk.Button( master=grid_frame, text="", font=font.Font(size=36, weight="bold"), fg="black", width=3, height=2, highlightbackground="lightblue", ) self._cells[button] = (row, col) button.bind("

", self.play) button.grid(row=row, column=col, padx=5, pady=5, sticky="nsew") def play(self, event): """Handle a player's move.""" clicked_btn = event.widget row, col = self._cells[clicked_btn] move = Move(row, col, self._game.current_player.label) if self._game.is_valid_move(move): self._update_button(clicked_btn) self._game.process_move(move) if self._game.is_tied(): self._update_display(msg="Tied game!", color="red") elif self._game.has_winner(): self._highlight_cells() msg = f'Player "{self._game.current_player.label}" won!' color = self._game.current_player.color self._update_display(msg, color) else: self._game.toggle_player() msg = f"{self._game.current_player.label}'s turn" self._update_display(msg) def _update_button(self, clicked_btn): clicked_btn.config(text=self._game.current_player.label) clicked_btn.config(fg=self._game.current_player.color) def _update_display(self, msg, color="black"): self.display["text"] = msg self.display["fg"] = color def _highlight_cells(self): for button, coordinates in self._cells.items(): if coordinates in self._game.winner_combo: button.config(highlightbackground="red") def reset_board(self): """Reset the game's board to play again.""" self._game.reset_game() self._update_display(msg="Ready?") for button in self._cells.keys(): button.config(highlightbackground="lightblue") button.config(text="") button.config(fg="black") def main(): """Create the game's board and run its main loop.""" game = TicTacToeGame() board = TicTacToeBoard(game) board.mainloop() if __name__ == "__main__": main()



Having the entire source code beforehand will allow you to check your progress while going through the tutorial.

Alternatively, you can also download the game source code from GitHub by clicking the link in the box below:

Get Source Code: Click here to get access to the source code that you’ll use to build your tic-tac-toe game.

Now that you know what the game’s final code will look like, it’s time to make sure you have the right Tkinter version for this project. Then, you’ll go ahead and create your game board.

Ensure the Right Tkinter Version

To complete this project, you’ll use a standard Python installation. There’s no need to create a virtual environment because no external dependency is required. The only package that you’ll need is Tkinter, which comes with the Python standard library.

However, you need to make sure that you have the right Tkinter version installed. You should have Tkinter greater than or equal to 8.6. Otherwise, your game won’t work.

You can check your current Tkinter version by starting a Python interactive session and running the following code:


>>> import tkinter >>> tkinter.TkVersion 8.6


If this code doesn’t show a version greater than or equal to 8.6 for your Tkinter installation, then you’ll need to fix that.

On Ubuntu Linux, you may need to install the

python3-tk

package using the system’s package manager,

apt

. That’s because typically Ubuntu doesn’t include Tkinter in its default Python installation.

Once you have Tkinter properly installed, then you need to check its current version. If the Tkinter version is lower than 8.6, then you’ll have to install a more recent version of Python either by downloading it from the official download page or by using a tool like pyenv or Docker.

On macOS and Windows, a straightforward option is to install a Python version greater than or equal to 3.9.8 from the download page.

Once you’re sure you have the right Tkinter version, you can get back to your code editor and start writing code. You’ll begin with the Python class that’ll represent the tic-tac-toe game board.

Create a Class to Represent the Game Board

To build the board of your tic-tac-toe game, you’ll use the

Tk

class, which allows you to create the main window of your Tkinter app. Then you’ll add a display on a top frame and a grid of cells covering the rest of the main window.

Go ahead and import the required objects and define the board class:


# tic_tac_toe.py import tkinter as tk from tkinter import font class TicTacToeBoard(tk.Tk): def __init__(self): super().__init__() self.title("Tic-Tac-Toe Game") self._cells = {}


In this code snippet, you first import

tkinter

as

tk

to bring the module’s name to your current namespace. Using the

tk

abbreviation is a common practice when it comes to using Tkinter in your code.

Then you import the

font

module directly from

tkinter

. You’ll use this module later in this tutorial to tweak the font of your game display.

The

TicTacToeBoard

class inherits from

Tk

, which makes it a full-fledged GUI window. This window will represent the game board. Inside

.__init__()

, you first call the superclass’s

.__init__()

method to properly initialize the parent class. To do this, you use the built-in super() function.

The

.title

attribute of

Tk

defines the text to show on the window’s title bar. In this example, you set the title to the

"Tic-Tac-Toe Game"

string.

The

._cells

non-public attribute holds an initially empty dictionary. This dictionary will map the buttons or cells on the game board to their corresponding coordinates—row and column—on the grid. These coordinates will be integer numbers reflecting the row and column where a given button will appear.

To continue with the game board, you now need to create a display where you can provide information about the game’s state and result. For this display, you’ll use a

Frame

widget as the display panel and a

Label

widget to show the required information.

Note: The line numbers in the code samples in this tutorial are intended to facilitate the explanation. Most of the time, they won’t match the line numbers in your final script.

Now go ahead and add the following method to your

TicTacToeBoard

class:


1# tic_tac_toe.py 2# ... 3 4class TicTacToeBoard(tk.Tk): 5 # ... 6 7 def _create_board_display(self): 8 display_frame = tk.Frame(master=self) 9 display_frame.pack(fill=tk.X) 10 self.display = tk.Label( 11 master=display_frame, 12 text="Ready?", 13 font=font.Font(size=28, weight="bold"), 14 ) 15 self.display.pack()


Here’s a breakdown of what this method does line by line:

• Line 8 creates a

  
Frame

  object to hold the game display. Note that the
  
master

  argument is set to
  
self

  , which means that the game’s main window will be the frame’s parent.

• Line 9 uses the

  
.pack()

  geometry manager to place the frame object on the main window’s top border. By setting the
  
fill

  argument to
  
tk.X

  , you ensure that when the user resizes the window, the frame will fill its entire width.

• Lines 10 to 14 create a

  
Label

  object. This label needs to live inside the frame object, so you set its
  
master

  argument to the actual frame. The label will initially show the text
  
"Ready?"

  , which indicates that the game is ready to go, and the players can start a new match. Finally, you change the label’s font size to
  
28

  pixels and make it bold.

• Line 15 packs the display label inside the frame using the

  
.pack()

  geometry manager.

Cool! You already have the game display. Now you can create the grid of cells. A classic tic-tac-toe game has a three-by-three grid of cells.

Here’s a method that creates the grid of cells using

Button

objects:


1# tic_tac_toe.py 2# ... 3 4class TicTacToeBoard(tk.Tk): 5 # ... 6 7 def _create_board_grid(self): 8 grid_frame = tk.Frame(master=self) 9 grid_frame.pack() 10 for row in range(3): 11 self.rowconfigure(row, weight=1, minsize=50) 12 self.columnconfigure(row, weight=1, minsize=75) 13 for col in range(3): 14 button = tk.Button( 15 master=grid_frame, 16 text="", 17 font=font.Font(size=36, weight="bold"), 18 fg="black", 19 width=3, 20 height=2, 21 highlightbackground="lightblue", 22 ) 23 self._cells[button] = (row, col) 24 button.grid( 25 row=row, 26 column=col, 27 padx=5, 28 pady=5, 29 sticky="nsew" 30 )


Wow! This method does a lot! Here’s an explanation of what each line does:

• Line 8 creates a

  
Frame

  object to hold the game’s grid of cells. You set the
  
master

  argument to
  
self

  , which again means that the game’s main window will be the parent of this frame object.

• Line 9 uses the

  
.pack()

  geometry manager to place the frame object on the main window. This frame will occupy the area under the game display, all the way to the bottom of the window.

• Line 10 starts a loop that iterates from

  to. These numbers represent the row coordinates of each cell in the grid. For now, you’ll haverows on the grid. However, you’ll change this magic number later and provide the option of using a different grid size, such as four by four.

• Line 11 and 12 configure the width and minimum size of every cell on the grid.

• Line 13 loops over the three column coordinates. Again you use three columns, but you’ll change this number later to provide more flexibility and get rid of magic numbers.

• Lines 14 to 22 create a

  
Button

  object for every cell on the grid. Note that you set several attributes, including
  
master

  ,
  
text

  ,
  
font

  , and so on.

• Line 23 adds every new button to the

  
._cells

  dictionary. The buttons work as keys, and their coordinates—expressed as
  
(row, col)

  —work as values.

• Lines 24 to 30 finally add every button to the main window using the

  
.grid()

  geometry manager.

Now that you’ve implemented

._create_board_display()

and

._create_board_grid()

, you can call them from the class initializer. Go ahead and add the following two lines to

.__init__()

in your

TicTacToeBoard

class:


# tic_tac_toe.py # ... class TicTacToeBoard(tk.Tk): def __init__(self): super().__init__() self.title("Tic-Tac-Toe Game") self._cells = {} self._create_board_display() self._create_board_grid()


These two lines put together the game board by adding the display and grid of cells. Isn’t that cool?

With these updates, you can almost run your app and see how your tic-tac-toe game will look. You just need to write a few more lines of boilerplate code. You need to instantiate

TicTacToeBoard

and call its

.mainloop()

method to launch your Tkinter app.

Go ahead and add the following piece of code to the end of your

tic_tac_toe.py

file:


# tic_tac_toe.py # ... def main(): """Create the game's board and run its main loop.""" board = TicTacToeBoard() board.mainloop() if __name__ == "__main__": main()


This code snippet defines a

main()

function for your game. Inside this function, you first instantiate

TicTacToeBoard

and then run its main loop by calling

.mainloop()

.

The

if __name__ == "__main__":

construct is a common pattern in Python applications. It allows you to control the execution of your code. In this case, the call to

main()

will only happen if you run the

.py

file as an executable program, as opposed to an importable module.

That’s it! You’re now ready to run your game for the first time. Of course, the game isn’t playable yet, but the board is ready. To run the game, go ahead and execute the following command on your command line:


$ python tic_tac_toe.py


Once you’ve run this command, then you’ll get the following window on your screen:

Cool! Your tic-tac-toe game is starting to look like the real thing. Now you need to make this window respond to the players’ actions on the board.

Project Overview

Your goal with this project is to create a tic-tac-toe game in Python. For the game interface, you’ll use the Tkinter GUI tool kit, which comes in the standard Python installation as an included battery.

The tic-tac-toe game is for two players. One player plays X and the other plays O. The players take turns placing their marks on a grid of three-by-three cells. If a given player gets three marks in a row horizontally, vertically, or diagonally, then that player wins the game. The game will be tied if no one gets three in a row by the time all the cells are marked.

With these rules in mind, you’ll need to put together the following game components:

• The game’s board, which you’ll build with a class called
  
TicTacToeBoard

• The game’s logic, which you’ll manage using a class called
  
TicTacToeGame


The game board will work as a mix between view and controller in a model-view-controller design. To build the board, you’ll use a Tkinter window, which you can create by instantiating the

tkinter.Tk

class. This window will have two main components:

1. Top display: Shows information about the game’s status
2. Grid of cells: Represents previous moves and available spaces or cells

You’ll create the game display using a

tkinter.Label

widget, which allows you to display text and images.

For the grid of cells, you’ll use a series of

tkinter.Button

widgets arranged in a grid. When a player clicks one of these buttons, the game logic will run to process the player’s move and determine whether there’s a winner. In this case, the game logic will work as the model, which will manage the data, logic, and rules of your game.

Now that you have a general idea of how to build your tic-tac-toe game, you should check out a few knowledge prerequisites that’ll allow you to get the most out of this tutorial.

Step 5: Provide Options to Play Again and Exit the Game

In this section, you’ll provide your tic-tac-toe game with a main menu. This menu will have an option to restart the game so that the players can start another match. It’ll also have an option to exit the game once the players have finished playing.

Main menus are often an essential component of many GUI applications. So, learning how to create them in Tkinter is a good exercise to improve your GUI-related skills beyond the game development itself.

This is an example of how building your own games is a powerful learning experience because it allows you to integrate knowledge and skills that you can later use in other non-game projects.

The complete source code for this step is available for download. Just click the link below and navigate to the

source_code_step_5/

folder:

Get Source Code: Click here to get access to the source code that you’ll use to build your tic-tac-toe game.

Build the Game’s Main Menu

To add a main menu to a Tkinter application, you can use the

tkinter.Menu

class. This class allows you to create a menu bar on top of your Tkinter window. It also allows you to add dropdown menus to the menu bar.

Here’s the code that creates and adds a main menu to your tic-tac-toe game:


1# tic_tac_toe.py 2# ... 3 4class TicTacToeBoard(tk.Tk): 5 def __init__(self, game): 6 # ... 7 8 def _create_menu(self): 9 menu_bar = tk.Menu(master=self) 10 self.config(menu=menu_bar) 11 file_menu = tk.Menu(master=menu_bar) 12 file_menu.add_command( 13 label="Play Again", 14 command=self.reset_board 15 ) 16 file_menu.add_separator() 17 file_menu.add_command(label="Exit", command=quit) 18 menu_bar.add_cascade(label="File", menu=file_menu)


Here’s what this code does line by line:

• Line 8 defines a helper method called

  
._create_menu()

  to handle the menu creation in a single place.

• Line 9 creates an instance of

  
Menu

  , which will work as the menu bar.

• Line 10 sets the menu bar object as the main menu of your current Tkinter window.

• Line 11 creates another instance of

  
Menu

  to provide a File menu. Note that the
  
master

  argument in the class constructor is set to your menu bar object.

• Lines 12 to 15 add a new menu option to the File menu using the

  
.add_command()

  method. This new option will have the label
  
"Play Again"

  . When a user clicks this option, the application will run the
  
.reset_board()

  method, which you provided through the
  
command

  argument. You’ll write this method in the following section.

• Line 16 adds a menu separator using the

  
.add_separator()

  method. Separators are useful when you need to separate groups of related commands in a given dropdown menu.

• Line 17 adds an Exit command to the File menu. This command will make the game exit by calling the

  
quit()

  function.

• Line 18 finally adds the File menu to the menu bar by calling

  
.add_cascade()

  with appropriate arguments.

To actually add the main menu to your game’s main window, you need to call

._create_menu()

from the initializer of

TicTacToeBoard

. So, go ahead and add the following line to the class’s

.__init__()

method:


# tic_tac_toe.py # ... class TicTacToeBoard(tk.Tk): def __init__(self, game): super().__init__() self.title("Tic-Tac-Toe Game") self._cells = {} self._game = game self._create_menu() self._create_board_display() self._create_board_grid() # ...


With this final update, your game’s main menu is almost ready for use. However, before using it, you must implement the

.reset_board()

method. That’s what you’ll do in the following section in order to allow the players to play again.

Implement the Play Again Option

To reset the game board and allow the players to play again, you need to add code to both classes,

TicTacToeGame

and

TicTacToeBoard

.

In the game logic class, you need to reset the

._current_moves

attribute to hold a list of initially empty

Move

objects. You also need to reset the

._has_winner

and

.winner_combo

to their initial state. On the other hand, in the game board class, you need to reset the board display and cells to their initial state.

Get back to

TicTacToeGame

in your code editor and add the following method right at the end of the class:


# tic_tac_toe.py # ... class TicTacToeGame(tk.Tk): # ... def reset_game(self): """Reset the game state to play again.""" for row, row_content in enumerate(self._current_moves): for col, _ in enumerate(row_content): row_content[col] = Move(row, col) self._has_winner = False self.winner_combo = []


The

for

loop in

.reset_game()

sets all the current moves to an empty

Move

object. An empty move’s main characteristic is that its

.label

attribute holds the empty string,

""

.

After updating the current moves, the methods sets

._has_winner

to

False

and

.winner_combo

to an empty list. These three resets ensure that the game’s abstract representation is ready to start a new match.

Note that

reset_game()

doesn’t reset the player back to X when preparing the game for a new match. Typically, the winner of the previous match gets to go first in the next one. So, there’s no need to reset the player here.

Once you’ve provided the required new functionality in the game logic, then you’re ready to update the game board functionality. Go ahead and add the following method to the end of

TicTacToeBoard

:


1# tic_tac_toe.py 2# ... 3 4class TicTacToeBoard(tk.Tk): 5 # ... 6 7 def reset_board(self): 8 """Reset the game's board to play again.""" 9 self._game.reset_game() 10 self._update_display(msg="Ready?") 11 for button in self._cells.keys(): 12 button.config(highlightbackground="lightblue") 13 button.config(text="") 14 button.config(fg="black")


This

.reset_board()

method works as follows:

• Line 9 calls

  
.reset_game()

  to reset the board’s abstract representation.

• Line 10 updates the board display to hold the initial text,

  
"Ready?"

  .

• Line 11 starts a loop over the buttons on the board grid.

• Lines 12 to 14 restore every button’s

  
highlightbackground

  ,
  
text

  , and
  
fg

  properties to their initial state.

That’s it! With this last feature, your tic-tac-toe game project is complete. Go ahead and give it a try!

Next Steps

The tic-tac-toe game that you implemented in this tutorial is fairly bare-bones. However, you can expand it in several different and fun ways. Some ideas to take this game project to the next level include allowing your users to:

• Use a different game board size
• Play against the computer

What other ideas can you come up with to extend this project? Be creative and have fun!

Now that you’ve completed this project, here are some additional great projects to continue building your own games with Python:

• Make Your First Python Game: Rock, Paper, Scissors!: In this tutorial, you’ll learn to program rock paper scissors in Python from scratch. You’ll learn how to take in user input, make the computer choose a random action, determine a winner, and split your code into functions.

• PyGame: A Primer on Game Programming in Python: In this step-by-step tutorial, you’ll learn how to use PyGame. This library allows you to create games and rich multimedia programs in Python. You’ll learn how to draw items on your screen, implement collision detection, handle user input, and much more!

• Build an Asteroids Game With Python and Pygame: This article will show you how to create a game in PyGame!

• Arcade: A Primer on the Python Game Framework: This article is a excellent follow-up because it shows you another Python game framework that allows you to create more complex games.

• Build a Platform Game in Python With Arcade: In this step-by-step tutorial, you’ll build a platform game in Python using the arcade library. You’ll cover techniques for designing levels, sourcing assets, and implementing advanced features.

• Build a Tic-Tac-Toe Game Engine With an AI Player in Python: In this step-by-step tutorial, you’ll build a universal game engine in Python with tic-tac-toe rules and two computer players, including an unbeatable AI player using the minimax algorithm.

How to Create a Tic-Tac-Toe Game in Python?

Let us create a simple Tic Tac Toe game in Python. It will help you to build up game logic and understand how to structure code.

Gaming is one of the entertainment that humans have. We can find different types of games on the web, mobile, desktop, etc. We are not here to make one of those heavy games now. We are going to create a CLI tic-tac-toe game using Python.

If you are not familiar with Tic Tac Toe, play it visually here to understand. Don’t worry, even if you don’t understand it, we are going to see it.

Building Tic Tac Toe using Python

Now after understanding the logical flow of the project and refreshing our Python knowledge based on the pre-requisite, let us start to create our tic tac toe Python project step by step.

Step 1: Designing the Tic Tac Toe Python Project:

As discussed in the algorithm before we can start playing the game as we are building our tic tac tor Python game from scratch that too using the command line interface. We need to start by designing a tic tac toe Python program 3X3 gameboard. For doing so, we shall be using the print statements from Python and designing the 9 empty boxes of the game board.

Our prime objective in creating the design of the tic tac toe Python grid function would be that whenever a player needs to mark the box of their choice, then he/she will be inputting the respective digit that is displayed on the grid. For example, if we want to select the first box of the grid on the leftmost corner then we will input 1 in the command line interface.

Code :

Output :

Explanation :

As seen above, we created a function called tictactoe_grid where we implemented the user-defined function knowledge from Python. This function takes values from the user as its parameter. We have used the print function along with the format function to act as the placeholder for the user’s input value. Here the value parameter, signifies the status of each cell of the grid as a list.

Step 2: Using the Data Structure to Store Data

Now to understand the key principles of any game we need to dive deep into the dynamics of that game.

As we are building a relatively simple game, we need to know two important pieces of information that need to be stored so that they can be referred to at any point in time during the game which is as follow:

The Status of Grid: For this we will create a data structure that stores the status for each cell which can be either filled or empty.

The Move of each player: it is always good to store the past and present moves of each player which are the positions occupied by ‘X’ and ‘O’.

Quick Note: We can access the above data from the Status of Grid which requires us to pass over the information every time we need to know the positions of each player. This is generally done by conserving time via the Time versus Space Complexity Trade-off.

Code :

Output :

Explanation :

As seen above, we created a user-defined function game_single for the tic-tac-toe Python game. This function is created for a single game of tic tac toe Python where the value signifies the parameter of the previous function. The variable position_player is used for storing the position of the box that is either filled by the cross (X) or the naught (O). We store three values that help to manage the Grid Status as a list of characters:

‘X’ – This signifies when a cell is occupied by the X Player. ‘O’ – This signifies when a cell is occupied by the O Player. ‘ ‘ – This signifies when a cell is empty or vacant.

To check the player move, we have created the variable position_player where the moves of the players are stored as a dictionary (consisting of a list of integers) where the keys are defined by ‘X’ and ‘O’ for each player.

Quick Note: The player_current variable is used to store the move of the current player as ‘X’ or ‘O’.

Step 3: To Understand the Game-Loop

Understanding the game loop for the tic tac toe Python game allows the player to understand how to play the game until that player wins or a draw happens between the two players. Also, in the tic tac toe Python game, every single move of the player is denoted by the loop iteration.

Code :

Explanation :

To print the values for the function tictactoe_grid(), we have made use of the while loop from Python that helps us to generate the single tic tac toe Python game loop.

To handle the input from the player, we are using the Try-Exception block for ‘CHANCE’ input that can handle the unintended value if provided by the payer as his move during each iteration of the game. We also handled the ValueError exception to resolve if the same error gets encountered and also to maintain the continuity of the game. Finally, we also performed a few sanity checks, to verify if the value given by the player is a valid input or not or if the valid position given is already occupied or not.

Step 4: Updating the Game Information

Now that we have understood the game loop and gathered the inputs from the player, we need to update the information too. We can make our tic tac toe Python game work smoothly by updating the information by concatenating the below-given piece of code into our main game program.

Code :

Output :

Explanation :

Once we call our tictactoe_grid() function, the grid will be as shown above as we now have the value list updated. We updated the status of the grid in addition to the position of the player by updating our game information where we update the boxes that got occupied as per the players which are reflected by the value list. Also, by adding the position just filed by the move of the current player we reflect the position of the player.

Step 5: To Validate the Win or Tie Situation

Now we move towards analyzing the win or tie situation. For that, we need to validate if any player after every move it takes has won the tic tac toe Python game or if the game ended as a tie.

We will be creating two user-defined functions in Python to validate the Win or Tie situation. We name these functions win_validate() and tie_validate().

win_validate(): This function validates if the player has satisfied any of the winning combinations that are stored. If it does, then it shall return TRUE; otherwise, it shall give output as FALSE.

tie_validate(): This is a function that validates if all ‘Nine’ boxes on the grid are filled and the game is ending with a tie.

Code :

Explanation :

As seen above, we created user-defined function (UDF) in Python to define the win_validate() and tie_validate(). We made use of the for loops in Python and if statements to validate if the winning combination to win the game is met or not. Consecutively, while calling both the functions we shall get the respective output if the game is won by any player or it has resulted in a tie. The game_single() function shall return if the current player has won the game or not. Else, the game will return ‘D’ signifying a tie.

Step 6: Switching Between the Player Once the Chance of One Player is Executed

As the tic tac toe Python game is based on an alternate chance being given to each player after one player has played its chance therefore we shall be using the if-else loop in Python now to enable this switching between the players after its chance has been executed.

Code :

Explanation :

We implemented the if-else statement in Python to switch between the player once the chance of one player is executed in a way that when the current player makes its move and takes one position from the grid, then the program must switch the position to the next payer.

Step 7: Recording the Player’s Names to Observe on the Scoreboard

As we are maintaining the scoreboard to see what is the score against each player’s name after they have played multiple matches of the tic tac toe Python game, we will be using the main function in Python to capture and record the Player’s names to observe on the scoreboard at the end of the game.

Code :

Explanation :

Above shows the special variable__name__ that has the value of “main”. We use the input function in Python to provide the names of the two players. This will be captured as soon as the game starts when the entire program for the tic tac toe Python game gets executed.

Step 8: To Capture the Game Information

In the tic tac toe Python game, it’s always important to store the game information so that we are capturing the data related to the current player, the selection between the X or O that the players choose, the available options in the game which is either X or O and the scoreboard information.

Code :

Explanation :

As per the above code, we selected the current player as the first player along with storing the information on the selections made by both players as a dictionary, the available options in the game as a list, and the scoreboard information as a dictionary.

Step 9: To Design the Scoreboard

We shall be designing the Scoreboard as a dictionary data structure to keep a track of multiple games that the players play. here, the players’ names will act as the keys of the dictionary, and their respective wins shall be captured as the values.

Code :

Output :

Explanation :

We used the user-defined function my_scoreboard(score_board) which is taking score_board as the parameter where we define the variable that captures the names of the players in a list using the .keys() function in Python after which we index that as part of our score_board and show the respective scores which here is 0 as this is what shall be visible while the game starts.

As we are our game flexible enough to let the players play multiple games of tic tac toe Python, we shall require another loop for the same where we shall allow the current player to select the mark for each match. The selection menu will also be shown in each iteration of the game.

Code :

Output :

Explanation :

As seen above we implemented the while loop from Python to show the menu and give the current payer which is John here to make the choice for the series of the Tic tac toe Python game. John can now make use of action between the three options Cross ‘X’ or Naught ‘O’ or exit the game by pressing the respective key.

It’s very important to maintain the flow of the game to Handle Exceptions and Allot the selection of the symbol for the current player for each iteration of the game, for which we shall be using the try-exception block in Python as shown in the below code. The selection made by the current player will be captured and evaluated to let them know which player has won the game.

Code :

Explanation :

In the above snippet of code, we have used the try-exception block to handle any exception for the the_choice input. We have then used the if-else statement to create the choice menu for the current player to select from.

As per the selection made by the player, the data will be stored. This is significant as it will tell us which player won after every match.

Step 12: Execution of the Tic Tac Toe Python Game and Updating the Scoreboard Simultaneously

Now we are approaching the final part of our tic tac toe Python game, where we shall be executing an independent game between the two players and capture the win for the player. And as we have our scoreboard ready we shall also be updating it when the first game end as well.

Code :

Explanation :

As seen above, we captured the details of the winner of the tic tac toe Python game for a single match. we also used the if statement in Python to validate if the match is getting a tie or if one of the players is winning the game. If the game is a tie, then again the new match will start else when the game ends in a win the score of the player gets updated and the scoreboard gets updated too.

Step 13: Swapping the Chance Given to Choose the Symbol Between the Selecting Player

It is important to swap the chance given to choose the symbol between the players after each game has ended. While playing a game, it becomes mandatory to switch the chance of choosing the mark. For doing so, we shall be using the if-else statements in Python for letting the players switch the chance of selecting the mark (X or O) once one game has ended so that both the players get an equal chance to choose between the symbol.

Code :

Explanation :

Using the if-else statement in Python we created the possibility of giving each player an equal chance to choose between the Cross or Naught after each game has ended.

Step 14: It’s Gameplay Time

Now as we have understood each step in detail and the logic behind each let us compile all the above-created functions and execute our tic tac toe Python game to see it working and also to enjoy our very own created game!!

Code :

Output :

Please refer to the subsection – Final Output under the heading What we are building?

Elevate your coding skills with our Machine Coding Tic Tac Toe – LLD Case Study Course. Enroll now and master the art of low-level design!

Conclusion

Throughout this step-by-step project, you’ve created a classic tic-tac-toe computer game using Python and Tkinter. This GUI framework is available in the Python standard library. It runs on Windows, Linux, and macOS, so your game will work great on all three platforms. That’s pretty cool!

In this tutorial, you learned how to:

• Implement the logic of the classic tic-tac-toe game using Python
• Build the game’s board or GUI using Tkinter from the Python standard library
• Connect the game’s logic and GUI to make the game work correctly

This knowledge provides you with the foundation for creating new and more complex games and GUI projects, which will help you take your Python skills to the next level.

Conclusion

• Tic tac toe Python, also known as Noughts and Crosses or Xs and Os, is a very simple two-player game where both the player choose between the symbol ‘X’ and ‘O’ to mark the position on a 3X3 grid. Once a player is successful in marking a strike of the same symbol either in the horizontal, vertical, or diagonal way that player wins the game else the game goes on a draw if all the spots are filled.
• We can access the above data from the Status of Grid which requires us to pass over the information every time we need to know the positions of each player. This is generally done by conserving time via the Time versus Space Complexity Trade-off.
• The player_current variable that we used was to store the move of the current player as ‘X’ or ‘O’ in the tic tac toe in Python.