Python Random Numbers

Introduction

Welcome to the fascinating world of random numbers in Python! But before we dive into the code, let’s establish a foundation.

What are Random Numbers?

Definition and Importance in Computing

Random numbers are not truly random but rather pseudo-random. They are generated by a computer algorithm that creates a sequence of seemingly unpredictable numbers. This calculated sequence mimics randomness but relies on a seed value determining the starting point. Despite their non-absolute randomness, they are incredibly valuable in computing.

Random numbers play a crucial role in various applications:

• Simulations and Modeling: Imagine simulating a complex system like weather patterns or financial markets. Random numbers help inject realistic variability into these models, allowing us to study their behavior under different conditions.
• Game Development: Random numbers are the lifeblood of games! They determine everything from the dice roll to the movement of enemies, creating an element of surprise and keeping gameplay engaging.
• Data Security (Obfuscation): When anonymizing data for privacy reasons, random numbers can be used to shuffle or mask sensitive information, making it more difficult to identify individuals.
• Machine Learning (Training Data): Training machine learning algorithms often requires diverse datasets. Random numbers help generate this variety, ensuring the algorithm doesn’t develop biases based on a limited set of predictable data.

Why Use Random Numbers in Python?

With its rich set of libraries, Python makes working with random numbers a breeze. The random module provides a powerful toolbox for generating different types of random values, making it an ideal choice for various tasks:

• Simulations and Modeling: Python’s clear syntax and libraries like NumPy make it perfect for building complex simulations that leverage random numbers.
• Game Development: With Python frameworks like Pygame, you can create engaging games where random numbers control everything from dice rolls to enemy behavior.
• Data Security (Obfuscation): Python scripts can anonymize data by employing random numbers for shuffling or masking techniques.
• Machine Learning (Training Data): Python’s extensive data science libraries, like sci-kit-learn, can be combined with random number generation to create diverse training datasets for machine learning models.

This introductory section has laid the groundwork for exploring random numbers in Python. Now, we’ll delve deeper into the functionalities offered by the random module and how to harness its power for various applications.

The Workhorses of Randomness: Python’s Random Module

The random module is the heart and soul of random number generation in Python. It provides a collection of functions catering to various needs, making introducing an element of chance into your programs easy.

Importing the random Module

To begin using the random module, import it into your Python script. This is done with the following line:

Python

import random

Once imported, the functions and functionalities of the random module become available for your use throughout the script.

Generating Random Integers

When it comes to random integers, the random module offers two key functions:

• Random. randint(a, b): This function generates a random integer within a specified inclusive range, including both a and b.

Here’s an example:

Python

random_number = random.randint(1, 6)

print(random_number)  # This could print any number between 1 and 6 (inclusive)

• Random. randrange(start, stop, step): This function provides more control over the generated random integer. It generates a random number between start (inclusive) and stop (exclusive), with an optional step value determining the increment between consecutive numbers.

Here’s an example:

Python

random_number = random.randrange(2, 10, 2)  # Generates even numbers between 2 (inclusive) and 10 (exclusive)

print(random_number)  # This could print 2, 4, 6, or 8

These functions offer a versatile way to generate random integers for various applications, from simulating dice rolls to creating random positions within a game world.

Generating Random Floats

The random module also allows you to generate random floating-point numbers, which are numbers with decimal points.

• Random.random(): This function generates a single random floating-point number between 0.0 (inclusive) and 1.0 (exclusive).

Here’s an example:

Python

random_float = random.random()

print(random_float)  # This could print any number between 0.0 (inclusive) and 1.0 (exclusive)

• Random. Uniform (a, b): This function generates a random floating-point number within a specified range, including a and excluding b.

Here’s an example:

Python

random_temperature = random.uniform(10.0, 30.0)

print(random_temperature)  # This could print any number between 10.0 (inclusive) and 30.0 (exclusive)

These functions provide a way to introduce randomness with decimals, which is useful for simulating real-world phenomena or creating variations in-game elements.

By mastering these core functionalities of the random module, you’ll be well on your way to incorporating the element of surprise into your Python programs!

Shuffling the Deck: Randomizing Sequences

The random module extends its power beyond individual numbers, allowing you to manipulate entire sequences. This section explores functions for randomizing the order of elements within a list, tuple, or string, a technique akin to shuffling a deck of cards.

