# The Random Module in Python

Generating random numbers is required for different reasons. For example, creating a random number as a user’s password or pin code etc.

Python makes it quite easy creating the random numbers whether it is the matter of creating a random number within a range, integer numbers as well as generating floating random numbers.

The built-in module random has a number of functions to fulfill that purpose. A few of these functions include:

- Randrange
- Randint
- Random
- Shuffle
- Choice

Few of these functions are for generating the integer random number while other generate float numbers. The next section shows you examples of these functions.

**Generating a random integer number by Randrange**

The randrange function returns a random number for the given range. This function can be used in two ways. The syntax of first way is:

random.randrange(stop)

In that case, the maximum number is provided and a random number is generated between 0 to that number (inclusive).

The example below generates a random number between 0 and 500 by using randrange function:

1 2 3 4 5 6 7 8 9 |
# Generate Random Numbers - RandRange demo import random rand_num = random.randrange(500) print (rand_num) |

The other way of using this function is providing the

**start, stop and step**arguments as follows:

random.randrange(start, stop[, step])

The start and stop numbers are inclusive.

The following example shows generating a random number between 10 to 1000 that must be even.

**The code:**

1 2 3 4 5 6 7 8 9 |
# Generate Even Random Numbers in range import random rand_even = random.randrange(10, 1000, 2) print (rand_even) |

Similarly, a random odd number between 1 to 500 can be created as follows:

1 2 3 4 5 6 7 8 |
# Generate Odd Random Numbers in range import random rand_odd = random.randrange(1, 500, 2) print (rand_odd) |

**The example of using randint number**

As the name shows, this random module’s function is used to generate an int pseudo-random number. The syntax for using the randint function is:

random.randint(a, b)

The arguments **a and b** must be integer values. It returns ValueError if floating point numbers are given as argument.

The examples below show generating positive, negative and a random int number either positive or negative between two values.

**Generating positive int random number**

The example below generates an int number between 5 and 50:

**The code:**

1 2 3 4 5 6 |
# Generate int random number: randint import random print("The Int Random Number: % s" % (random.randint(5, 50))) |

**Example of a negative random number:**

In this example, a negative number is generated:

1 2 3 4 5 6 7 |
# Generate negative int random number demo import random print("The negative integer number: % s" % (random.randint(-55, -5))) |

Note that the first number must be smaller than the second; otherwise, a ValueError is generated.

**Generating either negative or positive number example**

1 2 3 4 5 6 7 |
#Negative or positive random number import random print("The Random Numer (+ve or -ve): % s" % (random.randint(-15, 15))) |

**Generating pseudo-random floating point number**

In this section, we will have a look at the functions for generating the floating numbers. The first function is random that returns the next random floating point number.

This random function does not take any argument and used as follows:

random.random()

If used that way, it returns a random floating number in the range of 0.0 and 1.0.

The example below shows displaying a number:

1 2 3 4 5 6 7 8 9 |
#Floating number demo import random flt_ran = random.random() print("Floating Point Random Number [0.0 , 1.0]: ", flt_ran ) |

**Generating random floating point number between 0.0 and 5.0**

1 2 3 4 5 6 7 |
import random flt_ran_five = random.random()*5 print("Floating Point Random Number [0.0 , 5.0]: ", flt_ran_five ) |

**An example of using uniform function**

The uniform function of the random module also returns the floating point random number. The difference is, you may specify a range, unlike the random function that returns a random number between (0.0 – 1.0).

Also, the value *b* may be included in the range depending on the floating-point rounding in the equation. In the case of the random function, the 1.0 is not included.

The example below shows generating the random floating point number between (10.5, 20.5):

1 2 3 4 5 6 7 8 9 |
#Floating number demo by uniform function import random flt_rand_uni = random.uniform(10.5, 20.5) print("Floating Point Random Number in Range (10.5, 20.5): ", flt_rand_uni ) |

**The choice function **

The choice function returns a random element from a sequence like a list, tuple etc. The usage can be, for example, a lucky draw. There, you have a list of given numbers or codes that are part of the draw. The **choice** function can be used to pick a number randomly.

The syntax for using the choice function is:

random.choice(seq)

In the example below, we have a list of ten numbers. The choice method is used to return the random element and displayed on the screen.

1 2 3 4 5 6 7 8 9 10 11 |
#Choice function demo import random draw_lst = [45747, 45624, 45745, 748458, 254231, 4145474, 1458745, 584757, 589654, 968457] print("The Winning Number is: ", random.choice(draw_lst)) |

**The result as I executed this code:**

The Winning Number is: 45745

**How to use Shuffle function**

The shuffle method randomizes the elements of the sequence in place. For example, if we have a list:

[1,2,3,4,5]

The shuffle function of the random module can randomize the order of elements. An example below shows a list and its output before and after using the shuffle function:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
#Shuffle function demo import random shuff_lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] #List Before print("List Before", shuff_lst) #List after shuffling random.shuffle(shuff_lst) print("List After Shuffling", shuff_lst) |

**The output as I executed this code:**

List Before [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

List After Shuffling [7, 4, 9, 2, 5, 1, 6, 3, 8, 10]

Every time you run this code, it should produce a different result after using the shuffle function.