Random Number Code Generator

How to generate a random number in Python: import random for games and simulations, secrets for anything security-related.

Both functions are in the standard library - nothing to install. randint includes both ends; randrange excludes the stop value, like range().

import random

random.randint(1, 10)      # 1..10, both ends included
random.randrange(0, 10)    # 0..9, stop is excluded
random.randrange(0, 100, 5)  # 0, 5, 10 ... 95

random() returns a float in [0.0, 1.0); uniform(a, b) scales it to your range.

import random

random.random()          # 0.0 <= x < 1.0
random.uniform(1.5, 4.5)  # float between 1.5 and 4.5

choice picks one item, sample picks several without repeats, shuffle reorders a list in place.

import random

items = ["red", "green", "blue", "yellow"]
random.choice(items)       # one item
random.sample(items, 2)    # two different items
random.shuffle(items)      # shuffles the list in place, returns None

The random module is a Mersenne Twister: fast and reproducible, but predictable. For passwords, tokens, invite codes or prize draws use secrets, which reads from the operating system CSPRNG.

import secrets

secrets.randbelow(10) + 1   # 1..10
secrets.choice(["a", "b"])  # secure pick
secrets.token_hex(16)       # 32 hex characters
secrets.token_urlsafe(16)   # URL-safe token
secrets.SystemRandom().shuffle(items)  # secure shuffle

Naming your own file random.py shadows the module, so import random loads your file and random.randint fails with an AttributeError - rename the file and delete __pycache__. Use random.seed(42) only when you want the same sequence every run (tests, simulations).

import random

random.seed(42)       # reproducible sequence
print(random.randint(1, 6))

How to generate a random number in JavaScript: Math.random() for UI and games, the Web Crypto API for anything security-related.

Math.random() returns a float in [0, 1). Multiply by the number of possible values, floor it, and add the minimum.

function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min; // min..max inclusive
}

randomInt(1, 10);

Scale Math.random() to any range of decimals.

Math.random();                       // 0 <= x < 1
const x = Math.random() * (5 - 1.5) + 1.5; // 1.5 <= x < 5

Pick an index at random, or shuffle with Fisher-Yates - sorting with () => Math.random() - 0.5 gives a biased order.

const items = ["red", "green", "blue", "yellow"];
const pick = items[Math.floor(Math.random() * items.length)];

// Fisher-Yates shuffle (in place)
for (let i = items.length - 1; i > 0; i--) {
  const j = Math.floor(Math.random() * (i + 1));
  [items[i], items[j]] = [items[j], items[i]];
}

Math.random() is not cryptographically secure. For tokens, IDs and draws use the Web Crypto API (browsers and Node 19+), or crypto.randomInt in Node.

const bytes = crypto.getRandomValues(new Uint8Array(16)); // 16 random bytes
const id = crypto.randomUUID();                            // random UUID v4

// Node.js
const { randomInt } = require("node:crypto");
randomInt(1, 11); // 1..10 (upper bound exclusive)

Math.round(Math.random() * 10) makes 0 and 10 half as likely as the other values; Math.floor(Math.random() * 10) never returns 10. Use the floor formula with max - min + 1.

How to generate a random number in Java: ThreadLocalRandom or java.util.Random for everyday use, SecureRandom for anything security-related.

Upper bounds are exclusive in Java's random APIs, so add 1 to include the maximum.

import java.util.concurrent.ThreadLocalRandom;

int n = ThreadLocalRandom.current().nextInt(1, 11); // 1..10

import java.util.Random;

Random random = new Random();
int m = random.nextInt(10) + 1;                       // 1..10

nextDouble() returns a value in [0.0, 1.0).

double d = ThreadLocalRandom.current().nextDouble();          // 0.0 <= d < 1.0
double e = ThreadLocalRandom.current().nextDouble(1.5, 4.5);   // 1.5 <= e < 4.5

Pick by index, or shuffle a list with Collections.shuffle.

List<String> items = new ArrayList<>(List.of("red", "green", "blue"));
String pick = items.get(ThreadLocalRandom.current().nextInt(items.size()));
Collections.shuffle(items);                      // in place
Collections.shuffle(items, new SecureRandom());  // secure shuffle

java.util.Random is predictable. Use SecureRandom for passwords, tokens and draws - create it once and reuse it.

import java.security.SecureRandom;

SecureRandom secure = new SecureRandom();
int n = secure.nextInt(10) + 1;   // 1..10
byte[] token = new byte[16];
secure.nextBytes(token);

Math.abs(random.nextInt()) % n can return a negative number (the absolute value of Integer.MIN_VALUE is still negative) and is biased - use nextInt(n). Creating a new Random on every call wastes time; reuse one instance or use ThreadLocalRandom.

How to generate a random number in C#: Random.Shared for everyday use, RandomNumberGenerator for anything security-related.

Next(minValue, maxValue) excludes maxValue, so add 1 to include it. Random.Shared is thread-safe (.NET 6+).

