# Python Random Module

The tutorial for the Python random module demonstrates how to produce pseudo-random integers in Python.

### Random Number Generator (RNG)

The RNG (random number generator) generates a series of values with no discernible patterns in their appearance. Pseudo random number generators and hardware random number generators are the two types of random number generators. Hardware randomnumber generators are thought to generate real random numbers. Software algorithms are used to produce values in pseudo-random number generators. They generate results using software algorithms. They generate values that appear to be random. These values, on the other hand, are deterministic and may be replicated if the algorithm is understood.

Random generators are used in gaming, gambling,cryptography in computers, and simulations.

Note:Cryptographically safe pseudo-random number generators must be utilized for security reasons.

Operating systems enhance the performance of pseudo-random number generators by using environmental noise gathered via jitter, device drivers, or user input lag from one or several hardware components.This idea serves as the foundation for cryptographically safe pseudo-random number generators.

### Python Random Module

Python has a built-in module called Random that can produce random integers. These are all fake random numbers that don't actually show true randomness. To make random numbers, return a random value for a string, a list, and other tasks, use this module.Example: Getting a random value from a list and printing it.

```
# import a random number
import random
# prints a value from the list at random
List_1 = [7, 2, 4, 9, 5, 6]
print(random.choice(List_1))
```

**Output:**

2

The random module produces pseudo-random numbers, as was already explained. The randomization of the numbers is determined by the seeding value. For instance, the result of the following commands will always be the same if the seeding value is 5.

**Example: Using a seeding value to generate random numbers**

```
import random
random.seed(5)
print(random.random())
print(random.random())
```

**Output:**

```
0.62290169488
0.74178698926
```

The given code will always produce the same result. It cannot, therefore, be used for encryption.

Let's look at the more common tasks that this module completes.

### What is Seed?

The random number generator is started using a seed, which is a number. Random number generators generate values by modifying a prior value in some way. The seed is the starting value on which the generator functions when the algorithm starts. The generators' extremely crucial and difficult task is to generate a seed that is close to a truly random number.

The random.seed method in Python provides the seed value. Python utilizes the system clock or another unexpected source if the values are not explicitly specified.

Note:The seed yields the same set of pseudo-random numbers every time.

### How does Seed Function Works?

The seed method saves the state of a random method so that it can create the same kind of random numbers on repeated executions of the code on the same kind or different machines (for a specific seed value). The past value number created by the generator is the seed value.It utilizes the current system time for the 1st time if there is no past value.

The random.seed() function is used.

Here we'll demonstrate how to use the same seed value to get the same random number all time.

**Example 1:**

```
# Importing a random module
import random
for j in range(5):
# In place of '0,' any number can be used.
random.seed(0)
# The produced random number will range from one to a thousand.
print(random.randint(1, 1000))
```

**Output:**

```
865
865
865
865
865
```

**Example 2:**

```
# A random module is imported
import random
random.seed(3)
# a number between one and thousand, printed at random
print(random.randint(1, 1000))
# If you had like to acquire the same kind of random number repeatedly,
random.seed(3)
print(random.randint(1, 1000))
# If you do not use the seed method,
# Responds in a completely unforeseen manner.
print(random.randint(1, 1000))
```

**Output:**

```
244
244
607
```

When the preceding code is run, the first two print statements will produce a response of 244, but the third print statement will produce an unknown result.

### Uses of Random.seed()

- This is how a pseudo-random encryption key is generated. Computer security relies heavily on encryption keys. These are the types of secret keys that are used to safeguard data on the internet from unauthorized access.
- It simplifies code optimization when random numbers are utilized for testing. The code's output is sometimes influenced by the input. As a result, using random numbers to evaluate algorithms might be difficult. The seed function is also used to create the same random numbers over and over again, making the algorithm testing process easier.

### Creating Random Integers

In Python3, randint() is an in-built function of the random module. The random module provides access to a number of useful methods, one of which is the ability to create random numbers, is the randint() function.

**Syntax:**

randint(start, end)

**For example: **Making up random numbers

```
# An explanation of the randint() method in Python 3
# random module to be imported
import random
# creates random numbers within a specified positive range.
R_1 = random.randint(5, 15)
print("A number at random among5 and 15 is % s." % (R_1))
# a random number is produced among two specified negative ranges.
R_2 = random.randint(-11, -2)
print("A random value among -11 and -2 is % d." % (R_2))
# a random number among a positive as well as a negative range is produced.
R_3 = random.randint(-3, 3)
print("A random value among -3 and 3 is % d." % (R_3))
```

**Output:**

```
A number at random among5 and 15 is 8.
A random value among -11 and -2 is -6.
A random value between -6 and 6 is -2.
```

### Creating Random Floats

Random floating values in the range [0.1, 1.0) are generated using the random.random() function. (Note the opening and closing brackets; they indicate that 0 is included but 1 is excluded.) It doesn't require any parameters and returns values that are evenly spread between 0 and 1.

**Syntax:**

random.random()

**Parameters:** There are no parameters for this procedure.

**Returns:** This method generates a floating number among 0 and 1 at random.

**For example:**

```
# A random() method demonstration application in Python 3.
# random import
from random import random
# random item printed
print(random())
```

**Output:**

0.371793355

### Selecting Random Elements

The Python programming language has an inbuilt method called choice() that returns a random item from a string, tuple, or list.

**Syntax****:**

random.choice(sequence)

**Parameters: **A list, tuple, or string can be used as the sequence parameter.

**Returns: **A random object is returned by choice().

