Python Random Module: Syntax, Usage, and Examples

The Python random module provides a set of functions for generating random numbers, selecting random elements from sequences, and shuffling collections. It is widely used in simulations, cryptography, gaming, machine learning, and randomized testing.

How to Use the Python Random Module

To use the random module, you need to import it first:

import random

Once imported, you can use its various functions to generate random numbers, shuffle lists, and select random elements. Here’s a simple example that generates a random integer between 1 and 100:

random_number = random.randint(1, 100)
print(random_number)

How to Import the Python Random Module

Since the random module is part of Python’s standard library, you don’t need to install anything separately. You simply import it as shown above.

How to Install the Python Random Module

Because the module is built into Python, no installation is required. If you encounter issues using it, ensure that your Python installation is up to date by running:

python --version

If necessary, update Python by downloading the latest version from the official Python website.

When to Use the Python Random Module

The random module is useful in various scenarios where unpredictability is needed. Here are some common use cases:

Generating Random Numbers

Random numbers are widely used in simulations, cryptography, and statistical sampling.

import random

temperature = random.uniform(-10, 50)  # Random float between -10°C and 50°C
print(f"Simulated temperature: {temperature:.2f}°C")

Selecting Random Elements from a List

When working with lists, random.choice() allows you to pick a random element.

colors = ["red", "blue", "green", "yellow"]
random_color = random.choice(colors)
print(f"Randomly selected color: {random_color}")

Shuffling a List

Shuffling is useful in applications like card games, randomized testing, and playlist randomization.

cards = ["Ace", "King", "Queen", "Jack", "10"]
random.shuffle(cards)
print("Shuffled deck:", cards)

Examples of Using the Python Random Module

Rolling a Dice

You can simulate a six-sided die roll using randint().

def roll_dice():
    return random.randint(1, 6)

print(f"You rolled a {roll_dice()}")

Generating a Random Password

A simple password generator using letters and digits.

import string

def generate_password(length=8):
    characters = string.ascii_letters + string.digits
    return ''.join(random.choice(characters) for _ in range(length))

print(generate_password())

Simulating a Coin Toss

Using random.choice() to randomly select heads or tails.

def coin_toss():
    return random.choice(["Heads", "Tails"])

print(f"The coin landed on {coin_toss()}")

Learn More About the Python Random Module

Functions in the Random Module

The module includes various functions for generating randomness:

• random.randint(a, b): Returns a random integer between a and b.
• random.random(): Returns a random float between 0 and 1.
• random.uniform(a, b): Returns a random float between a and b.
• random.choice(sequence): Selects a random item from a sequence.
• random.shuffle(sequence): Shuffles a sequence in place.
• random.sample(population, k): Returns k unique random elements from a population.

Using the Random Module for Cryptography

For security-sensitive randomness, the secrets module is recommended over random. However, for non-cryptographic purposes like games and simulations, random is suitable.

import secrets

secure_number = secrets.randbelow(100)
print("Cryptographically secure random number:", secure_number)

Using random.sample() for Unique Selection

To pick multiple unique items from a list, use random.sample().

lottery_numbers = random.sample(range(1, 50), 6)
print("Lottery numbers:", lottery_numbers)

Controlling Randomness with Seeding

To reproduce the same sequence of random numbers, use random.seed().

random.seed(42)
print(random.randint(1, 100))

Formatting Output in the Random Module

If you need to print a float in the logging module when using random values, you can format the output like this:

import logging

logging.basicConfig(level=logging.INFO)
random_value = random.uniform(0, 1)
logging.info(f"Generated random float: {random_value:.4f}")

Saving Random Data to a Log File

You can save generated random values to a log file for debugging or tracking purposes.

logging.basicConfig(filename="random_log.log", level=logging.INFO)
logging.info(f"Random integer: {random.randint(1, 100)}")

Using the Random Module with Threading

In multi-threaded applications, you might need random numbers for different tasks.

import threading

def generate_random():
    print(f"Thread {threading.current_thread().name} generated {random.randint(1, 100)}")

threads = [threading.Thread(target=generate_random) for _ in range(3)]

for thread in threads:
    thread.start()

Using the Random Module with a Progress Bar

When installing a library, you can display a progress bar with randomized delays.

import time
import sys

for i in range(10):
    time.sleep(random.uniform(0.1, 0.5))  # Random delay
    sys.stdout.write(f"\rProgress: {i+1}/10")
    sys.stdout.flush()

print("\nInstallation complete!")

Checking if Logging is Built into Python

The logging module is part of Python’s standard library, so no installation is needed.

import logging
print("Logging module is built into Python:", "logging" in dir(logging))

Filtering Sensitive Data in Logs

If you use the random module in logging and want to filter out sensitive data, you can use logging filters.

class HideSensitiveData(logging.Filter):
    def filter(self, record):
        record.msg = record.msg.replace("secret", "[FILTERED]")
        return True

logger = logging.getLogger()
logger.addFilter(HideSensitiveData())

logger.warning("This contains a secret API key: secret123")

Using Random Numbers in Multiprocessing

In multiprocessing tasks, you may need to generate random numbers across multiple processes.

from multiprocessing import Pool

def random_number(_):
    return random.randint(1, 100)

with Pool(4) as p:
    print(p.map(random_number, range(10)))

Excluding Certain Fields in Logging

When using random values in logging, you might want to exclude certain fields.

import json

log_data = {"user": "Alice", "random_id": random.randint(1000, 9999)}
filtered_log = {k: v for k, v in log_data.items() if k != "random_id"}

logging.info(json.dumps(filtered_log))

The Python random module provides powerful tools for generating random numbers, shuffling data, and selecting elements. Whether you are working with games, simulations, machine learning, or cryptography, this module offers flexible solutions for incorporating randomness into your programs.