Learn How to Build the Rock, Paper, Scissors Game in Python: Absolute Beginners Tutorial

Rock, Paper, Scissors is one of the best first projects you can build in Python. It is small enough to finish in one sitting, but it touches every skill that actually matters at the beginner level: getting input from the user, making decisions with conditionals, using the standard library, and keeping a program running with a loop.

By the end of this tutorial you will have a working terminal game that plays multiple rounds, tracks a score, and lets the player quit whenever they want. Every line of the final code is explained so you understand not just what it does but why it is written that way.

What the Program Will Do

Before writing any code, it helps to know what you are building. The finished program will do the following when run:

1. Ask the player to type rock, paper, scissors, or quit.
2. Have the computer pick a move at random.
3. Compare the two moves, print who won the round, and update the score.
4. Repeat until the player types quit, then print the final score.

That is four distinct behaviors, and each one maps to a specific Python concept. Asking for input maps to the input() function. Picking randomly maps to the random module. Comparing moves maps to if/elif/else. Repeating maps to a while loop. This is why game projects are so effective for learning: the game requirements drive you toward real-world patterns.

The Game Logic at a Glance

Rock beats scissors. Scissors beats paper. Paper beats rock. If both players choose the same thing, the round is a tie. That is all the domain logic this game requires, and you will represent it entirely with conditional statements.

The random Module and random.choice()

The random module is part of Python's standard library, which means it ships with Python and you never need to install it. To use it, you add one line at the top of your script:

import random

The function you will use is random.choice(). It takes a sequence — any list, tuple, or string — and returns one element chosen at random. Here is the only call you need for the computer's move:

choices = ["rock", "paper", "scissors"]
computer_choice = random.choice(choices)

Every time that line runs, computer_choice will be one of the three strings. random.choice() does not remove the chosen item from the list, so all three options remain available on the next call. That is the only randomness this program needs.

Why a List and Not Three Separate Variables?

Storing the choices in a list has two advantages. First, random.choice() needs a sequence — it cannot pick from three separate variables. Second, the list makes input validation effortless. You can check whether what the player typed is valid with a single expression: player_choice in choices. If the player types something unexpected, that expression evaluates to False and you handle the error before any other logic runs.

Getting Player Input and Validating It

The input() function pauses the program and waits for the user to type a line and press Enter. It always returns a string, regardless of what the user types. For this game, you want to normalize the input so that typing Rock or ROCK works the same as typing rock:

player_choice = input("Enter rock, paper, scissors, or quit: ").strip().lower()

Two string methods are chained here. .strip() removes any leading or trailing whitespace the player may have accidentally typed. .lower() converts the entire string to lowercase. Chaining them means both transformations happen in one line before the value is stored in player_choice.

After normalizing, check whether the player wants to quit, and then check whether the input is valid:

if player_choice == "quit":
    break

if player_choice not in choices:
    print("Invalid choice. Please type rock, paper, or scissors.")
    continue

The break statement exits the while loop immediately. The continue statement skips the rest of the current loop iteration and jumps back to the top, which means the invalid input never reaches the winner-determination logic.

Putting It All Together: The Complete Game

Here is the full program. Read through it once before moving on to the step-by-step build section below.

import random

choices = ["rock", "paper", "scissors"]
player_score = 0
computer_score = 0

def determine_winner(player, computer):
    if player == computer:
        return "tie"
    wins_against = {"rock": "scissors", "paper": "rock", "scissors": "paper"}
    if wins_against[player] == computer:
        return "player"
    return "computer"

print("Rock, Paper, Scissors — type 'quit' to exit.\n")

while True:
    player_choice = input("Your move (rock/paper/scissors): ").strip().lower()

    if player_choice == "quit":
        break

    if player_choice not in choices:
        print("Invalid choice. Please type rock, paper, or scissors.\n")
        continue

    computer_choice = random.choice(choices)
    print(f"Computer chose: {computer_choice}")

    result = determine_winner(player_choice, computer_choice)

    if result == "tie":
        print("It's a tie!")
    elif result == "player":
        player_score += 1
        print("You win this round!")
    else:
        computer_score += 1
        print("Computer wins this round.")

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

print(f"\nFinal score — You: {player_score}  Computer: {computer_score}")
print("Thanks for playing.")

"Simple things should be simple, complex things should be possible." — Alan Kay

Understanding the wins_against Dictionary

The wins_against dictionary inside determine_winner encodes all three win conditions in one data structure:

wins_against = {"rock": "scissors", "paper": "rock", "scissors": "paper"}

Reading it: rock beats scissors, paper beats rock, scissors beats paper. The function checks whether wins_against[player] equals the computer's choice. If it does, the player wins. If neither the tie nor the win condition is true, the computer wins. This is a useful pattern to remember: when you have a fixed set of relationships between values, a dictionary is often cleaner than a long chain of elif statements.

Python Learning Summary Points

1. import random loads the random module, which provides random.choice() for selecting a random element from a list.
2. The input() function always returns a string. Chaining .strip().lower() normalizes the input so case and whitespace do not cause unexpected failures.
3. A while True loop runs indefinitely until a break statement is reached, which is the standard pattern for terminal-based game loops in Python.
4. The continue statement skips the rest of the current loop iteration. Using it after detecting invalid input prevents bad data from reaching the logic that depends on valid data.
5. A dictionary can replace a long chain of elif statements when you are mapping one value to another. The wins_against pattern here is worth remembering for any project involving fixed rule sets.

From here, there are a number of natural extensions you can try: add a round limit so the game ends after five rounds, track win streaks, allow the player to choose how many rounds to play, or add a "best of N" mode. Each extension introduces a new concept without requiring you to rewrite what you have already built.