Rearranging Elements with random.shuffle(sequence)

Imagine you have a list of players for a game and want to determine the order randomly—the random. The shuffle (sequence) function comes to the rescue!

Python

players = [“Alice,” “Bob,” “Charlie,” “David”]

random.shuffle(players)

print(players)  # This will print the players in a random order

This function modifies the original sequence in place, meaning it directly shuffles the elements within the list itself. This approach is efficient for scenarios where you want to work directly with the shuffled sequence.

Important Note: Since shuffling modifies the original list, creating a copy before shuffling is recommended if you need to preserve the original order.

• Selecting Random Elements

Sometimes, you might not need to shuffle the entire sequence but rather pick a random element or a subset of elements. The random module offers a couple of helpful functions for this purpose:

• Random.choice(sequence): This function retrieves a single random element from the provided sequence.

Here’s an example:

Python

fruits = [“apple,” “banana,” “orange”]

random_fruit = random.choice(fruits)

print(random_fruit)  # This could print any of the three fruits

This function is useful for selecting a random item from a list, menu, or pool of options.

• Random. Sample (sequence, k): This function is more versatile, allowing you to select a specific number (k) of unique elements from the sequence.

Here’s an example:

Python

lottery_numbers = random.sample(range(1, 60), 6)  # Generates 6 unique lottery numbers between 1 and 59

print(lottery_numbers)  # This will print a list of 6 unique lottery numbers

This function is ideal for generating random samples or creating unique subsets of elements from a larger collection.

By combining these techniques, you can effectively manipulate the order and selection of elements within your Python programs, adding a layer of chance and dynamism to various applications.

The Realm of Probability: Simulating Random Events

The true power of random numbers lies in their ability to simulate real-world chance events. This section delves into using Python’s random module to model scenarios where outcomes are not guaranteed but determined by probability.

Generating Random Booleans with random.choice([True, False])

The foundation of many random events is the concept of a binary outcome: success or failure, heads or tails. The random module allows you to generate such Boolean values with ease.

Python

coin_flip = random.choice([True, False])

if coin_flip:

print(“Heads”)

else:

print(“Tails”)

This code simulates a coin flip. Random. Choice selects either True (heads) or False (tails) with equal probability (50%).

Simulating Coin Flips with random.randint(0, 1)

Here’s an alternative approach to simulating coin flips using random.randint(0, 1).

Python

coin_flip = random.randint(0, 1)

if coin_flip == 0:

print(“Tails”)

else:

print(“Heads”)

This method leverages the integer nature of random. randint. Any result is random by assigning 0 to tails and 1 to heads. randint(0, 1) can be interpreted as the coin flip outcome.

Simulating Dice Rolls with random.randint(1, 6) (or Relevant Dice Sides)

Moving beyond coin flips, what about rolling dice? Simulating dice rolls is straightforward with random. randint.

Python

dice_roll = random.randint(1, 6)

print(f”You rolled a {dice_roll}”)

This code generates a random integer between 1 and 6, representing the possible outcomes of a six-sided die. The concept can be easily adapted to any number of sides by adjusting the range randomly. randint.

Simulating Events with Probabilities: Using random. Random () for Unequal Probabilities

So far, we’ve explored events with a 50% chance of success (coin flips). But what if the probability is uneven? This is where random.random() comes in.

Python

# Simulate a weather event with a 70% chance of sunshine

sunny_day = random.random() < 0.7  # Threshold for sunshine is 0.7

if sunny_day:

print(“Enjoy the sunshine!”)

else:

print(“Looks like rain today.”)

Here, random. Random () generates a value between 0.0 (inclusive) and 1.0 (exclusive). By setting a threshold (0.7 in this case), any value below that threshold triggers a sunny day (70% chance). This approach allows you to model events with any probability distribution by adjusting the threshold.

With these techniques, you can create various random simulations in Python, from simple coin flips to complex weather models. The possibilities are limited only by your imagination!

Also Read: Python Operators

Advanced Techniques: Expanding the Randomness Toolbox

The random module offers functionalities beyond basic random number generation. This section explores advanced techniques to refine your control over randomness and cater to specific use cases.

Seeding the Random Number Generator for Reproducibility

By default, the random module uses an unpredictable seed value based on system time. This ensures different program runs generate different random sequences. However, there are situations where you might want to reproduce a specific sequence of random numbers across multiple runs. This is where seeding comes in.