**For instance**: Choosing elements at random from a string, tuple, or list.

```
# Python 3 example program for the choice() function
#random import
import random
# a value at random from the list is printed.
List_1 = [5, 4, 2, 6, 1, 3]
print(random.choice(List_1))
# a random element is printed from the string
str = "javaTpoint"
print(random.choice(str))
# a random element from the tuple is printed.
Tuple_1 = (5, 6, 7, 8, 9)
print(random.choice(Tuple_1))
```

**Output:**

```
3
T
7
```

### Shuffling List

The random module has an inherent method called shuffle(). It's used to shuffle a list of items (list). The process of rearranging the sequence's components is referred to as "shuffle".

**Syntax:**

random.shuffle(sequence, function)

**Parameters**

Here are the following parameters, such as:

- A list can be used as a sequence.
- Function: this is an optional feature that is set to random by default (). It should return a number between 0 and 1 as a result.

**Returns:** Nothing is returned

**For example: **A list is being shuffled.

```
# the random module be imported
import random
# initialization of a list
sample__list = [5, 6, 7, 8, 9]
print("Actual list: ")
print(sample__list)
# 1st shuffle
random.shuffle(sample__list)
print("\nRight after the 1st shuffle: ")
print(sample__list)
# 2nd shuffle
random.shuffle(sample__list)
print("\nRight after the 2nd shuffle : ")
print(sample__list)
```

**Output:**

```
Actual list:
[5, 6, 7, 8, 9]
Right after the 1st shuffle:
[8, 9, 5, 7, 6]
Right after the 2nd shuffle:
[6, 5, 9, 8, 7]
```

### Pick a Random Sample

sample() is a built-in method in Python's random module that returns a specific length list of items from a sequence, such as a string, tuple, list, or set. Used for non-replacement random sampling.

**Syntax:**

random.sample(sequence, k)

**Parameters:**

- sequence: A list, tuple, string, or set can be used as a sequence.
- k: K is an integer value that specifies the sample length.

**Returns****:** Returns a new k-length list of entries from the sequence.

**For example:**

```
# A Python3 program is used to show how to utilize the sample() method.
# Random import
import random
# Prints a list of three random elements from the supplied list.
List_1 = [6, 7, 8, 9, 10, 11]
print("Within list:", random.sample(List_1, 3))
# Prints a list of four random elements from the supplied string.
String_1 = “javaTpoint"
print("Within string:", random.sample(String_1, 4))
# prints a list of four random elements from the supplied tuple.
Tuple_1 = (“Aman”, “Rohit”, “Science”, “Python”, “Java”, “Computer”)
print("Within tuple:", random.sample(Tuple_1, 4))
# prints a list of three random elements from the supplied set.
Set_1 = {"f", "g", "h", "k", "j"}
print("Within set:", random.sample(Set_1, 3))
```

**Output:**

```
Within list: [9, 6, 11]
Within string: [‘T’, ‘j’, ‘a’, ‘p’]
Within tuple: [‘Computer’, ‘Aman’, ‘Python’, ‘Rohit’]
Within set: [‘j’, ‘k’, ‘f’]
```

### Selecting Multiple Random Elements

Multiple random items from the list with replacements are returned by the choices() method. With the weights or cum weights parameter, you can adjust the likelihood of each result. A string, a range, a list, a tuple, or any other type of sequence can be used as an element.

**Syntax:**

random.choices(sequence, weights=None, cum_weights=None, k=1)

**Parameters:**

**sequence:**sequence, which may be string, tuple, or a list, is a required argument.**weights:**The available parameter weights are used to balance the likelihood of each value.**cum_weights:**The cum weights argument, which is optional, is used to weigh the likelihood for each value, however, in this case, the likelihood is aggregated.**k:**The length of the returned list is determined by the optional parameter k.

Note:As opposed to random.choice(), this technique is distinct.

**For example:**

```
# random import
import random
My_list = ["java", "point", "python"]
print(random.choices(My_list, weights = [10, 1, 1], k = 5))
```

Note:As the system returns random components, the output will vary every time.

**Output:**

[‘java’, ‘java’, ‘java’, ‘point’, ‘point’]

### List of Methods in Random Module

Below is a list of every method in the random module:

Function Name | Description |

seed() | A random number generator is started. |

getstate() | An object containing the random number generator's internal state at the moment is returned. |

setstate() | Utilized to return the random number generator's state to the desired state |

getrandbits() | Deliver an integer with the required amounts of bits. |

randrange() | A random number from the specified range is returned. |

randint() | A random integer inside the specified range is returned. |

choice() | A random element is returned from a string, tuple, or list. |

choices() | Returns several random items with change from the list. |

sample() | Returns a list of items from the order, each of a specific length. |

random() | Create random floating-point numbers |

uniform() | Provide a random floating-point value among two inclusive numbers. |

triangular() | A random floating-point value with a bias towards an extreme from a range is returned. |

betavariate() | A random floating-point number with a beta distribution is returned. |

expovariate() | A random floating-point number with an exponential distribution is returned. |

gammavariate() | A random floating-point number with a Gamma distribution is returned. |

gauss() | A random floating-point number with a Gaussian distribution is returned. |

lognormvariate() | A random floating-point value with a log-normal distribution is returned. |

normalvariate() | A random floating-point value with a normal distribution is returned. |

vonmisesvariate() | Generate a random floating-point number using the von Mises distribution or the circular normal distribution. |

paretovariate() | Return a Pareto-distributed random floating-point number. |

weibullvariate() | Return a Weibull-distributed random floating-point number. |