## Introduction to NumPy random

A Random number is a number that is generated without following any logic or pattern so that it cannot be used again for any process; such kind of random number generation is very useful in the security or encryption of crucial information and so serve this purpose python has a library that performs a variety of numerical operation very easily called Numpy (Numerical Python) which can be used in the generation of Pseudo-Random numbers using BitGenerator that gives different combinations of sequences and the Generator then transforms the sequences into numbers following probability distribution.

### Syntax

Numpy can be used to generate a Random sequence for various data types like float, int, array, etc. Random number generation is performed by importing the Random package from the Numpy library. The basic syntax for numpy random generation is

```
from numpy import random
randint(int)
```

### Examples of NumPy random

Let us discuss a different example in which we use different random generation techniques for better understanding.

#### Example #1

**Code:**

```
from numpy import random
a = random.randint(10)
b= random.randint(50)
print(a)
print(b)
```

**Output:**

In this example, we have imported the random package from the numpy library to perform the operation. We have generated random integer a & b using the numpy random.randint() syntax and the value we gave in the bracket is the maximum limit for generating a random number. The output 4 is below the 10 that we have declared, and 44 is below the 50 that we have declared.

#### Example #2

We Numpy random to generate a list of float values in this example,

**Code:**

```
from numpy import random
a = random.rand()
b= random.rand(5)
print(a)
print(b)
```

**Output:**

In this example, we have used the random.rand() syntax, which allows us to generate float values. In the variable ‘a’, we haven’t declared any number, so it generates a random float from 0 to 1 in default. In variable ‘b,’ we have declared a limit of 5, so we have a list of 5 random float values. We can declare any number to generate float values of that limit we have declared.

#### Example #3

In this example, we’ll discuss the random generation of numpy arrays using a similar syntax we used in the previous examples.

**Code:**

```
from numpy import random
a = random.randint(10, size=(3))
b= random.randint(50, size=(7))
print(a)
print(b)
```

**Output:**

We have used the randint syntax and declared the maximum limit and the size of the sequence we are generating in this example. This method is a random generation of 1-dimensional arrays. For ‘a’, we have declared the maximum limit to be 10 and the length of the sequence to be 3, and for ‘b,’ we have declared the maximum limit to be 50 and the length of the sequence to be 7, and we got the corresponding output.

Similarly, we’ll try to generate 2-dimensional arrays in the following code.

**Code:**

```
from numpy import random
a = random.randint(10, size=(3,3))
b= random.randint(50, size=(5,5))
print(a)
print(b)
```

**Output:**

Using a similar code, we have generated the 2-dimensional random arrays by declaring the size of the generation in two dimensions. For example, in variable ‘a’, we have declared the maximum limit to be 10 and the length of the sequence to be 3, 3 which is a two-dimensional array, and for ‘b,’ we have declared the maximum limit to be 50 and the length of the sequence to be 5, 5, and we got the corresponding 2-dimensional array as output.

We can also generate 3-dimensional arrays using the same technique as shown below.

**Code:**

```
from numpy import random
a = random.randint(10, size=(3,2,1))
print(a)
```

**Output:**

**Code:**

```
from numpy import random
b= random.randint(50, size=(5,2,1))
print(b)
```

**Output:**

In the above example, we have generated 3-dimensional random arrays for variables ‘a’ and ‘b’ where the size we have ‘a’ we have declared the maximum limit to be 10 and length of the sequence to be (3, 2, 1), which is a two-dimensional array and for ‘b’ we have declared the maximum limit to be 50 and length of the sequence to be (5,2, 1) and we got the corresponding 3-dimensional array as output.

#### Example #4

In the previous example, we have discussed the generation of multiple dimensional arrays using the integer values; here, we will discuss the generation of float values.

**Code:**

```
from numpy import random
a = random.rand(3,2)
b = random.rand(5,2)
print(a)
print(b)
```

**Output:**

When we are using the random.rand syntax, it generates float values as default form 0 to 1, so when we declared the size of the random generation in two dimensions as we did in the above code where ‘a’ and ‘b’ is given a two-dimensional size of (3,2) & (5,2) we get the two-dimensional float array.

Similarly, for 3-dimensional float array,

**Code:**

```
from numpy import random
a = random.rand(3,2,2)
b = random.rand(5,2,2)
print(a)
print(b)
```

**Output:**

So in this code, we have declared the three-dimension size for a & b as (3,2,2) & (5,2,2), so we got the output in a three-dimensional array.

#### Example #5

Another method in Numpy random generation uses a function as a choice(), which allows the computer to choose a random choice from the given sequence of values.

**Code:**

```
from numpy import random
a = random.choice([8, 10, 16])
b= random.choice([80, 100, 160,1100])
print(a)
print(b)
```

**Output:**

In this method, we use a function called choice(), which allows the computer to randomly select a value from the array of values that the user declares.

The choice() function gets an array as input and gives a randomly selected value as output. Thus, we can give an array of any length and can generate a random value from it.

Similarly, we can generate multi-dimensional arrays using the choice() function by giving the size of the dimension.

**Code:**

```
from numpy import random
a = random.choice([8, 10, 16],size=(3, 2))
b= random.choice([80, 100, 160,1100],size=(5, 2))
print(a)
print(b)
```

**Output:**

So using the choice() function, we can declare the size and generate 2-dimensional and 3-dimensional arrays from the array we have declared.

### Conclusion

In this article, we have discussed Numpy random in detail using various examples. We have also discussed how to generate random values using integers, floats, and arrays. We also discussed different techniques for generating multi-dimensional arrays numpy random can be very helpful for working in various projects involving random sequence generation.

### Recommended Articles

This is a guide to NumPy random. Here we discuss the Examples of NumPy random and different random generation techniques for better understanding. You may also have a look at the following articles to learn more –

4 Online Courses | 5 Hands-on Projects | 37+ Hours | Verifiable Certificate of Completion

4.5

View Course

Related Courses