How to Create a Rock, Paper, Scissors Game in Python Using CLI

Introduction

Rock, Paper, Scissors is a classic hand game that’s simple yet fun to play. So let's build a command-line version of the game in Python, where we can play against the computer while keeping track of winning, losses and ties.

Prerequisites

Before we start, make sure you have these.

Python installed.
A code editor (VS Code, PyCharm, or even Notepad will work).
Basic understanding of functions, loops, and conditionals in Python.

Step 1. Setting Up the Game Structure

We’ll start by importing the necessary modules and defining the main function.

Importing Required Modules

Let's import some modules that we will be using in the code later on.

import sys  
import random  
from enum import Enum

In the first line, we have imported the sys module as we will be using the exit function present in this module to exit the game. In the next line, we have imported a random module that we will be using to generate random choice. In the next line, we have imported the Enum class from the enum module.

Defining the Main Function

Let's create a function in which we will be writing our game logic.

def rps(name='PlayerOne'):  
    game_count = 0  
    player_wins = 0  
    python_wins = 0

Here, we have created a function named rps in which we are passing one parameter named name in which we have provided a default value. In the next lines, we have declared some variables and also assigned initial values. game_count is used to track total games played, player_wins and python_wins track wins by player and computer respectively.

Step 2. Creating the Game Logic

Inside the rps() function, let's define play_rps(), which will hold the core game logic.

Using Enums for Choices

Let's create a enum class and assign the required values in this.

class RPS(Enum):  
    ROCK = 1  
    PAPER = 2  
    SCISSORS = 3

This makes the code more readable instead of using raw numbers.

Taking Player Input

Now, let's take player choice from the user.

playerchoice = input(f"\n{name}, please enter... \n1 for Rock,\n2 for Paper, or \n3 for Scissors:\n")

The players' choice will be stored in the player choice variable.

Generating Computer’s Choice

computerchoice = random.choice("123")  
computer = int(computerchoice)

Here, for the computer's choice, we are randomly picking one value from 1, 2, or 3 as a string, and then in the next line, we will convert it to an integer for comparison.

Displaying Choices

print(f"\n{name}, you chose {str(RPS(player)).replace('RPS.', '').title()}.")  
print(f"Python chose {str(RPS(computer)).replace('RPS.', '').title()}.\n")

Here, the above lines format and display the player’s and Python’s choices in a clean way. Since RPS(1) returns RPS.ROCK, we convert it to a string, remove "RPS." using .replace(), and capitalize it with .title(). This makes the output user-friendly.

Step 3. Determining the Winner

Now, let's define decide_winner() to compare player and computer choices.

Winning Conditions

if player == 1 and computer == 3:  
    player_wins += 1  
    return f"🎉 {name}, you win!"  
elif player == 2 and computer == 1:  
    player_wins += 1  
    return f"🎉 {name}, you win!"  
elif player == 3 and computer == 2:  
    player_wins += 1  
    return f"🎉 {name}, you win!"  
elif player == computer:  
    return "😲 Tie game!"  
else:  
    python_wins += 1  
    return f"🐍 Python wins!\nSorry, {name}..😢"

Here, we have written the conditional statements to decide the winner based on their choice value and the rules of the game. If the player wins (Rock beats Scissors, Paper beats Rock, or Scissors beats Paper), we will increase their win count and display a victory message. If both choose the same, it's a tie. Otherwise, if Python wins, we will increase its score and display a loss message.

Updating Game Stats

After each round, we are displaying the total games played, players’ wins, and Python’s wins.

game_count += 1  
print(f"\nGame count: {str(game_count)}")  
print(f"\n{name}'s wins: {str(player_wins)}")  
print(f"\nPython wins: {str(python_wins)}")

Step 4. Adding Replayability

After each game, the player can choose to continue or quit.

while True:  
    playagain = input("\nY for Yes or \nQ to Quit\n")  
    if playagain.lower() not in ["y", "q"]:  
        continue  
    else:  
        break  

if playagain.lower() == "y":  
    return play_rps()  
else:  
    print("\n🎉🎉🎉🎉")  
    print(f"Thank you for playing {name}!\n")  
    sys.exit(f"Bye {name}! 👋")

Here, we are asking the player if they want to play again. We will keep prompting until they enter "Y" (Yes) or "Q" (Quit). If they choose "Y", the game restarts by calling play_rps() again. If they choose "Q", the game thanks them, and display a bye message, and exits using sys.exit().

Step 5. Running the Game from CLI

Now, let's allow taking personalized names via the command line For that, we will use argparse.

if __name__ == "__main__":  
    import argparse  
    parser = argparse.ArgumentParser(description="Provides a personalized game experience.")  
    parser.add_argument(  
        "-n", "--name", metavar="name",  
        required=True, help="The name of the person playing the game."  
    )  
    args = parser.parse_args()  
    rock_paper_scissors = rps(args.name)  
    rock_paper_scissors()

Here, we are ensuring that the game starts only when the script is run directly (not when imported as a module). Then we use argparse to let the player enter their name when running the script from the command line. The -n or --name argument is required so the game knows who is playing. We will pass this to the rps() function, which sets up the game for that player. Finally, it will start the game by calling rock_paper_scissors().

How to Run the Game

To run the game, we will save the file as rps.py. Then, in the terminal and we will run the below command.

   py rps.py -n "Name"

Here, py or python3 runs Python, rps.py is our filename, and -n "Name" lets us enter our name for a personalized experience. After running this, the game will start, and we are now ready to play our rock-paper-scissor game.

Output

The above image shows how this will look in the terminal when we will play.

Conclusion

Now, we’ve successfully built a command-line Rock, Paper, Scissors game in Python. By following this step by step, we've learned how to take user input and validate it, use Enums to make code more readable, generate random choices for the computer, compare results and determine a winner, track scores and allow replayability, and run the game via CLI with personalized player names.

This project is a great way to practice Python fundamentals like loops, conditionals, functions, and modules like random and argparse.