int n = Random.Shared.Next(1, 11);   // 1..10
int m = Random.Shared.Next(10);      // 0..9

NextDouble() returns a value in [0.0, 1.0).

double d = Random.Shared.NextDouble();             // 0.0 <= d < 1.0
double e = 1.5 + Random.Shared.NextDouble() * 3.0;  // 1.5 <= e < 4.5

Pick by index; .NET 8 added Shuffle on both Random and RandomNumberGenerator.

string[] items = { "red", "green", "blue" };
string pick = items[Random.Shared.Next(items.Length)];
Random.Shared.Shuffle(items);              // .NET 8+
RandomNumberGenerator.Shuffle(items.AsSpan()); // secure, .NET 8+

System.Random is predictable. For tokens, passwords and draws use System.Security.Cryptography.RandomNumberGenerator.

using System.Security.Cryptography;

int n = RandomNumberGenerator.GetInt32(1, 11);  // 1..10
byte[] token = RandomNumberGenerator.GetBytes(16);

On .NET Framework, creating several new Random() in quick succession can give them the same time-based seed and identical sequences - use one shared instance (or Random.Shared on .NET 6+).

How to generate a random number in Go: math/rand/v2 for everyday use, crypto/rand for anything security-related.

rand.IntN(n) returns 0 to n-1; add the minimum to shift the range. math/rand/v2 (Go 1.22+) is seeded automatically.

import "math/rand/v2"

n := rand.IntN(10) + 1 // 1..10

rand.Float64() returns a value in [0.0, 1.0).

f := rand.Float64()            // 0.0 <= f < 1.0
g := 1.5 + rand.Float64()*3.0  // 1.5 <= g < 4.5

Pick by index; rand.Shuffle swaps elements through a callback.

items := []string{"red", "green", "blue"}
pick := items[rand.IntN(len(items))]
rand.Shuffle(len(items), func(i, j int) {
	items[i], items[j] = items[j], items[i]
})

math/rand is not suitable for secrets. crypto/rand reads from the operating system CSPRNG; rand.Int returns an unbiased value below a big.Int limit.

import (
	"crypto/rand"
	"math/big"
)

v, err := rand.Int(rand.Reader, big.NewInt(10)) // 0..9
if err != nil {
	panic(err)
}
n := v.Int64() + 1 // 1..10

buf := make([]byte, 16)
_, _ = rand.Read(buf) // 16 random bytes

With the original math/rand before Go 1.20, forgetting rand.Seed gave the same sequence on every run; math/rand/v2 removes that trap. Never use math/rand for tokens or keys.

How to generate a random number in PHP: random_int() is both easy and cryptographically secure, so it is the right default.

random_int($min, $max) includes both ends and is cryptographically secure (PHP 7+). mt_rand is faster but predictable; rand() is an alias of it since PHP 7.1.

$n = random_int(1, 10);  // 1..10, secure
$m = mt_rand(1, 10);     // 1..10, not secure

PHP 8.3 added Random\Randomizer::getFloat; before that, divide mt_rand() by mt_getrandmax().

$r = new \Random\Randomizer();
$f = $r->getFloat(1.5, 4.5);          // PHP 8.3+
$g = mt_rand() / mt_getrandmax();      // 0.0 <= g <= 1.0

array_rand and shuffle use the non-secure generator; Random\Randomizer (PHP 8.2+) defaults to the secure engine.

$items = ["red", "green", "blue"];
$pick = $items[array_rand($items)];                     // not secure
$securePick = $items[random_int(0, count($items) - 1)];   // secure
shuffle($items);                                         // not secure
$shuffled = (new \Random\Randomizer())->shuffleArray($items); // secure, PHP 8.2+

For tokens, reset links and API keys, generate random bytes and encode them.

$token = bin2hex(random_bytes(16)); // 32 hex characters

uniqid() is based on the clock, not random - never use it for tokens. Neither rand() nor mt_rand() is safe for passwords or tokens; random_int and random_bytes are.

How to generate a random number in Bash: $RANDOM for quick scripts, shuf or /dev/urandom for wider ranges and anything security-related.

$RANDOM returns 0 to 32767 in Bash (not in plain sh). The modulo trick is slightly biased and limited to 32768 values; shuf has neither problem.

echo $(( RANDOM % 10 + 1 ))   # 1..10, quick and slightly biased
shuf -i 1-10 -n 1              # 1..10
shuf -i 1-1000000 -n 5         # five different numbers

shuf also picks lines.

shuf -n 1 names.txt     # one random line
shuf names.txt          # whole file in random order

Read from the kernel CSPRNG for anything security-related.

od -An -N4 -tu4 /dev/urandom                  # random 32-bit unsigned integer
shuf -i 1-10 -n 1 --random-source=/dev/urandom
openssl rand -hex 16                          # 32 hex characters
head -c 16 /dev/urandom | base64

$RANDOM does not exist in /bin/sh on systems where sh is dash (Debian, Ubuntu) - run the script with bash. On macOS, shuf comes from GNU coreutils (installed as gshuf).