How to generate random integers between 0 and 9 in Python? To generate random integers between 0 and 9, you can use the `randint()`

function.

Besides the randint() function, there are more methods like, `randrange()`

, `choice()`

, and `uniform()`

methods from the built-in `random`

module. In this article, we will discuss each of these methods along with Python examples.

## 1. Quick Examples of Generating Random Integers

These quick examples will give you a high-level idea of different ways to generate random integers between 0 and 9. We will discuss each method in more detail.

```
# Quick examples of generating random integers
# Imports
import random
import secrets
# randint() method from the random module
print(random.randint(0, 9))
# randrange() method from the random module
print(random.randrange(0, 10))
# choice() method from the random module
print(random.choice(range(10)))
# uniform() method from the random module
print(int(random.uniform(0, 9.99)))
# randbelow() method from the secrets module
print(secrets.randbelow(10))
```

## 2. randint() – Random Integers Between 0 and 9

The `randint()`

method is a built-in function in the `random`

module that generates a random integer between two specified endpoints, inclusive. This means that both parameters will be included in the range. This one is probably the most common way to generate random numbers in Python

**Related:** Python random.sample() with Examples

To generate a random integer between 0 and 9 using randint(), we can simply call the function with the arguments `0`

and `9`

.

```
# Using random.randint() to generate random
# Import random module
import random
rand_num = random.randint(0, 9)
print(rand_num)
# Output :
# 5
```

`randint()`

uses a pseudo-random number generator.- The two endpoints of the range are included.

## 3. random.choice() – Generate Random Numbers

The random.choice() is another method in the `random`

module of Python that returns a single random element from a sequence. The parameter of this method is a sequence instead of numbers.

```
# Using random.choice()
# Import random module
import random
rand_num = random.choice(range(10))
print(rand_num)
```

We can also use the `random.choices()`

method that generates a random selection from a given sequence. This time, to generate a random integer between 0 and 9 using `random.choices()`

, we can call the function with the argument `[0,1,2,3,4,5,6,7,8,9]`

and `k=1`

to specify that we want to generate only one random selection.

The `choices()`

method returns a list of selections, even if `k=1`

, so we must access the first selection using the indexing operator `[0]`

.

```
import random
rand_num = random.choices([0,1,2,3,4,5,6,7,8,9], k=1)
print(rand_num[0])
```

The `choices()`

method allows us to generate a random selection from any sequence, not just a range of integers, making it a more flexible option in certain situations.

## 4. random.sample() – Generate a Random Sample 0 to 9

We can also use random.sample() method to generate a specified random selection from a sequence. However, there are a few differences between these two methods. The only thing common between these two methods is that they both return a random selection from a sequence.

Use below code to generate a random number between 0 and 9:

```
# Using random.sample()
import random
rand_num = random.sample([0,1,2,3,4,5,6,7,8,9], k=1)
print(rand_num[0])
```

Now the first difference between the two is that `sample()`

returns a list of unique random selections from a given sequence, while `choices()`

returns a list of random selections from a given sequence that may include duplicates.

Another difference between the two methods is that `sample()`

requires that the number of selections (`k`

) be less than or equal to the length of the sequence, while `choices()`

does not have this restriction.

## 5. random.SystemRandom class – 0 to 9 Random Number

The `random.SystemRandom`

class is a subclass of the `random`

module that uses the system’s random number generator to produce random numbers. It is considered more secure than the `random`

module’s default generator, since it uses the operating system’s entropy source.

```
# Using random.SystemRandom()
import random
sys_random = random.SystemRandom()
rand_num = sys_random.randint(0, 9)
print(rand_num)
```

The `SystemRandom`

class may be slower than the default `random`

module, since it has to interact with the operating system to generate random numbers.

## 6. secrets.randbelow() – Random Number with Security

`secrets.randbelow()`

is different from the other methods in that it is specifically designed for generating cryptographically secure random numbers. `secrets.randbelow()`

is included in the Python Standard Library starting from Python 3.6.

Cryptographically secure random numbers are important for security-sensitive applications, such as password generation or encryption, as they are difficult to predict or reproduce.

See the following example:

```
# Using secrets.randbelow()
import secrets
rand_num = secrets.randbelow(10)
print(rand_num)
```

## 7. numpy.random.random_integers()

The `random_integers()`

function returns a random integer from a specified range, including both endpoints. To use `random_integers()`

to generate a random integer between 0 and 9, we can call the function with a range of (0, 9).

```
import numpy as np
rand_num = np.random.random_integers(0, 9)
print(rand_num)
```

## 8. Pseudo-random and Truly Random Numbers

A random number is one that is generated in a way that is unpredictable, statistically independent, and uniformly distributed over a given range.

There are two main types of random number generators:

### 8.1 Pseudo-Random Number Generator

Pseudo-random number generators (PRNGs) are algorithms that generate sequences of numbers that appear to be random but are actually deterministic.

That is, given the same seed value, a PRNG will always generate the same sequence of numbers. PRNGs typically use a mathematical formula, known as a seed, to generate a sequence of numbers that appears to be random.

```
import random
# Pseudo-Random Number
print(random.random())
```

### 8.2 Truly Random Number Generator

Truly random number generators (TRNGs), on the other hand, generate random numbers using physical processes that are inherently unpredictable.

To generate truly random numbers in Python, you can use the secrets module, which provides access to hardware-based random number generators.

```
import secrets
# Generate a random integer between 0 and 9
print(secrets.randbelow(10))
```

PRNGs are faster and more efficient than TRNGs, However, they are not suitable for applications that require high levels of security or randomness. Because a skilled attacker may be able to predict the sequence of numbers generated by a PRNG if they know the seed value.

## 9. Summary and Conclusion

We discussed different methods to generate random integers between 0 and 9 in Python. These methods include using the `random.randint()`

function, the `random.choices()`

method, the `random.sample()`

function, the `random.choice()`

function, the `random.SystemRandom`

class, the `secrets.randbelow()`

function. If you have any questions, please leave them in the comment section.

Happy Coding!

## References

## Related Articles

- How to generate random numbers in Python?
- Random String Generation with Letters and Digits in Python
- Python random.randint() with Examples
- Python Random seed() Function
- Python Random uniform() Function
- Python Random Module Methods Explained
- Python random.sample() With Examples
- Shuffle List in Python with Examples
- Python Random randrange() Function
- Generate Random Float Numbers in Python
- Python random.choice() function
- Python random.random() function
- Python random.choices() function