Generate Random Integers Between 0 and 9 in Python

By the end of this page, you will understand how to generate random integers in Python using the random module, especially for an inclusive range like 0 to 9. You will also learn the difference between common random-number functions, how inclusive bounds work, and how this is used in real programs.

Python provides random-number tools through its built-in random module. When you need a random integer in a range, the most common choice is random.randint(a, b).

import random

n = random.randint(0, 9)
print(n)

This returns a random integer between 0 and 9, and both ends are included.

That inclusive behavior is important:

• 0 is possible
• 9 is possible
• every whole number in between is possible

This matters because different Python functions use different range rules. Beginners often confuse:

• random.randint(0, 9) → includes 0 and 9
• random.randrange(0, 10) → includes 0, excludes 10
• random.random() → returns a float from 0.0 up to but not including 1.0

Why this matters in real programming:

• generating dice rolls or game values
• picking a random test case
• simulating events
• assigning random IDs for simple demos
• choosing random indexes or categories

The key concept is not just "random numbers," but choosing the right function for the kind of random value you need.

Think of random.randint(0, 9) like pressing a button on a machine that has 10 numbered balls inside: 0 through 9.

Each time you press the button, one ball comes out at random, and then goes back in for the next press.

That means:

• you always get a whole number
• the number will be somewhere between 0 and 9
• the same number can appear again later

If you instead used a function that works with floats, that would be more like getting a measuring value such as 0.3472 instead of a numbered ball.

The most direct way is:

import random

number = random.randint(0, 9)
print(number)

How it works

• import random makes Python's random tools available
• random.randint(0, 9) asks for a random integer from 0 to 9
• the result is stored in number

Example output

7

If you run it again, you might get:

2

Generate several random integers

import random

for _ in range(5):
    print(random.randint(0, 9))

Possible output:

3
0
9
4
4

Alternative: randrange

import random

number = random.randrange(10)
print(number)

This also gives a random integer from 0 to 9.

Why? Because random.randrange(10) means:

• start at 0 by default
• go up to but not including 10

So the possible results are still 0 through 9.

Consider this example:

import random

number = random.randint(0, 9)
print(number)

Step by step

1. Python loads the random module.
2. It calls randint(0, 9).
3. Python chooses one integer from this set:
   • 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
4. That chosen value is assigned to number.
5. print(number) displays it.

Trace example

Suppose Python randomly chooses 6.

• number becomes 6
• print(number) outputs:

6

If you run the same code again, Python may choose a different value, such as 1 or 9.

Another traceable example

import random

numbers = []
for _ in range(3):
    numbers.append(random.randint(0, 9))

print(numbers)

Possible step flow:

1. numbers starts as []
2. first loop: append 2 → [2]
3. second loop: append 8 → [2, 8]
4. third loop: append 0 → [2, 8, 0]
5. print the final list

Possible output:

[2, 8, 0]

Random integers in a small range appear in many practical situations.

Games

import random

enemy_strength = random.randint(0, 9)

Used for:

• simple game difficulty values
• random rewards
• dice-like mechanics

Test data generation

import random

sample_score = random.randint(0, 9)

Useful when:

• testing form validation
• generating fake input values
• simulating repeated runs

Random selection by index

import random

colors = ["red", "blue", "green", "yellow"]
index = random.randint(0, len(colors) - 1)
print(colors[index])

This pattern is common when picking an item from a list.

Simulations

import random

digit = random.randint(0, 9)

Useful in:

• random digit generation
• code puzzles
• probability experiments
• simple Monte Carlo simulations

In real projects, developers usually use random integer generation as part of a larger pattern rather than alone.

Validation before using ranges

If a range comes from configuration or user input, developers often validate it first.

import random

start = 0
end = 9

if start > end:
    raise ValueError("start must be less than or equal to end")

value = random.randint(start, end)

Generating batches of values

import random

digits = [random.randint(0, 9) for _ in range(6)]
print(digits)

This is common for:

• fake datasets
• simulations
• repeated randomized testing

Guard clauses

import random

def random_digit(enabled):
    if not enabled:
        return None
    return random.randint(0, 9)