Python

# Set a seed value for reproducible results

random.seed(1234)

# Perform random operations (these will generate the same sequence each time)

# Reset the seed to avoid unintended consequences in subsequent code

random.seed()  # Resets to system time-based seed

The random. The seed (seed_value) function sets a specific random number generation algorithm starting point. Any subsequent program runs with the same seed will produce the same sequence of random numbers. This is useful for debugging or creating deterministic simulations where repeatable results are desired.

Important Note: Use seeding judiciously. In most cases, true randomness is preferable. Seeding can introduce bias if not used carefully.

Random Numbers Across Multiple Runs (Avoiding Repetition)

While seeding offers reproducibility, what if you want a sequence that changes across runs but avoids repeating the same sequence from a previous run? This can be achieved by leveraging random. getstate() and random. setstate().

Python

# Capture the current random state

random_state = random.get state()

# Perform random operations in the first run

# Save the state for future use

with open(“random_state.pkl”, “wb”) as f:

pickle.dump(random_state, f)  # Pickle library needed for saving state

# In subsequent runs, load the saved state and restore it

with open(“random_state.pkl”, “rb”) as f:

random.set state(pickle.load(f))

# Perform random operations with a different sequence (but not identical to the first run)

This approach involves capturing the current state of the random number generator using random. getstate(). This state can be saved to a file (using libraries like pickle). In subsequent runs, you can load the saved state randomly. Set state (), ensuring a different sequence than the first run but avoiding repetition of the initial sequence.

Important Note: This technique requires additional libraries like Pickle and introduces file I/O overhead. Use it when the benefits outweigh the added complexity.

Generating Random Strings with random.choices(population, weights=None, k=1)

While the random module excels at generating numbers, it can also be used to create random strings. The random. The choice function provides flexibility in this regard.

Python

# Generate a random password with lowercase letters, digits, and special characters

alphabet = “abcdefghijklmnopqrstuvwxyz”

digits = “0123456789”

symbols = “!@#$%^&*”

characters = alphabet + digits + symbols

# Generate a password with 12 characters, with a higher weight for letters

password = “”.join(random.choices(characters, weights=[8, 2, 2], k=12))

print(password)

Here, random. Choices select characters from the provided characters string. The weights argument allows you to assign different probabilities to different character groups. In this example, letters have a higher weight (8) than digits and symbols (weight of 2 each), resulting in a password with a higher likelihood of containing more letters. The k argument specifies the desired length of the random string (12 characters in this case).

By employing these advanced techniques, you can unlock even greater potential from the random module, tailoring random number generation to fit the specific needs of your Python applications.

Security Considerations: When Randomness Needs to be Truly Random

The random module, while powerful, has limitations. It generates pseudo-random numbers calculated based on an algorithm and a seed value. While appearing random, they are predictable in theory, especially for someone with knowledge of the algorithm and seed. This becomes a critical concern in security applications where true randomness is essential.

Limitations of Pseudo-Random Numbers in Python’s Random Module

Here’s why pseudo-random numbers from random might not be suitable for security purposes:

• Predictability: If an attacker can guess the seed value or exploit weaknesses in the random number generation algorithm, they could predict future random numbers.
• Reusability of Seed: The default behavior of random uses a time-based seed, which can lead to repetition if multiple operations are performed within a short timeframe.

Using Secrets Module for Cryptographically Secure Random Numbers

Python offers the secrets module for scenarios demanding true randomness, introduced in Python 3.6. This module leverages stronger cryptographic algorithms to generate numbers with much more unpredictability.

Important Note: It’s crucial to use secrets whenever security is paramount. This includes tasks like:

• Generating encryption keys
• Creating session tokens
• Randomizing initialization vectors (IVs) for encryption

The secrets module provides functions specifically designed for secure random number generation:

• Secrets.token_bytes(n): This function generates a sequence of n cryptographically secure random bytes. These bytes can be used for various security purposes.

Python

# Generate 16 random bytes for a cryptographic key

key = secrets.token_bytes(16)

• Secrets. and below (max value): This function generates a random integer between 0 (inclusive) and max value (exclusive), using a cryptographically secure random number generator.

Python

# Generate a random integer for a one-time password (OTP) between 0 and 9999 (exclusive)

otp = secrets.and below(10000)

