Enable Dark Mode!
By: Arwa VV

# Random module in NumPy

## Technical

NumPy, short for Numerical Python, is a fundamental library in Python for numerical computations. One of its prominent modules, NumPy Random, provides a wide array of tools for generating random numbers and arrays with diverse distributions. In this blog, we will delve into the functionalities of NumPy Random.

(This blog is a continuation from our previous blog on NumPy. If you're new to NumPy or need a refresher on its basics, consider referring to our previous blog post on NumPy Introduction for a comprehensive understanding. If you want to know about the universal functions (ufuncs) of NumPy, refer our blog. )

### Random Numbers

Random number generation is a crucial part of many scientific computing tasks. NumPy's numpy.random module in Python provides a versatile suite of tools for generating random numbers and arrays.

To generate random numbers:

1. random.rand() generates random values between 0 and 1.

`from numpy import randomx = random.rand()print(x)`

Output of this will be a float between 0 and 1.

To generate a 2x3 array of random values, you can specify the shape.

`from numpy import randomrandom_array = random.rand(2, 3)print(random_array)`

2. random.randint() generates random integers within a specified range.

To generate a random integer in the range of 1 to 10:

`from numpy import randomrandom_int = random.randint(1, 11)print(random_int)`

This will return any integer between 1 and 10

The shape of the array can be specified using the size parameter.

To generate a 1-D array containing 4 random integers from 0 to 50:

`from numpy import randomx=random.randint(50, size=(4))print(x)`

To generate a 2-D array with 3 rows containing 5 random integers each from 0 to 50:

`from numpy import randomx = random.randint(50, size=(3, 5))print(x)`

3. random.choice() is used to generate a random sample from a given 1-D array.

`from numpy import randomrandom = random.choice([1, 2, 3, 4, 5])print(random)`

### Random Permutations

In NumPy, random permutations refer to the reordering or shuffling of elements in an array.

1. random.permutation() function produces an array or sequence permutation that results in a shuffled version of the items. It's useful for applications like shuffling data, randomizing sequences, or creating randomized indices for sampling.

`from numpy import randomimport numpy as nparray = np.array([1, 2, 3, 4, 5])random_permutation = np.random.permutation(array)print(random_permutation)`

This function returns a new array containing a shuffled version of the elements from the input array. It doesn't modify the original array; instead, it produces a randomized order of the elements each time it's called.

2. random.shuffle() can be used if you want to shuffle the elements of an array in place without creating a new array.

`from numpy import randomimport numpy as nparray = np.array([1, 2, 3, 4, 5])random.shuffle(array)print(array)`

### Normal (Gaussian) Distribution

The normal distribution, also known as the Gaussian distribution, is a fundamental probability distribution that appears in numerous natural phenomena. In NumPy's random module, generating random numbers following a normal distribution is a common task. The random.normal() function is used to create an array of random numbers following this distribution.

Syntax:

`random.normal(loc=0.0, scale=1.0, size=None)`

loc: The mean (center) of the distribution.

scale: The standard deviation (spread or width) of the distribution.

size: The shape of the output array. If not provided, a single value is returned.

`from numpy import randommean = 0    # Meanstd_dev = 1 # Standard deviation# Generating a 1x5 array of random values from a normal distributionnormal_array = random.normal(mean,std_dev, size=(1, 5))print(normal_array)`

The random.normal() function generates random numbers that follow a normal distribution characterized by a specified mean (loc) and standard deviation (scale).

Mean is the distribution's center or average value and the std_dev is the spread or width of the distribution. If not provided, a single random value will be returned.

### Binomial Distribution

In probability theory, the number of successes in a certain number of independent Bernoulli trialsâ€”each of which has a binary result (success or failure) with a constant chance of success represented by the letter "p"â€”is described by the binomial distribution.  In NumPy's random module, the random.binomial() function is used to simulate random variates following a binomial distribution.

Syntax:

`random.binomial(n, p, size=None)`

n: Number of trials or experiments.

p: Probability of success for each trial.

size: Shape of output array. If not given, a single value is returned.

`from numpy import randomnum_trials = 10    # Number of trialsprobability = 0.5  # Probability of success# Generating a random value representing successes in 10 trials with a success probability of 0.5binomial_result = random.binomial(num_trials, probability)print(binomial_result)`

The random.binomial() function generates random numbers that follow a binomial distribution.

The parameter n represents the number of trials or experiments, while p denotes the probability of success for each trial.

The size parameter indicates the shape of the output array. If not specified, a single random value representing the number of successes is returned.

Given the given probability of success for each trial, the random values created by random.binomial() indicate the count of successes that occur in a specific number of trials.

#### Poisson Distribution

A probability distribution called the Poisson distribution describes how many events, occurring at a known constant rate and regardless of the amount of time that has passed since the last event, will take place in a given period of time or space. In NumPy's random module, the random.poisson() function is utilized to generate random numbers that follow a Poisson distribution.

Syntax:

`random.poisson(lam=1.0, size=None)`

lam: The rate or mean of the Poisson distribution (average number of events occurring in the interval).

size: The shape of the output array. If not provided, a single value is returned.

`from numpy import randomaverage_rate = 3.0  # Average number of events per interval# Generating a random value from a Poisson distribution with an average rate of 3 eventspoisson_result = random.poisson(average_rate)print(poisson_result)`

The random.poisson() function generates random numbers that follow a Poisson distribution characterized by the average rate of lam.

The lam parameter represents the mean or average number of events occurring in the interval. It denotes the rate at which events happen.

The size parameter indicates the shape of the output array. If not specified, a single random value representing the number of events is returned.

The generated random values using random.poisson() represent the count of events occurring in a fixed interval of time or space, given the specified average rate at which these events occur.

### Uniform Distribution

A probability distribution known as the uniform distribution gives each value within a range an equal chance of happening. In NumPy's random module, the random.uniform() function is used to generate random numbers following a uniform distribution.

Syntax:

`random.uniform(low=0.0, high=1.0, size=None)`

low: The lower boundary of the output range.

high: The upper boundary of the output range.

size: The shape of the output array. If not provided, a single value is returned.

`from numpy import random# Generating random values from a uniform distribution within the range [1, 10)# Generating a single random valuerandom_value = random.uniform(1, 10)print(random_value)`

The random.uniform() function generates random numbers from a uniform distribution within the specified range [low, high).

The low parameter represents the lower boundary of the range, while high denotes the upper boundary.

The size parameter indicates the shape of the output array. If not specified, a single random value within the range is returned.

### Logistic Distribution

A probability distribution with heavier tails than the normal distribution is called the logistic distribution. In NumPy's random module, the random.logistic() function is used to generate random numbers following a logistic distribution.

Syntax:

`random.logistic(loc=0.0, scale=1.0, size=None)`

loc: The mean or location parameter of the distribution.

scale: The scale or standard deviation parameter of the distribution.

size: The shape of the output array. If not provided, a single value is returned.

`from numpy import random# Generating random numbers from a logistic distributionmean = 0   scale = 1  # Generating a 1x5 array of random values from a logistic distributionlogistic_array = random.logistic(mean, scale, size=(1, 5))print(logistic_array)`

The random.logistic() function generates random numbers that follow a logistic distribution.

The loc parameter represents the mean or location parameter of the distribution, specifying the center around which the distribution is centered.

The scale parameter denotes the scale or standard deviation of the distribution, influencing the spread or width of the distribution.

The size parameter indicates the shape of the output array. If not specified, a single random value or an array of random values is returned.

Similar to the normal distribution, the logistic distribution is bell-shaped and symmetric, but it's tails are longer. It is commonly used in various fields, including statistics, economics, and modeling, where a distribution with heavier tails than the normal distribution is required.

### Exponential Distribution

When events happen continuously, independently, and at a constant average rate in a Poisson process, the time interval between them is modelled by the exponential distribution, which is a probability distribution. The random.exponential() function in NumPy's numpy.random module is used to produce random numbers with an exponential distribution.

Syntax:

`numpy.random.exponential(scale=1.0, size=None)`

scale: The scale parameter, also known as the inverse of the rate parameter. It represents the average time between events.

size: The shape of the output array. If not provided, a single value is returned.

`from numpy import random# Generating random numbers from an exponential distributionaverage_time = 2.0  # Average time between events# Generating a 1x5 array of random values from an exponential distributionexponential_array = random.exponential(average_time, size=(1, 5))print(exponential_array)`

The random.exponential() function generates random numbers that follow an exponential distribution.

The scale parameter represents the average time between events or the mean of the distribution. It is the inverse of the rate parameter (?) in the exponential distribution.

The size parameter indicates the shape of the output array. If not specified, a single random value or an array of random values is returned.

The exponential distribution is characterized by a continuous probability density function that describes the time it takes for an event to occur in a Poisson process. It is commonly used in various fields, such as reliability engineering, queuing theory, and telecommunications, where the modeling of time-to-failure, waiting times, or arrival times of events is crucial.

#### Zipf Distribution

The Zipf distribution is a discrete probability distribution that models data where elements have different frequencies of occurrence, where the frequency of any element is inversely proportional to its rank in a given dataset. In NumPy's random module, the random.zipf() function is used to generate random numbers that follow a Zipf distribution.

Syntax:

`numpy.random.zipf(a, size=None)`

a: The parameter defining the shape of the distribution.

size: The shape of the output array. If not provided, a single value is returned.

`from numpy import random# Generating random numbers from a Zipf distributionparameter_a = 2.0  # Shape parameter# Generating a 1x5 array of random values from a Zipf distributionzipf_array = random.zipf(parameter_a, size=(1, 5))print(zipf_array)`

The random.zipf() function generates random numbers that follow a Zipf distribution.

The â€˜aâ€™ parameter defines the shape of the distribution. It represents the parameter controlling the shape of the distribution and should be greater than 1.

The size parameter indicates the shape of the output array. If not specified, a single random value or an array of random values is returned.

The Zipf distribution is commonly used to model phenomena where a few elements occur frequently while the majority occur rarely. It is often observed in various fields such as linguistics (word frequencies in natural languages), information retrieval (web page accesses), and the distribution of city populations.

#### Rayleigh Distribution

The distribution of vector component magnitudes is modeled by the Rayleigh distribution, which is a continuous probability distribution. In NumPy's random module, the random.rayleigh() function is employed to generate random numbers that follow a Rayleigh distribution.

Syntax:

`numpy.random.rayleigh(scale=1.0, size=None)`

scale: The scale parameter, representing the mode or the square root of the mean of the distribution.

size: The shape of the output array. If not provided, a single value is returned.

`from numpy import random# Generating random numbers from a Rayleigh distributionscale_parameter = 2.5  # Scale parameter# Generating a 1x5 array of random values from a Rayleigh distributionrayleigh_array = random.rayleigh(scale_parameter, size=(1, 5))print(rayleigh_array)`

The random.rayleigh() function generates random numbers that follow a Rayleigh distribution.

The scale parameter represents the scale or mode of the distribution, and it influences the spread or width of the distribution.

The size parameter indicates the shape of the output array. If not specified, a single random value or an array of random values is returned.

The Rayleigh distribution is commonly used in various fields such as signal processing, telecommunications, and engineering. It often appears when modeling the magnitude of a two-dimensional vector whose components are independent and identically distributed with a normal distribution.

These are some of the NumPy random functions. In conclusion, NumPy's random tools are like a treasure trove for anyone dealing with numbers in Python. They help generate all sorts of random numbers - from simple coin tosses to more complex scenarios.

If you need any assistance in odoo, we are online, please chat with us.

### Recent Posts

#### How to Create Odoo JS Dialog/Popup in Odoo 17

Calicut

Cybrosys Technologies Pvt. Ltd.
Neospace, Kinfra Techno Park
Kakkancherry, Calicut
Kerala, India - 673635

Kochi

Cybrosys Technologies Pvt. Ltd.
1st Floor, Thapasya Building,
Kochi, India - 682030.

Bangalore

Cybrosys Techno Solutions
The Estate, 8th Floor,