This pattern keeps logic simple.

Choosing from known values

Sometimes developers use random.choice() instead of numeric ranges when the real goal is selecting from a predefined set.

import random

digit = random.choice([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

This is less compact than randint(0, 9), but it is useful when the allowed values are not a simple range.

Reproducible tests with seeding

import random

random.seed(42)
print(random.randint(0, 9))
print(random.randint(0, 9))

Developers do this in tests so the random output is repeatable.

1. Forgetting to import the module

Broken code:

number = random.randint(0, 9)

Problem:

• random is not defined

Fix:

import random
number = random.randint(0, 9)

2. Confusing inclusive and exclusive bounds

Broken expectation:

import random
number = random.randrange(0, 9)

Problem:

• this gives 0 through 8
• 9 is excluded

Fix:

import random
number = random.randrange(0, 10)

Or simply:

import random
number = random.randint(0, 9)

3. Using random.random() when you need integers

Broken code:

import random
number = random.random()
print(number)

Problem:

• this returns a float like 0.5831
• not an integer from 0 to 9

Fix:

import random
number = random.randint(0, 9)

4. Assuming random means no repeats

import random
print(random.randint(0, 9))
print(random.randint(0, 9))

Problem:

• the same value may appear more than once
• that is normal for random draws with replacement

If you need unique values, use sampling instead.

import random
print(random.sample(range(10), 3))

5. Using random values for security-sensitive code

Avoid this for passwords, tokens, or auth codes:

import random
code = random.randint(0, 9)

For security-related randomness, use secrets instead.

import secrets
code = secrets.randbelow(10)

randint(0, 9) vs randrange(10)

Both can produce 0 through 9.

random.randint(0, 9)
random.randrange(10)

Difference:

• randint(0, 9) is often clearer when you want inclusive endpoints
• randrange(10) is convenient when thinking in terms of length or index ranges

random vs secrets

• Use random for games, demos, simulations, and testing
• Use secrets for passwords, tokens, reset codes, and security-related data

import random

Generate a random integer from 0 to 9 inclusive

random.randint(0, 9)

Equivalent half-open form

random.randrange(10)

Key rules

• randint(a, b) includes both ends
• randrange(stop) excludes stop
• random.random() returns a float, not an integer
• random values can repeat

Examples

import random

print(random.randint(0, 9))
print(random.randrange(10))

Repeatable results for testing

import random

random.seed(123)
print(random.randint(0, 9))

Security note

Use this instead for secure randomness:

import secrets

print(secrets.randbelow(10))

Quick decision guide

• Need a random integer from 0 to 9? → random.randint(0, 9)
• Need a random index for a length-10 range? → random.randrange(10)
• Need secure randomness? → secrets.randbelow(10)

How do I generate a random number from 0 to 9 in Python?

Use:

import random
random.randint(0, 9)

This includes both 0 and 9.

Is 9 included in random.randint(0, 9)?

Yes. randint includes both the lower and upper bounds.

What is the difference between randint(0, 9) and randrange(10)?

They both can return 0 through 9. The difference is the way the range is expressed:

• randint(0, 9) is inclusive
• randrange(10) means 0 up to but not including 10

Why am I getting decimals instead of integers?

You are probably using random.random(), which returns a float. Use random.randint(0, 9) for whole numbers.

Can the same random number appear more than once?

Yes. Each call is independent, so repeats are normal.

How do I generate multiple random digits in Python?

You can use a loop or list comprehension:

import random

digits = [random.randint(0, 9) for _ in range(5)]
print(digits)

Should I use random for passwords or verification codes?

Not for security-sensitive cases. Use the secrets module instead.

Do I need to install the random module?

No. random is part of Python's standard library.

• random module — the main Python module for non-secure random values.
• randint — the most direct function for inclusive random integers.
• randrange — useful when working with half-open ranges like list indexes.
• random.choice — used when selecting a random item from a sequence.
• secrets module — the right choice for secure random values.
• list comprehensions — commonly used to generate many random values at once.
• loops — helpful when producing repeated random results.
• indexing — relevant when random numbers are used to access list elements.