Como faço para simular aleta da moeda viciada em python?

Question

imparcial moeda aleta H ou T ocorre 50% de vezes.

Mas eu quero moeda de simulação que dá H com probabilidade 'p' e T com probabilidade '(1-p)'.

algo como isto:

def flip(p):
   '''this function return H with probability p'''
   # do something
   return result

>> [flip(0.8) for i in xrange(10)]
[H,H,T,H,H,H,T,H,H,H]

Answer 1

random.random() retorna um uniformemente distribuído número de ponto flutuante pseudo-aleatório no intervalo [0, 1). Este número é inferior a um determinado p número no intervalo [0,1) com p probabilidade. Assim:

def flip(p):
    return 'H' if random.random() < p else 'T'

Alguns experimentos:

>>> N = 100
>>> flips = [flip(0.2) for i in xrange(N)]
>>> float(flips.count('H'))/N
0.17999999999999999  # Approximately 20% of the coins are heads

>>> N = 10000
>>> flips = [flip(0.2) for i in xrange(N)]
>>> float(flips.count('H'))/N
0.20549999999999999  # Better approximation 

Answer 2

Você quer o "viés" para ser baseada na distribuição simétrica? Ou talvez exponencial distribuição? ninguém Gaussian?

Bem, aqui estão todos os métodos, extraídos da própria documentação aleatória.

Primeiro, um exemplo de distribuição triangular:

print random.triangular(0, 1, 0.7)

random.triangular(low, high, mode) :

Retorna um aleatório ponto flutuante número N tal que low <= N < high e com o modo especificado entre aqueles limites. Os limites low e high padrão para de zero e um . o mode defaults argumento para o ponto médio entre os limites, dando um simétrica distribuição.

random.betavariate(alpha, beta) :

distribuição Beta. Condições sobre os parâmetros são alpha > 0 e beta > 0. valores devolvidos variam entre 0 e 1.

random.expovariate(lambd) :

distribuição exponencial. lambd é 1.0 dividido pela média desejada. Deveria ser diferente de zero . (O parâmetro seria chamado de “ lambda ”, mas que é um palavra reservada em Python.) retornou Os valores variam de 0 a positiva infinidade se lambd é positivo, e de infinito negativo para 0 se lambd é negativo.

random.gammavariate(alpha, beta) :

distribuição

Gamma. (Não é o gamma função!) Condições no parâmetros são alpha > 0 e beta > 0.

random.gauss(mu, sigma) :

distribuição de Gauss. mu é a média, e é o padrão sigma desvio. Este é um pouco mais rápido do que a função normalvariate() definido abaixo.

random.lognormvariate(mu, sigma) :

distribuição normal Log. Se você pegar o logaritmo natural desta distribuição, você vai ter um normais distribuição com mu médio e padrão sigma desvio. mu pode ter qualquer valor e sigma deve ser maior que de zero .

random.normalvariate(mu, sigma) :

A distribuição normal. mu é a média, e sigma é o desvio padrão.

random.vonmisesvariate(mu, kappa) :

mu é o ângulo médio, expresso em radianos entre 0 e 2*pi, e kappa é o parâmetro concentração, que deve ser maior que ou igual a de zero . Se kappa é igual a de zero , este distribuição reduz-se a um uniforme ângulo aleatório sobre o 0 intervalo para 2*pi.

random.paretovariate(alpha) :

distribuição

Pareto. alpha é o parâmetro de forma.

random.weibullvariate(alpha, beta)

distribuição Weibull. alpha é o parâmetro de escala e beta é a forma parâmetro.

Answer 3

import random
def flip(p):
    return (random.random() < p)

que retorna um booleano que você pode usar para escolher H ou T (ou escolher entre dois valores) que você deseja. Você também pode incluir a escolha do método:

def flip(p):
    if random.random() < p:
        return 'H'
    else:
        return 'T'

mas seria menos geralmente útil dessa forma.

Answer 4

Como sobre: ??

import numpy as np
n, p = 1, .33  # n = coins flipped, p = prob of success
s = np.random.binomial(n, p, 100)

Answer 5

• Importar um número aleatório entre 0-1 (você pode usar a função randrange)

• Se o número for superior a (1-p), rabos de retorno.

• Else, cabeças de retorno