Python Random: Genera números aleatorios, selecciones y muestras

Name

Soren Atelier

Updated on 10/2/2026

Generar datos aleatorios es fundamental en la programación -- desde mezclar una lista de reproducción y muestrear encuestados hasta ejecutar simulaciones de Monte Carlo y crear conjuntos de datos de prueba. Pero el módulo random de Python tiene docenas de funciones, y es fácil usar la incorrecta. Llamar a random.random() cuando necesitas un entero, usar choice() cuando necesitas múltiples elementos únicos, u olvidar que random no es criptográficamente seguro puede llevar a bugs sutiles o vulnerabilidades de seguridad.

El módulo random de Python proporciona un conjunto completo de herramientas para la generación de números pseudoaleatorios. Esta guía cubre cada función que necesitarás comúnmente, con ejemplos claros que muestran cuándo usar cada una.

Enteros aleatorios

randint(a, b)

Devuelve un entero aleatorio N tal que a <= N <= b (ambos extremos incluidos).

import random
 
# Random integer between 1 and 10 (inclusive)
print(random.randint(1, 10))  # e.g., 7
 
# Simulate a dice roll
dice = random.randint(1, 6)
print(f"You rolled a {dice}")
 
# Generate random ages for test data
ages = [random.randint(18, 65) for _ in range(5)]
print(ages)  # e.g., [34, 52, 21, 45, 28]

randrange(start, stop, step)

Como range() pero devuelve un elemento aleatorio. El valor stop está excluido.

import random
 
# Random even number between 0 and 100
print(random.randrange(0, 101, 2))  # e.g., 42
 
# Random number from 0 to 9
print(random.randrange(10))  # e.g., 7
 
# Random multiple of 5 from 0 to 100
print(random.randrange(0, 101, 5))  # e.g., 35

Flotantes aleatorios

random()

Devuelve un flotante aleatorio en el rango [0.0, 1.0).

import random
 
print(random.random())  # e.g., 0.7234...
 
# Scale to any range: random float between 10 and 20
value = 10 + random.random() * 10
print(value)  # e.g., 15.23...

uniform(a, b)

Devuelve un flotante aleatorio N tal que a <= N <= b.

import random
 
# Random temperature between 98.0 and 99.5
temp = random.uniform(98.0, 99.5)
print(f"Temperature: {temp:.1f}F")  # e.g., Temperature: 98.7F
 
# Random price between 9.99 and 29.99
price = round(random.uniform(9.99, 29.99), 2)
print(f"Price: ${price}")

gauss(mu, sigma) -- Distribución normal

import random
 
# Generate normally distributed values (mean=100, std=15)
iq_scores = [round(random.gauss(100, 15)) for _ in range(10)]
print(iq_scores)  # e.g., [112, 95, 103, 88, 107, ...]

Selecciones aleatorias

choice(seq)

Devuelve un solo elemento aleatorio de una secuencia no vacía.

import random
 
colors = ['red', 'blue', 'green', 'yellow', 'purple']
print(random.choice(colors))  # e.g., 'green'
 
# Random character from a string
print(random.choice('abcdefghij'))  # e.g., 'f'

choices(population, weights, k)

Devuelve una lista de k elementos elegidos CON reemplazo (duplicados posibles). Soporta pesos.

import random
 
# Pick 5 random colors (duplicates allowed)
colors = ['red', 'blue', 'green']
print(random.choices(colors, k=5))  # e.g., ['blue', 'red', 'blue', 'green', 'red']
 
# Weighted selection (red is 5x more likely)
weighted = random.choices(
    ['red', 'blue', 'green'],
    weights=[5, 1, 1],
    k=10
)
print(weighted)  # Mostly 'red'

sample(population, k)

Devuelve k elementos únicos elegidos SIN reemplazo (sin duplicados).

import random
 
# Lottery numbers: 6 unique numbers from 1-49
lottery = random.sample(range(1, 50), 6)
print(sorted(lottery))  # e.g., [3, 12, 27, 33, 41, 48]
 
# Random survey sample
employees = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank']
survey_group = random.sample(employees, 3)
print(survey_group)  # e.g., ['Diana', 'Alice', 'Frank']

choice vs choices vs sample

Mezclar

shuffle(seq)

Mezcla una lista en su lugar. Devuelve None.

import random
 
deck = list(range(1, 53))  # 52 cards
random.shuffle(deck)
print(deck[:5])  # e.g., [37, 12, 48, 3, 21]
 
# Deal 5 cards
hand = deck[:5]
remaining = deck[5:]

Seeds y reproducibilidad

