In unbiased coin flip H or T occurs 50% of times.

But I want to simulate coin which gives H with probability ‘p’ and T with probability ‘(1-p)’.

something like this:

``````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]
``````

`random.random()` returns a uniformly distributed pseudo-random floating point number in the range [0, 1). This number is less than a given number `p` in the range [0,1) with probability `p`. Thus:

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

Some experiments:

``````>>> 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
``````

Do you want the “bias” to be based in symmetric distribuition? Or maybe exponential distribution? Gaussian anyone?

Well, here are all the methods, extracted from random documentation itself.

First, an example of triangular distribution:

``````print random.triangular(0, 1, 0.7)
``````

`random.triangular(low, high, mode)`:

Return a random floating point number `N` such that `low <= N < high` and
with the specified mode between those
bounds. The `low` and `high` bounds
default to zero and one. The `mode`
argument defaults to the midpoint
between the bounds, giving a symmetric
distribution.

`random.betavariate(alpha, beta)`:

Beta distribution. Conditions on the parameters are `alpha > 0` and
`beta > 0`. Returned values range between `0` and `1`.

`random.expovariate(lambd)`:

Exponential distribution. `lambd` is `1.0`
divided by the desired mean. It should
be nonzero. (The parameter would be
called “`lambda`”, but that is a
reserved word in Python.) Returned
values range from `0` to positive
infinity
if `lambd` is positive, and
from negative infinity to `0` if `lambd`
is negative.

`random.gammavariate(alpha, beta)`:

Gamma distribution. (Not the gamma
function!) Conditions on the
parameters are `alpha > 0` and `beta > 0`.

`random.gauss(mu, sigma)`:

Gaussian distribution. `mu` is the mean, and `sigma` is the standard
deviation. This is slightly faster
than the `normalvariate()` function
defined below.

`random.lognormvariate(mu, sigma)`:

Log normal distribution. If you take
the natural logarithm of this
distribution, you’ll get a normal
distribution with mean `mu` and standard
deviation `sigma`. `mu` can have any
value, and `sigma` must be greater than
zero.

`random.normalvariate(mu, sigma)`:

Normal distribution. `mu` is the mean,
and `sigma` is the standard deviation.

`random.vonmisesvariate(mu, kappa)`:

`mu` is the mean angle, expressed in
radians between `0` and `2*pi`, and `kappa`
is the concentration parameter, which
must be greater than or equal to zero.
If `kappa` is equal to zero, this
distribution reduces to a uniform
random angle over the range `0` to `2*pi`.

`random.paretovariate(alpha)`:

Pareto distribution. `alpha` is the
shape parameter.

`random.weibullvariate(alpha, beta)`

Weibull distribution. `alpha` is the
scale parameter and `beta` is the shape
parameter.

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

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

That returns a boolean which you can then use to choose H or T (or choose between any two values) you want. You could also include the choice in the method:

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

but it’d be less generally useful that way.

One can sample from the `X ~ Bernoulli(p)` distribution `nsamples` times using `sympy` too:

``````from sympy.stats import Bernoulli, sample_iter
list(sample_iter(Bernoulli('X', 0.8), numsamples=10)) # p = 0.8 and nsamples=10
# [1, 1, 0, 1, 1, 0, 1, 1, 1, 1]
``````

Return `'H'` or `'T'` instead using

``````def flip(p, n):
return list(map(lambda x: 'H' if x==1 else 'T', sample_iter(Bernoulli('X', p), numsamples=n)))

print(flip(0.8, 10)) # p = 0.8 and nsamples=10
# ['H', 'H', 'T', 'H', 'H', 'T', 'H', 'H', 'H', 'H']
``````

• Import a random number between 0 – 1 (you can use randrange function)

• If the number is above (1-p), return tails.

• Else, return heads

``````import random
def flip():
return ["H" if random.randint(0,3) <= 2 else "T" for i in range(10)]
``````

Right now probability of Head is 75% and tails is 25% (0,1,2 are all Heads and only 3 is Tails) . By using random.randint() you could have any probability of bias while still maintaining randomness.