Learn How to Build a Dice Game in Python: Absolute Beginners Tutorial

Building a dice game is one of the best first projects for anyone learning Python. It combines randomness, loops, conditionals, and user input into a single script you can run from your terminal in under 30 lines of code. This tutorial walks through every line, from importing the random module to printing a final winner.

A dice game makes an excellent starter project because it reinforces several core Python skills at once. You will practice importing modules, generating random numbers, writing while loops, reading user input with the input() function, and using if/elif/else branches to control program flow. By the end of this tutorial, you will have a working player-vs-computer dice game with score tracking and a replay option.

What You Need Before You Start

This tutorial assumes you have Python 3 installed on your machine. You do not need any third-party packages. The only module used here, random, ships with every standard Python installation. Any text editor or IDE will work, whether that is VS Code, IDLE, or even a plain terminal with nano.

If you can open a terminal and type python3 --version (or python --version on Windows) and see a version number starting with 3, you are ready to go. Create a new file called dice_game.py and follow along.

Understanding the random Module

Python's random module provides functions for generating pseudo-random numbers. The word "pseudo" matters here: the numbers are produced by a deterministic algorithm called the Mersenne Twister, not by a truly random physical process. For games and simulations, this is perfectly fine. For security-critical applications, you would use the secrets module instead.

The function we care about is random.randint(a, b). It returns a random integer N such that a <= N <= b. Both endpoints are included. That makes it a natural fit for simulating a standard six-sided die, where the valid outcomes are 1, 2, 3, 4, 5, and 6.

import random

# Simulate rolling a six-sided die
roll = random.randint(1, 6)
print("You rolled:", roll)

Run this a few times and you will see a different number each time. The import random line loads the module into memory, and random.randint(1, 6) does the work of picking one number from the range 1 through 6.

Comparing Random Functions

Python's random module offers several functions for generating numbers. Here is how the three you are likely to encounter as a beginner compare to each other.

Writing the Game Logic Step by Step

Now that you understand how randint() works, it is time to combine it with loops, input, and conditionals to build the full game. The goal: the player and the computer each roll a die every round. Whoever rolls higher earns a point. The first to reach 3 points wins.

The Basic Game Loop

A while loop is ideal here because you do not know in advance how many rounds the game will take. The loop keeps running until one player's score hits the target.

import random

player_score = 0
computer_score = 0
target = 3

while player_score < target and computer_score < target:
    input("Press Enter to roll the dice...")

    player_roll = random.randint(1, 6)
    computer_roll = random.randint(1, 6)

    print(f"You rolled: {player_roll}")
    print(f"Computer rolled: {computer_roll}")

    if player_roll > computer_roll:
        player_score += 1
        print("You win this round!")
    elif computer_roll > player_roll:
        computer_score += 1
        print("Computer wins this round!")
    else:
        print("It's a tie! No points awarded.")

    print(f"Score — You: {player_score} | Computer: {computer_score}\n")

if player_score == target:
    print("Congratulations! You won the game!")
else:
    print("Game over. The computer won.")

Walk through what happens here. The two score variables start at zero. The while condition checks that neither player has reached 3 yet. Inside the loop, input() pauses execution until the player presses Enter, giving them a sense of control. Both rolls happen via randint(1, 6), and the if/elif/else chain determines who scores. After the loop exits, a simple check reveals the winner.

Adding a Play Again Feature

Wrapping the entire game in an outer loop lets you offer a replay without restarting the script.

import random

def play_game():
    player_score = 0
    computer_score = 0
    target = 3
    round_num = 1

    print("\n--- Dice Game: First to 3 wins! ---\n")

    while player_score < target and computer_score < target:
        input(f"Round {round_num} — Press Enter to roll...")

        player_roll = random.randint(1, 6)
        computer_roll = random.randint(1, 6)

        print(f"  You rolled: {player_roll}")
        print(f"  Computer rolled: {computer_roll}")

        if player_roll > computer_roll:
            player_score += 1
            print("  You win this round!")
        elif computer_roll > player_roll:
            computer_score += 1
            print("  Computer wins this round!")
        else:
            print("  It's a tie! No points awarded.")

        print(f"  Score — You: {player_score} | Computer: {computer_score}\n")
        round_num += 1

    if player_score == target:
        print("Congratulations! You won the game!")
    else:
        print("Game over. The computer won.")

# Main loop with replay
while True:
    play_game()
    again = input("\nPlay again? (y/n): ").strip().lower()
    if again != "y":
        print("Thanks for playing!")
        break

The play_game() function encapsulates all the game logic, making it easy to reset everything by calling it again. The outer while True loop asks for a replay after each game. Calling .strip().lower() on the input handles cases where the player types " Y " or "Yes" with trailing spaces or mixed case.

"Simple is better than complex." — The Zen of Python

Python Learning Summary Points

1. random.randint(a, b) returns a random integer between a and b, inclusive on both ends, making it a direct fit for simulating standard dice.
2. A while loop with compound conditions using and is the right structure when the game should stop as soon as any one condition becomes false.
3. The input() function pauses the program and waits for the user to press Enter, giving the player agency in each round without requiring complex event handling.
4. Wrapping game logic in a function and calling it from a while True loop is a clean pattern for offering replay without duplicating code.
5. Chaining .strip().lower() on user input normalizes whitespace and case, preventing the program from breaking on minor input variations.

This dice game covers the foundational patterns you will reuse in larger projects: importing modules, looping until a condition is met, reading and sanitizing user input, and branching with conditionals. From here, you could extend the game with multiple dice, weighted scoring, or even a graphical interface using a library like tkinter. The core logic stays the same.