Establecer un seed hace que la salida aleatoria sea reproducible -- crítico para pruebas y depuración.

import random
 
random.seed(42)
print(random.randint(1, 100))  # Always 81
print(random.random())          # Always 0.0744...
 
# Reset seed for same sequence
random.seed(42)
print(random.randint(1, 100))  # 81 again
print(random.random())          # 0.0744... again

Cuándo usar seeds

Generar datos de prueba

import random
import string
 
def random_string(length=10):
    """Generate a random alphanumeric string."""
    chars = string.ascii_letters + string.digits
    return ''.join(random.choices(chars, k=length))
 
def random_email():
    """Generate a random email address."""
    name = random_string(8).lower()
    domains = ['gmail.com', 'yahoo.com', 'outlook.com']
    return f"{name}@{random.choice(domains)}"
 
def random_user():
    """Generate a random user record."""
    first_names = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve']
    last_names = ['Smith', 'Jones', 'Brown', 'Wilson', 'Taylor']
    return {
        'name': f"{random.choice(first_names)} {random.choice(last_names)}",
        'email': random_email(),
        'age': random.randint(18, 65),
        'score': round(random.uniform(0, 100), 1),
    }
 
# Generate 5 test users
users = [random_user() for _ in range(5)]
for user in users:
    print(user)

Random y ciencia de datos

Para flujos de trabajo de análisis de datos, el módulo random ayuda con muestreo, bootstrapping y creación de conjuntos de datos sintéticos. Combinado con pandas, puedes generar DataFrames de prueba rápidamente:

import random
import pandas as pd
 
random.seed(42)
n = 1000
 
df = pd.DataFrame({
    'age': [random.randint(18, 80) for _ in range(n)],
    'income': [round(random.gauss(50000, 15000), 2) for _ in range(n)],
    'category': random.choices(['A', 'B', 'C'], weights=[5, 3, 2], k=n),
})
print(df.describe())

Para exploración interactiva de tus conjuntos de datos aleatorios, PyGWalker (opens in a new tab) convierte cualquier DataFrame de pandas en una interfaz de visualización estilo Tableau dentro de Jupyter:

import pygwalker as pyg
walker = pyg.walk(df)

Advertencia de seguridad: random vs secrets

El módulo random NO es adecuado para propósitos de seguridad. Su salida es determinista y predecible si se conoce el seed. Para contraseñas, tokens y aplicaciones criptográficas, usa el módulo secrets:

import secrets
 
# Cryptographically secure random token
token = secrets.token_hex(16)
print(token)  # e.g., 'a3f2b8c9d1e4f5a6b7c8d9e0f1a2b3c4'
 
# Secure random integer
secure_int = secrets.randbelow(100)
 
# Secure random choice
secure_choice = secrets.choice(['option1', 'option2', 'option3'])

FAQ

¿Cómo genero un entero aleatorio en Python?

Usa random.randint(a, b) para obtener un entero aleatorio entre a y b (inclusive). Por ejemplo, random.randint(1, 10) devuelve un número del 1 al 10. Para un rango que excluye el límite superior, usa random.randrange(start, stop).

¿Cuál es la diferencia entre random.choice y random.sample?

random.choice(seq) devuelve un solo elemento aleatorio. random.sample(population, k) devuelve k elementos únicos sin reemplazo. Para seleccionar múltiples elementos donde se permiten duplicados, usa random.choices(population, k=n).

¿Cómo hago que los resultados aleatorios sean reproducibles?

Llama a random.seed(value) antes de generar números aleatorios. Usar el mismo seed produce la misma secuencia de valores aleatorios cada vez. Esto es esencial para tests unitarios y depuración.

¿Es seguro el módulo random de Python?

No. El módulo random usa el algoritmo Mersenne Twister, que es determinista y predecible. Para aplicaciones sensibles a la seguridad como contraseñas o tokens, usa el módulo secrets en su lugar, que utiliza fuentes aleatorias criptográficamente seguras.

¿Cómo mezclo una lista aleatoriamente en Python?

Usa random.shuffle(my_list) para mezclar una lista en su lugar. Modifica la lista original y devuelve None. Si necesitas la lista original sin cambios, haz una copia primero: shuffled = my_list.copy(); random.shuffle(shuffled).

Conclusión

El módulo random de Python cubre toda necesidad común de aleatorización: randint para enteros, uniform para flotantes, choice/choices/sample para seleccionar de secuencias, shuffle para reordenar y seed para reproducibilidad. Recuerda la distinción clave: choices permite duplicados (con reemplazo), sample no (sin reemplazo). Y nunca uses random para seguridad -- usa secrets en su lugar.