random.binomialvariate: simule distribuições binomiais

random.binomialvariate() é uma função da biblioteca padrão do Python criada para simular quantas vezes um evento acontece com sucesso em um número fixo de tentativas independentes. Ela representa diretamente a distribuição binomial, muito usada em estatística, ciência de dados, testes, jogos, confiabilidade, marketing, controle de qualidade e modelagem de risco. Em vez de escrever um laço com várias chamadas a random.random(), você informa o número de tentativas e a probabilidade de sucesso em cada uma delas.

O que é uma distribuição binomial

Uma variável binomial conta o número de sucessos em n tentativas. Cada tentativa possui apenas dois resultados relevantes, como sucesso ou falha, verdadeiro ou falso, compra ou não compra. A probabilidade de sucesso, representada por p, deve permanecer igual em todas as tentativas e cada tentativa deve ser independente das demais.

Exemplos clássicos incluem contar quantas pessoas clicam em um anúncio entre cem visitantes, quantas peças apresentam defeito em um lote, quantos testes passam em uma bateria automatizada ou quantas vezes uma moeda resulta em cara. Para revisar conceitos básicos, veja também nossos conteúdos sobre números aleatórios em Python, estatística em Python, listas em Python e funções em Python.

Sintaxe de random.binomialvariate

import random

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

O argumento n define o número de tentativas e deve ser um inteiro não negativo. O argumento p representa a probabilidade de sucesso em cada tentativa e deve estar entre zero e um. O retorno é um inteiro entre zero e n.

Com n=10 e p=0.5, o valor esperado fica próximo de cinco, mas uma única execução pode produzir três, seis, oito ou qualquer outro valor permitido. O resultado muda porque se trata de uma amostra aleatória.

Primeiro exemplo prático

Imagine uma campanha em que cada visitante possui 8% de chance de converter. Para simular quantas conversões podem ocorrer entre 200 visitantes, basta escrever:

import random

conversoes = random.binomialvariate(200, 0.08)
print(f'Conversões simuladas: {conversoes}')

A média teórica é n * p, portanto aproximadamente dezesseis conversões. Isso não significa que toda simulação retornará dezesseis. A variação é parte do modelo.

Simulando muitos cenários

Uma única simulação raramente é suficiente para analisar risco. Normalmente executamos milhares de repetições e observamos a distribuição dos resultados.

import random
from statistics import mean, pstdev

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

print('Média:', mean(amostras))
print('Desvio padrão:', pstdev(amostras))
print('Mínimo:', min(amostras))
print('Máximo:', max(amostras))

A média simulada deve se aproximar de n * p. O desvio padrão teórico é a raiz quadrada de n * p * (1 - p). Comparar os valores simulados com esses resultados ajuda a validar o experimento.

Definindo uma semente

Durante testes, é importante tornar os resultados reproduzíveis. Para isso, use random.seed() antes das simulações.

import random

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

Com a mesma versão do ambiente e a mesma sequência de chamadas, a semente ajuda a repetir o experimento. Ela é útil em testes automatizados, demonstrações e depuração. Porém, o gerador do módulo random não foi criado para criptografia. Tokens, senhas e chaves devem usar o módulo secrets.

Comparação com um laço manual

Antes dessa função, era comum simular uma binomial com uma soma de comparações:

import random

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

print(binomial_manual(100, 0.2))

O resultado conceitual é o mesmo. A vantagem de random.binomialvariate() é deixar a intenção explícita, reduzir código repetido e centralizar validações. Para leitura e manutenção, a chamada direta costuma ser melhor.

Validação dos parâmetros

Em aplicações reais, valide os dados antes de executar a simulação. Um número negativo de tentativas não faz sentido, assim como uma probabilidade menor que zero ou maior que um.

def simular_sucessos(n, p):
    if not isinstance(n, int):
        raise TypeError('n deve ser inteiro')
    if n < 0:
        raise ValueError('n não pode ser negativo')
    if not 0 <= p <= 1:
        raise ValueError('p deve estar entre 0 e 1')

    import random
    return random.binomialvariate(n, p)

Essa camada de validação é especialmente importante quando n e p vêm de formulários, arquivos, APIs ou bancos de dados.

Probabilidade zero e probabilidade um

Os extremos são úteis para testes. Com p=0, o resultado sempre será zero. Com p=1, o resultado sempre será igual a n.

import random

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

Esses casos também ajudam a verificar se uma função que consome a simulação lida corretamente com limites.

Exemplo de controle de qualidade

Suponha que uma fábrica produza lotes de mil itens e estime uma taxa de defeito de 1,5%. Podemos simular quantos itens defeituosos aparecem em cada lote:

import random

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

Repetindo a simulação muitas vezes, a equipe pode estimar com que frequência um lote ultrapassa um limite de tolerância. Isso apoia planejamento, mas não substitui medições reais nem um modelo estatístico revisado.

Exemplo com testes automatizados

Também podemos modelar falhas intermitentes em uma suíte de testes. Imagine cem testes independentes, cada um com 2% de chance de falhar por instabilidade externa:

import random

falhas = random.binomialvariate(100, 0.02)
if falhas:
    print(f'Execução simulada com {falhas} falhas')
else:
    print('Nenhuma falha simulada')

Esse tipo de modelo pode ser usado para testar dashboards, alertas e políticas de repetição sem provocar falhas reais.

Quando o modelo binomial não serve

A distribuição binomial depende de hipóteses específicas. Se a probabilidade muda de uma tentativa para outra, se os eventos dependem entre si ou se existem mais de dois resultados relevantes, o modelo pode ser inadequado. Por exemplo, clientes de uma mesma família podem ter decisões correlacionadas, e defeitos de uma máquina podem ocorrer em grupos.

Nessas situações, talvez seja necessário usar outro modelo, dividir os dados em grupos com probabilidades diferentes ou recorrer a bibliotecas científicas. A documentação oficial de random no Python descreve o comportamento da função, enquanto a referência do NIST sobre distribuição binomial apresenta a base estatística.

Desempenho e grandes simulações

Para algumas milhares de amostras, a biblioteca padrão costuma ser suficiente. Em experimentos massivos, arrays vetorizados e bibliotecas numéricas podem ser mais rápidos. Mesmo assim, random.binomialvariate() é excelente para scripts, ensino, testes e aplicações sem dependências externas.

Evite armazenar milhões de resultados quando você precisa apenas de contagens agregadas. Atualizar médias, frequências e percentis em blocos pode reduzir uso de memória. Também registre a semente, os parâmetros e a versão do Python para tornar o experimento auditável.

Boas práticas

Use nomes que revelem o significado de n e p. Documente as hipóteses de independência e probabilidade constante. Defina sementes somente quando a repetibilidade for desejada. Separe simulação de regras de negócio e escreva testes para os extremos. Não apresente uma única amostra como previsão garantida.

Conclusão

random.binomialvariate() oferece uma forma clara e direta de simular contagens de sucesso em tentativas independentes. Com ela, você pode modelar conversões, defeitos, aprovações, falhas e diversos outros fenômenos binários. O recurso se torna ainda mais útil quando combinado com repetição, métricas estatísticas, validação de parâmetros e documentação das hipóteses. Use a função como ferramenta de exploração e teste, sempre lembrando que a qualidade do resultado depende da adequação do modelo aos dados reais.