Kodeclik Blog
How to generate a random 4-digit number in Javascript or Python
Have you ever wondered how websites or apps come up with verification codes, temporary passwords, or game PINs? Often, they're just random 4-digit numbers generated behind the scenes using a bit of code. Learning how to generate a random number, especially a simple 4-digit one, is an essential skill when you're programming games, creating secure logins, or building fun projects like quizzes or puzzles. Whether you're coding in Python or JavaScript, knowing how and when to use random number generation can add a powerful tool to your programming toolkit—so let's dive in and see how it's done!
How to generate a random 4-digit number in Javascript
In JavaScript, there are multiple ways to generate a random 4-digit number depending on your needs. You can use Math.random() for a simple and fast solution, the crypto.getRandomValues() method for a more secure and cryptographically strong result, or format numbers with padStart() to include leading zeros for string-based outputs like PIN codes. Each approach offers a unique balance between simplicity, security, and formatting flexibility. Let us look at each of them next!
Method 1: Use Math.random()
This is the most basic method. It ensures the number is between 1000 and 9999.
const random4Digit = Math.floor(1000 + Math.random() * 9000);
console.log(random4Digit);This method uses JavaScript’s built-in Math.random() function, which returns a floating-point number between 0 (inclusive) and 1 (exclusive). By multiplying it by 9000, we get a number in the range [0, 8999.999...). Adding 1000 shifts the range to [1000, 9999.999...), and then Math.floor() is used to round it down to the nearest integer. This ensures the final result is a whole number between 1000 and 9999, inclusive.
Method 2: Use crypto.getRandomValues() (more secure)
This is a cryptographically stronger random number generator:
const array = new Uint16Array(1);
crypto.getRandomValues(array);
const random4Digit = 1000 + (array[0] % 9000);
console.log(random4Digit);This approach uses the crypto.getRandomValues() method from the Web Crypto API, which provides a more secure, cryptographically strong way to generate random values compared to Math.random(). A single 16-bit unsigned integer is created (Uint16Array(1)), and the getRandomValues method fills it with a random value between 0 and 65535. Taking the modulo of that value with 9000 restricts the range to 0–8999, and then adding 1000 ensures the final result falls between 1000 and 9999. This is ideal when randomness quality and security matter (e.g., generating temporary PINs).
Method 3: Pad a shorter number
This approach gives a 4-digit string, including numbers like "0007" and thus is useful if you want all 4-digit combinations including leading zeros.
const random4Digit = String(Math.floor(Math.random() * 10000)).padStart(4, '0');
console.log(random4Digit);In this version, we allow the full range from 0 to 9999 by multiplying Math.random() by 10000, then using Math.floor() to convert it to an integer. This can produce numbers with fewer than 4 digits (like 7, 98, or 562). To ensure the output is always 4 characters long, we convert the number to a string and apply padStart(4, '0'), which adds leading zeros if needed. The result is a string (not a number), useful for cases like formatting codes or PINs where leading zeros are meaningful.
How to generate a random 4-digit number in Python
Generating a random 4-digit number in Python can be accomplished in several simple and efficient ways, again depending on whether you need pure randomness, cryptographic security, or string formatting (including leading zeros). Below are three common and practical methods you can use in your Python scripts.
Method 1: Use random.randint()
This method uses Python’s built-in random module and the randint() function, which returns a random integer within the specified inclusive range:
import random
random_4_digit = random.randint(1000, 9999)
print(random_4_digit)By passing 1000 and 9999 as arguments, we ensure that the result is always a valid 4-digit number (from 1000 up to 9999). This is the most straightforward and commonly used method for generating a 4-digit number in Python when cryptographic-level randomness isn’t required.
Method 2: Use secrets.randbelow() (for cryptographic use cases)
The secrets module is designed for generating cryptographically secure random numbers, ideal for things like passwords, tokens, and secure PINs.
import secrets
random_4_digit = 1000 + secrets.randbelow(9000)
print(random_4_digit)In the above code, secrets.randbelow(9000) returns a number from 0 to 8999, and adding 1000 ensures the final number is in the 1000–9999 range. This method is recommended when security is a concern and you want unpredictable results suitable for sensitive applications.
Method 3: Pad with zfill() to allow leading zeros
This method generates a number between 0 and 9999 and converts it to a string.
import random
random_4_digit = str(random.randint(0, 9999)).zfill(4)
print(random_4_digit)To ensure it is always 4 digits long, the above code uses the .zfill(4) string method, which prepends leading zeros if necessary. This is especially useful when you need a PIN code, a 4-digit string identifier, or when leading zeros are important. The output here is a string rather than an integer, which is ideal for display or formatting purposes.
In summary, you have learnt three different ways to generate random 4-digit numbers in JavaScript and Python. Whether you need basic randomness, cryptographic security, or formatted strings with leading zeros, this guide has you covered with code and explanations!
Enjoy this blogpost? Want to learn Python or Javascript with us? Sign up for 1:1 or small group classes.