Utilizing the secrets module for security-sensitive tasks can ensure a higher level of unpredictability and strengthen your application’s defenses.

Putting it All Together: Practical Examples in Action.

Now that we’ve explored the theoretical underpinnings of random number generation in Python let’s see how it comes alive with practical examples! This section demonstrates how randomness can be harnessed to create simulations and games and enhance data security.

Simulating Random Walks (e.g., Brownian Motion)

Random walks are a fascinating concept where a particle takes random steps in a specific direction at each time step. They can model various real-world phenomena, from the jittery movement of microscopic particles (Brownian motion) to the erratic path of a drunken sailor.

Here’s a Python program that simulates a random walk:

Python

import random

# Define the number of steps and maximum step size

num_steps = 1000

max_step = 10

# Initialize starting position

position = 0

# Simulate the random walk

for _ in range(num_steps):

step = random.randint(-max_step, max_step)

position += step

print(f”Final position after {num_steps} steps: {position}

This program defines the number of steps and the maximum step size. Each iteration of the loop is random. randint to generate a random step value (positive or negative) and update the current position. The final position reflects the cumulative effect of these random steps.

Modifying this code allows you to explore different random walk variations, like two-dimensional walks or walks with biased step probabilities.

Creating Random Mazes

Mazes are a classic example of using randomness to generate interesting and challenging puzzles. Python’s random number generation capabilities can be harnessed to create random maze structures.

Here’s a simplified example that builds a basic random maze:

Python

import random

# Define maze dimensions

rows = 5

cols = 5

# Initialize empty maze

maze = []

for _ in range(rows):

maze. Append ([0] * cols)  # Create rows with columns filled with zeros (representing walls)

# Carve random passages

for row in range(1, rows – 1):

for col in range(1, cols – 1):

if random.randint(0, 1) == 0:  # 50% chance of creating a passage

maze[row][col] = 1  # Mark the cell as part of the passage (represented by 1)

# Print the maze

for row in a maze:

For cells in a row:

print(“#” if cell == 0 else ” “, end=””)  # Print “#” for walls and ” ” for passages

print()

This program defines the maze dimensions and initializes it with walls (represented by zeros). It then iterates through each cell and uses random. Randint will determine with a 50% chance whether to create a passage (marked by one) at that location. This is a basic approach; more complex algorithms can generate intricate maze structures.

Generating Random Passwords

In today’s security-conscious world, strong random passwords are crucial. Python’s random number generation capabilities can be leveraged to create cryptographically secure passwords using the secrets module:

Python

import secrets

# Define password length and character set

password_length = 16

characters = “abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*”

# Generate a random password using secrets.token_bytes

password = “”.join(random.choices(characters, k=password_length))

print(password)

This code defines the desired password length and a character set containing letters, numbers, and special symbols. It then utilizes secrets.token_bytes to generate a sequence of random bytes, which is converted into a string using the chosen character set. This approach ensures a high degree of randomness and complexity in the generated password.

These examples showcase the possibilities of combining Python’s random number generation features with your creativity. From scientific simulations to engaging games and robust security practices, the power of randomness is at your fingertips in Python!

Going Beyond the Basics: Additional Randomness Modules

The built-in random and secrets modules offer a solid foundation for random number generation in Python. However, the world of randomness extends even further, with additional modules catering to specific needs. This section explores two such modules: random2 and NumPy’s random.

random2 Module for Extended Functionality (Third-Party)

The random2 module is a third-party library that provides a Python 3 compatible port of the functionalities offered by Python 2.7’s random module. While the core functionalities remain largely similar to the built-in random module, random2 provides some advantages:

• Compatibility: If you’re working on a project that requires compatibility with Python 2 and 3, random2 can help maintain consistency in your random number generation code across versions.
• Deterministic Seeding: random2 offers more control over seeding behavior than the built-in random module. This can be beneficial for debugging or replicating specific random sequences across different environments.

Here’s an example demonstrating how random2 can be used:

Python

import random2

# Set a specific seed for deterministic results

random2.seed(1234)

# Generate a random integer

random_number = random2.randint(1, 6)

print(random_number)

Important Note: When working with Python 3, the built-in random module is generally preferred due to its native integration and potential performance benefits. Use random2 primarily for compatibility reasons or if you require its deterministic seeding features.

NumPy’s Random Module for Numerical Computing

NumPy, a powerful library for scientific computing in Python, also boasts its random module. This module focuses on generating random numbers specifically tailored for numerical computations.

Here are some key aspects of NumPy’s random module:

• Vectorized Random Number Generation: NumPy excels at working with arrays. The random module allows you to efficiently generate arrays of random numbers, leveraging vectorized operations for faster performance.
• Advanced Distributions: Beyond basic uniform and normal distributions, NumPy’s random module provides functions for generating random numbers from various statistical distributions like Poisson, binomial, and exponential distributions. This is particularly useful for simulating complex systems or modeling real-world phenomena.

Here’s an example demonstrating how to generate a random array of numbers from a normal distribution using NumPy’s random:

Python

import numpy as np

# Generate a random array of 100 numbers from a standard normal distribution (mean 0, standard deviation 1)

random_numbers = np. Random.normal(size=100)

print(random_numbers)

Important Note: NumPy’s random module primarily targets numerical computing tasks. The built-in random or secrets module might be more suitable for general-purpose random number generation.

Venturing beyond the core modules unlocks a wider range of functionalities for generating random numbers in Python. Whether you need compatibility across Python versions, efficient vectorized random number generation, or advanced statistical distributions, these additional modules can empower you to tackle more complex and specialized random number-related tasks in your Python programming endeavors.

Best Practices and Common Errors: Using Random Numbers Effectively

Harnessing the power of random numbers in Python effectively requires careful consideration. This section delves into best practices and common pitfalls to avoid, ensuring your code produces the desired randomness without introducing unintended consequences.

Choosing the Right Random Number Generation Method

The random and secret modules offer a variety of functions for generating random numbers. Choosing the right method depends on your specific needs:

• Basic Random Integers: Use random—randint (a, b) to generate integers within a specified range (inclusive).
• Random Floats: Use random. Random () for numbers between 0.0 (inclusive) and 1.0 (exclusive) or random.uniform(a, b) for a specific range of floating-point numbers.
• Shuffling Sequences: Use random. Shuffle (sequence) to randomize the order of elements within a list, tuple, or string.
• Selecting Random Elements: Use random. Choice (sequence) to pick a single random element or random—sample (sequence, k) to select specific unique elements.
• Cryptographically Secure Random Numbers: Use secrets.token_bytes(n) or secrets—rand below (max value) for security-sensitive tasks requiring true randomness.

Important Note: Consider using NumPy’s random module for efficient vectorized random number generation in numerical computing tasks.

By understanding the functionalities of each method, you can select the most appropriate one for your specific application.

Avoiding Bias in Randomization

One of the critical aspects of effective random number generation is ensuring unbiased results. Here are some ways to prevent bias:

• Seeding Carefully: While seeding can be useful for reproducibility, use it judiciously. Inadequate seeding can lead to predictable sequences, especially if the seed value is easily guessable.
• Uniform Distribution: When generating random numbers from a specific range, ensure the range encompasses all the desired values. Unequal ranges can introduce bias towards values with a larger representation within the range.
• Shuffling Thoroughly: Employ random. Shuffle multiple times for longer sequences to ensure a more even distribution of randomness across all elements.

Handling Edge Cases (e.g., Division by Zero)

Randomness can sometimes lead to unexpected outcomes in your code. Here’s how to handle potential edge cases:

• Division by Zero: If your code involves random number generation and division, incorporate checks to avoid division by zero when a random zero value is generated.
• Out-of-Bounds Values: When working with random indices or positions, implement checks to prevent accessing elements outside the valid range of a list or array.
• Error Handling: Consider gracefully incorporating error handling mechanisms to handle unexpected scenarios arising from random number generation.

By following these best practices and being mindful of potential pitfalls, you can ensure that your Python code leverages randomness effectively and avoids introducing unintended biases or errors.

Conclusion: The Power of Randomness in Python

This comprehensive guide has explored the captivating realm of random numbers in Python. We’ve delved into the core functionalities of the random and secrets modules, equipping you with the tools to introduce an element of chance into your programs.

Summary of Key Concepts and Techniques

• Generating Random Numbers: We explored functions like random. randint for integers, random. Random and random. Uniform for floats and random. Choice and random. Sample for selecting elements from sequences.
• Shuffling and Randomizing Sequences: The random. A Shuffle function was introduced to randomize the order of elements, while techniques for selecting random subsets were discussed.
• Simulating Random Events: We saw how to model events with probabilities using random. Random and functions like random. randint for simulating coin flips and dice rolls.
• Advanced Techniques: Seeding for reproducibility, using random. getstate and random. Set state to manage random states across runs and generate random strings with random. Choices were covered.
• Security Considerations: The limitations of pseudo-random numbers and the importance of using the secrets module for cryptographically secure random numbers in security-sensitive applications were emphasized.
• Practical Examples: We brought these concepts to life with examples like simulating random walks, creating random mazes, and generating secure passwords.

Beyond the core modules, we ventured into the functionalities offered by random2 for Python 2 compatibility and NumPy’s random module for efficient vectorized random number generation in numerical computing tasks.

Finally, we discussed best practices and common errors to ensure you leverage randomness effectively in your Python programs, avoiding unintended bias and handling edge cases gracefully.

The Impact of Random Numbers in Various Applications

Random numbers are not just a source of amusement; they play a crucial role in various applications:

• Simulations: Random numbers empower us to create realistic simulations of complex systems, from weather patterns to financial markets, allowing us to study their behavior under different conditions.
• Game Development: From the dice roll to the movement of enemies, random numbers are the lifeblood of games, injecting an element of surprise and keeping gameplay engaging.
• Data Security: Anonymizing data by shuffling or masking sensitive information with random numbers helps protect individual privacy.
• Machine Learning: Training robust machine learning algorithms often require diverse datasets. Random number generation helps create this variety, preventing the algorithm from developing biases based on a limited set of predictable data.

By mastering random number generation techniques in Python, you unlock a vast potential for creating innovative, dynamic, and secure applications. So, unleash the power of randomness in your Python programming endeavors!

Frequently Asked Questions 

This section addresses some commonly encountered questions regarding random number generation in Python:

What if I need a random number outside the standard range (e.g., negative integers)?

The random. randint(a, b) function allows you to generate random integers within a specified range (inclusive). To create negative integers, set a to the desired negative starting point and b to a positive value. For instance, random.randint(-10, 0) will generate random integers between -10 and 0 (inclusive).

Here’s an example:

Python

# Generate a random integer between -10 and 0

random_number = random.randint(-10, 0)

print(random_number)

This code can produce any integer from -10 to 0, including -10 and 0.

How can I generate random numbers from a custom distribution (e.g., normal distribution)?

The built-in random module offers limited functionality for generating numbers from specific distributions. However, Python libraries like NumPy provide extensive capabilities in this area.

NumPy’s random module offers functions for generating random numbers from various statistical distributions, including the normal distribution you mentioned. Here’s an example:

Python

import numpy as np

# Generate a random number from a standard normal distribution (mean 0, standard deviation 1)

random_number = np. Random.normal()

print(random_number)

NumPy’s random module also supports binomial, Poisson, and exponential distributions. Refer to NumPy’s documentation for details on available distributions and their parameters.

How can I ensure randomness across different program runs?

By default, the random module uses an unpredictable seed value based on system time. This ensures different program runs generate different random sequences. However, if you require repeatable results, you can leverage seeding.

The random. The seed (seed_value) function sets a specific starting point for the random number generation algorithm. Any subsequent program runs with the same seed will produce the same sequence of random numbers.

Here’s an example:

Python

# Set a seed value for reproducible results

random.seed(1234)

# Perform random operations (these will generate the same sequence each time)

# Reset the seed to avoid unintended consequences in subsequent code

random.seed()  # Resets to system time-based seed

Important Note: Use seeding judiciously. In most cases, true randomness is preferable. Seeding can introduce bias if not used carefully.

When should I use secrets instead of random?

Use the secrets module whenever true randomness is critical, especially for security-sensitive applications. The random module generates pseudo-random numbers, which are good for most general-purpose applications. However, they might be theoretically predictable, especially for someone with knowledge of the algorithm.

Here are some scenarios where secrets are recommended:

• Generating encryption keys
• Creating session tokens
• Randomizing initialization vectors (IVs) for encryption

The secrets module offers functions specifically designed for cryptographically secure random number generation:

• Secrets.token_bytes(n): Generates random bytes for various security purposes.
• Secrets. and below (max value): Generates a random integer to a specified maximum value using a cryptographically secure random number generator.

By using secrets in security-critical contexts, you can ensure higher unpredictability and strengthen your application’s defenses.