random.binomialvariate: simula resultados binomiales

random.binomialvariate() es una función de la biblioteca estándar de Python que permite simular cuántos éxitos ocurren en un número fijo de intentos independientes. Representa directamente una distribución binomial, muy utilizada en estadística, pruebas, juegos, confiabilidad, marketing, control de calidad y análisis de riesgo. En lugar de escribir un bucle con muchas llamadas a random.random(), se indican el número de intentos y la probabilidad de éxito de cada uno.

Qué representa una distribución binomial

Una variable binomial cuenta éxitos en n intentos. Cada intento tiene dos resultados relevantes, como éxito o fracaso, verdadero o falso, compra o no compra. La probabilidad de éxito, representada por p, debe mantenerse constante y los intentos deben ser independientes.

Algunos ejemplos son contar cuántos visitantes hacen clic en un anuncio, cuántas piezas de un lote tienen defectos, cuántas pruebas pasan o cuántos lanzamientos de moneda dan cara. Para repasar fundamentos, consulta nuestros artículos sobre números aleatorios en Python, estadística con Python, listas en Python y funciones en Python.

Sintaxis de random.binomialvariate

import random

resultado = random.binomialvariate(n=10, p=0.5)
print(resultado)

El argumento n define el número de intentos y debe ser un entero no negativo. El argumento p representa la probabilidad de éxito y debe estar entre cero y uno. El resultado es un entero entre cero y n.

Con diez intentos y probabilidad 0.5, el valor esperado es cinco, pero una ejecución puede devolver tres, seis, ocho o cualquier otro valor válido. Esa variación forma parte del modelo.

Ejemplo de conversiones

Supongamos que cada visitante tiene una probabilidad del 8% de convertirse en cliente. Para simular cuántas conversiones pueden ocurrir entre 200 visitantes:

import random

conversiones = random.binomialvariate(200, 0.08)
print(f'Conversiones simuladas: {conversiones}')

La media teórica es n * p, es decir, dieciséis conversiones. Eso no significa que todas las simulaciones produzcan exactamente dieciséis.

Ejecutar muchos escenarios

Una sola muestra no suele ser suficiente para analizar riesgos. Lo habitual es repetir el experimento miles de veces y estudiar la distribución de resultados.

import random
from statistics import mean, pstdev

muestras = [random.binomialvariate(200, 0.08) for _ in range(10_000)]

print('Media:', mean(muestras))
print('Desviación estándar:', pstdev(muestras))
print('Mínimo:', min(muestras))
print('Máximo:', max(muestras))

La media simulada debería acercarse a n * p. La desviación estándar teórica es la raíz cuadrada de n * p * (1 - p). Comparar ambos valores ayuda a validar el experimento.

Usar una semilla

En pruebas y demostraciones suele ser necesario reproducir resultados. Para ello se usa random.seed() antes de la simulación.

import random

random.seed(42)
print(random.binomialvariate(50, 0.3))

Con el mismo entorno y la misma secuencia de llamadas, una semilla ayuda a repetir el experimento. Sin embargo, el módulo random no está diseñado para criptografía. Contraseñas, tokens y claves deben generarse con secrets.

Comparación con un bucle manual

También es posible obtener una muestra binomial sumando comparaciones independientes:

import random

def binomial_manual(n, p):
    return sum(random.random() < p for _ in range(n))

print(binomial_manual(100, 0.2))

El concepto es equivalente. La función directa expresa mejor la intención, reduce código repetido y facilita el mantenimiento.

Validar los parámetros

El código de producción debe validar valores procedentes de formularios, archivos, APIs o bases de datos. Un número negativo de intentos no tiene sentido y una probabilidad no puede estar fuera del intervalo entre cero y uno.

def simular_exitos(n, p):
    if not isinstance(n, int):
        raise TypeError('n debe ser entero')
    if n < 0:
        raise ValueError('n no puede ser negativo')
    if not 0 <= p <= 1:
        raise ValueError('p debe estar entre 0 y 1')

    import random
    return random.binomialvariate(n, p)

La validación explícita produce mensajes más claros y define mejor el contrato de la función.

Probabilidades límite

Los extremos son previsibles y útiles en pruebas. Con p=0, el resultado siempre es cero. Con p=1, el resultado siempre es igual a n.

import random

assert random.binomialvariate(20, 0) == 0
assert random.binomialvariate(20, 1) == 20

Estos casos permiten verificar que el código posterior maneja correctamente conteos vacíos y máximos.

Simulación de control de calidad

Imagina una fábrica que produce lotes de mil artículos con una tasa estimada de defectos del 1.5%. Podemos simular cuántas unidades defectuosas aparecen en cada lote:

import random

for lote in range(1, 6):
    defectos = random.binomialvariate(1000, 0.015)
    print(f'Lote {lote}: {defectos} defectos')

Al repetir el experimento se puede estimar con qué frecuencia un lote supera un límite de tolerancia. Es una ayuda para planificar, pero no sustituye datos medidos ni una revisión estadística.

Pruebas con fallos intermitentes

La función también puede modelar tests inestables. Supongamos cien pruebas independientes con una probabilidad del 2% de fallar por un servicio externo:

import random

fallos = random.binomialvariate(100, 0.02)
if fallos:
    print(f'Ejecución simulada con {fallos} fallos')
else:
    print('Sin fallos simulados')

Esto permite probar paneles, alertas, reintentos e informes sin provocar fallos reales.

Cuándo no conviene usar el modelo binomial

La distribución binomial depende de condiciones importantes. Si la probabilidad cambia entre intentos, los resultados se influyen mutuamente o existen más de dos resultados relevantes, el modelo puede ser engañoso. Clientes de una misma familia pueden tener decisiones correlacionadas y los defectos de una máquina pueden aparecer agrupados.

En esos casos conviene dividir la población, elegir otro modelo o usar una biblioteca científica. La documentación oficial de random en Python explica la función, mientras que la referencia del NIST sobre distribución binomial presenta la base estadística.

Rendimiento y simulaciones grandes

Para scripts y miles de muestras, la biblioteca estándar suele ser suficiente. Los experimentos numéricos masivos pueden beneficiarse de arrays vectorizados. Aun así, random.binomialvariate() es excelente para aprendizaje, pruebas y aplicaciones sin dependencias externas.

No almacenes millones de muestras si solo necesitas métricas agregadas. Procesa por bloques o actualiza estadísticas de forma incremental. Registra la semilla, los parámetros y la versión de Python cuando la reproducibilidad sea importante.

Errores comunes

No interpretes una sola muestra como pronóstico garantizado. No uses un porcentaje como 8 cuando la función espera 0.08. No supongas independencia sin revisar el proceso real. Tampoco uses este generador pseudoaleatorio para valores sensibles de seguridad.

Buenas prácticas

Usa nombres descriptivos para explicar el significado de n y p. Documenta las hipótesis de independencia y probabilidad constante. Separa la simulación de las reglas de negocio. Añade pruebas para cero intentos, probabilidades límite, valores inválidos y rangos realistas. Presenta distribuciones e intervalos, no solo un resultado llamativo.

Conclusión

random.binomialvariate() ofrece una forma clara y directa de simular conteos de éxito en intentos independientes. Puede representar conversiones, defectos, aprobaciones, fallos y muchos otros procesos binarios. Combinada con repeticiones, métricas estadísticas, validación y supuestos bien documentados, se convierte en una herramienta práctica para experimentación y pruebas. La utilidad del resultado siempre depende de que el modelo refleje correctamente el sistema real.