Game — Tic-Tac-Toe · Part 1 (Board & Display)

By the end of this lesson you can:

• Represent a 3×3 grid as a list of lists in Python.
• Print the grid cleanly with borders.
• Read a move from the user — row and column — and validate it.
• Alternate turns between X and O.

A 3×3 grid is a list of three lists, each with three items:

board = [
    [".", ".", "."],
    [".", ".", "."],
    [".", ".", "."],
]

print(board[0][0])     # top-left
print(board[1][1])     # centre
print(board[2][2])     # bottom-right

Two indices: board[row][col]. Row first, column second — the maths convention. Rows count 0, 1, 2 from the top; columns 0, 1, 2 from the left.

1 · Build the board

Don't hand-type three identical lists. Use a comprehension. (We'll see exactly why the obvious-looking [["."] * 3] * 3 is dangerous in a moment.)

def new_board():
    return [["." for _ in range(3)] for _ in range(3)]

The shared-reference trap

This common-looking code is broken:

board = [["."] * 3] * 3    # ❌ all three rows are the SAME list

board[0][0] = "X"
print(board)
# → [['X', '.', '.'], ['X', '.', '.'], ['X', '.', '.']]
#                              ↑ ↑ all changed at once!

The outer * 3 doesn't make three separate lists — it makes three references to the same list. Use the comprehension above to build three independent rows.

2 · Print the board

def show(board):
    print()
    print("   0   1   2")          # column labels
    print("  ───┬───┬───")
    for r in range(3):
        print(f"{r}  {board[r][0]} │ {board[r][1]} │ {board[r][2]}")
        if r < 2:
            print("  ───┼───┼───")
    print()

   0   1   2
  ───┬───┬───
0  . │ . │ .
  ───┼───┼───
1  . │ X │ .
  ───┼───┼───
2  . │ . │ O

Box-drawing characters (│ ─ ┼) come standard with Unicode terminals. If your terminal doesn't render them, swap for plain ASCII (| - +).

3 · Place a piece

def place(board, row, col, piece):
    if not (0 <= row <= 2 and 0 <= col <= 2):
        return False                     # off-board
    if board[row][col] != ".":
        return False                     # square already taken
    board[row][col] = piece
    return True                          # success

Two checks before writing: in-range, and the square is empty. Return True/False so the caller can loop until a valid move comes in.

4 · Switch turns

Two pieces, alternate. Use a variable that flips each turn.

turn = "X"
# after a successful move:
turn = "O" if turn == "X" else "X"

You'll also see a fancier turn = "XO"[turn == "X"] trick — same effect, harder to read. Stick with the conditional.

Save as ttt1.py. Plays a game with no win detection — just 9 moves alternating X and O.

# ttt1.py — board + display + move loop (no win detection yet)

def new_board():
    return [["." for _ in range(3)] for _ in range(3)]

def show(board):
    print()
    print("   0   1   2")
    print("  ───┬───┬───")
    for r in range(3):
        print(f"{r}  {board[r][0]} │ {board[r][1]} │ {board[r][2]}")
        if r < 2:
            print("  ───┼───┼───")
    print()

def place(board, row, col, piece):
    if not (0 <= row <= 2 and 0 <= col <= 2):
        return False
    if board[row][col] != ".":
        return False
    board[row][col] = piece
    return True

def ask_move(turn):
    while True:
        raw = input(f"{turn}'s move — row col: ").strip()
        parts = raw.split()
        if len(parts) != 2:
            print("  ! Type two numbers, like '1 2'.")
            continue
        try:
            r, c = int(parts[0]), int(parts[1])
        except ValueError:
            print("  ! Numbers only please.")
            continue
        return r, c

# --- play 9 moves ---

board = new_board()
turn  = "X"

for move_no in range(9):
    show(board)
    while True:
        r, c = ask_move(turn)
        if place(board, r, c, turn):
            break
        print("  ! Square taken or off-board. Try again.")

    turn = "O" if turn == "X" else "X"

show(board)
print("Board is full. (No win detection yet — that's Part 2.)")

Sample session

   0   1   2
  ───┬───┬───
0  . │ . │ .
  ───┼───┼───
1  . │ . │ .
  ───┼───┼───
2  . │ . │ .

X's move — row col: 1 1

   0   1   2
  ───┬───┬───
0  . │ . │ .
  ───┼───┼───
1  . │ X │ .
  ───┼───┼───
2  . │ . │ .

O's move — row col: 0 0
...

Read the diff

Three small reusable functions — new_board, show, place — plus an ask_move input helper. The 9-move loop just calls them in order, switching turn after each successful place. Win detection comes next; the foundation is set.

A 3×3 grid is a list of lists. Build with a nested comprehension — never with * 3 (shared references!). Access cells with board[r][c], row first, column second. Print with a small show function that draws separator lines. Take input as two numbers per move; validate range and that the square is empty before placing. Switch turns with a one-line ternary. Four helper functions cover the whole foundation.