Introduction

The Python random module is a built-in module that provides functionalities related to random number generation. It is often used in scenarios where unpredictability or randomness is required, such as in simulations, games, cryptography, and data shuffling. The module uses a pseudo-random number generator algorithm to produce seemingly random numbers.

List of all the Functions  Python Random Module

Here’s a list of some key functions provided by the Python random module:

random()

Returns a random float in the range [0.0, 1.0).

import random
random_number = random.random()
print(random_number)
# Output: 0.7164296823654763 (Note: This value will vary on each run)

seed(seed=None)

Initializes the random number generator with the given seed. If no seed is provided, the system time is used.

import random
random.seed(42)
# No output, but it initializes the random number generator with seed 42

randrange(start, stop, step=1)

Returns a randomly selected element from the range(start, stop, step).

import random
random_range = random.randrange(1, 10, 2)
print(random_range)
# Output: Random number within the range [1, 10) with step 2

Want to become a python expert in 2024? Enroll in our free Python Course today!

Enroll in our free Python Course today!(a, b)

Generates a random integer in the inclusive range [a, b].

import random
random_integer = random.randint(1, 10)
print(random_integer)
# Output: Random integer within the inclusive range [1, 10]

choice(sequence)

Returns a randomly selected element from the given sequence (list, tuple, or string).

import random
my_list = [1, 2, 3, 4, 5]
random_item = random.choice(my_list)
print(random_item)
# Output: Random item from the list my_list

choices(population, weights=None, k=1)

Returns a list with k randomly selected elements from the population. The optional weights parameter allows you to assign probabilities to different elements.

import random
my_list = [1, 2, 3, 4, 5]
random_items = random.choices(my_list, k=3)
print(random_items)
# Output: List of 3 randomly selected items from my_list with replacement

shuffle(sequence)

Shuffles the elements of a sequence in place.

import random
my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)
# Output: [3, 1, 4, 5, 2] (Note: This order will vary on each run)

sample(population, k)

Returns a k-length list of unique elements chosen randomly from the population.

import random
my_list = [1, 2, 3, 4, 5]
random_sample = random.sample(my_list, k=2)
print(random_sample)
# Output: List of 2 unique items randomly chosen from my_list

uniform(a, b)

Returns a random float in the range [a, b).

import random
random_uniform = random.uniform(0.0, 1.0)
print(random_uniform)
# Output: Random floating-point number between 0.0 and 1.0 (both inclusive)

getstate()

Returns an object encapsulating the current internal state of the random number generator.

import random
state = random.getstate()
print(state)
# Output: Tuple representing the internal state of the random number generator

getrandbits(k)

Returns an integer with k random bits.

import random
random_bits = random.getrandbits(5)
print(random_bits)
# Output: Random integer with 5 bits

setstate()

Restores the state of the random number generator to a specified state, allowing for reproducibility.

import random
random.setstate(state)
# No output, but it sets the state of the random number generator back to the specified state

betavariate(alpha, beta)

Returns a random floating-point number with a beta distribution.

import random
random_beta = random.betavariate(2, 5)
print(random_beta)
# Output: Random floating-point number with beta distribution (alpha=2, beta=5)

expovariate(lambd)

Returns a random floating-point number with an exponential distribution.

import random
random_exponential = random.expovariate(2)
print(random_exponential)
# Output: Random floating-point number with exponential distribution (lambda=2)

gammavariate(alpha, beta)

Returns a random floating-point number with a gamma distribution.

import random
random_gamma = random.gammavariate(1, 2)
print(random_gamma)
# Output: Random floating-point number with gamma distribution (alpha=1, beta=2)

triangular(low, high, mode)

Returns a random floating-point number within the specified range with a bias towards the mode.

import random
random_triangular = random.triangular(1, 5, 3)
print(random_triangular)
# Output: Random floating-point number within the specified range with a bias towards 3

gauss(mu, sigma)

Returns a random floating-point number with a Gaussian distribution.

import random
random_gaussian = random.gauss(0, 1)
print(random_gaussian)
# Output: Random floating-point number with Gaussian distribution (mean=0, standard deviation=1)

normalvariate(mu, sigma)

Returns a random floating-point number with a normal distribution.

import random
random_normal = random.normalvariate(0, 1)
print(random_normal)
# Output: Random floating-point number with normal distribution (mu=0, sigma=1)

lognormvariate(mu, sigma)

Returns a random floating-point number with a log-normal distribution.

import random
random_lognormal = random.lognormvariate(0, 1)
# Output: Random floating-point number with log-normal distribution (mu=0, sigma=1)

vonmisesvariate(mu, kappa)

Returns a random floating-point number with a von Mises distribution or circular normal distribution.

import random
random_vonmises = random.vonmisesvariate(0, 4)
# Output: Random floating-point number with von Mises distribution (mu=0, kappa=4)

paretovariate(alpha)

Returns a random floating-point number with a Pareto distribution.

import random
random_pareto = random.paretovariate(2)
# Output: Random floating-point number with Pareto distribution (alpha=2)

weibullvariate(alpha, beta)

Returns a random floating-point number with a Weibull distribution.

import random
random_weibull = random.weibullvariate(1, 2)
# Output: Random floating-point number with Weibull distribution (alpha=1, beta=2)

These functions provide a set of tools for generating random numbers and working with random elements in various scenarios.

Conclusion

In conclusion, the Python random module isn’t just a collection of functions; it’s a gateway to creativity and dynamism in programming. Whether you are crafting games, enhancing user experiences, or exploring probabilistic scenarios, the random module invites you to embrace the beauty of unpredictability. Through its functions, developers can navigate the delicate balance between order and randomness, creating applications that captivate and surprise users. So, as you embark on your Python programming journey, remember to harness the power of the random module and infuse your code with the spark of randomness.

You can also read more articles related to Python here:

• How to Generate Random Numbers in Python?
• 14 Exciting Python Project Ideas for Beginners
• 6 Different Approaches to Displaying Lists in Python

Frequently Asked Questions