Probability Distributions Python Cheat Sheet

Introduction to Probability Distributions

Probability distributions are mathematical functions that describe the likelihood of different outcomes in a random experiment. They are fundamental to statistics and data science, providing a framework for modeling uncertainty and making predictions. This cheat sheet will cover key probability distributions, their properties, and how to work with them using Python.

import random

def coin_flip_experiment(n_flips):
    return [random.choice(['H', 'T']) for _ in range(n_flips)]

results = coin_flip_experiment(10)
print(f"Coin flip results: {results}")
print(f"Heads count: {results.count('H')}")
print(f"Tails count: {results.count('T')}")

Uniform Distribution

The uniform distribution represents a constant probability over a continuous interval. It's often used to model random selection from a range of values with equal likelihood. In Python, we can use the random module to generate uniform random numbers.

import random

def uniform_distribution(a, b, n):
    return [random.uniform(a, b) for _ in range(n)]

# Generate 1000 random numbers between 0 and 1
samples = uniform_distribution(0, 1, 1000)

print(f"Mean: {sum(samples) / len(samples):.4f}")
print(f"Min: {min(samples):.4f}")
print(f"Max: {max(samples):.4f}")

Results for: Uniform Distribution

Mean: 0.5021
Min: 0.0013
Max: 0.9987

Normal (Gaussian) Distribution

The normal distribution, also known as the Gaussian distribution, is a symmetric bell-shaped curve characterized by its mean and standard deviation. It's widely used in natural and social sciences to represent real-valued random variables. Here's how to generate normally distributed random numbers in Python:

import random
import math

def box_muller_transform():
    u1 = random.random()
    u2 = random.random()
    z0 = math.sqrt(-2 * math.log(u1)) * math.cos(2 * math.pi * u2)
    return z0

def normal_distribution(mu, sigma, n):
    return [mu + sigma * box_muller_transform() for _ in range(n)]

samples = normal_distribution(0, 1, 1000)
mean = sum(samples) / len(samples)
variance = sum((x - mean) ** 2 for x in samples) / len(samples)

print(f"Mean: {mean:.4f}")
print(f"Variance: {variance:.4f}")
print(f"Standard Deviation: {math.sqrt(variance):.4f}")

Results for: Normal (Gaussian) Distribution

Mean: -0.0124
Variance: 0.9876
Standard Deviation: 0.9938

Binomial Distribution

The binomial distribution models the number of successes in a fixed number of independent Bernoulli trials. It's useful for scenarios like coin flips or yes/no surveys. Here's a Python implementation:

import random
import math

def binomial_distribution(n, p, k):
    def combinations(n, k):
        return math.factorial(n) // (math.factorial(k) * math.factorial(n - k))
    
    return combinations(n, k) * (p ** k) * ((1 - p) ** (n - k))

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

# Probability of getting exactly 3 heads in 10 coin flips
prob_3_heads = binomial_distribution(10, 0.5, 3)
print(f"Probability of exactly 3 heads in 10 flips: {prob_3_heads:.4f}")

# Simulate 1000 experiments of 10 coin flips each
results = [binomial_experiment(10, 0.5) for _ in range(1000)]
print(f"Average number of heads: {sum(results) / len(results):.2f}")

Results for: Binomial Distribution

Probability of exactly 3 heads in 10 flips: 0.1172
Average number of heads: 4.98

Poisson Distribution

The Poisson distribution models the number of events occurring in a fixed interval of time or space, assuming these events happen with a known average rate and independently of each other. It's often used in queueing theory and reliability engineering.

import math
import random

def poisson_pmf(lambda_param, k):
    return (math.exp(-lambda_param) * lambda_param ** k) / math.factorial(k)

def poisson_random_variable(lambda_param):
    L = math.exp(-lambda_param)
    k = 0
    p = 1
    
    while p > L:
        k += 1
        p *= random.random()
    
    return k - 1

# Calculate probability of exactly 3 events occurring when average is 2
prob_3_events = poisson_pmf(2, 3)
print(f"Probability of exactly 3 events: {prob_3_events:.4f}")

# Generate 1000 Poisson random variables with lambda = 2
samples = [poisson_random_variable(2) for _ in range(1000)]
mean = sum(samples) / len(samples)
print(f"Sample mean: {mean:.2f}")

Results for: Poisson Distribution

Probability of exactly 3 events: 0.1804
Sample mean: 2.01

Exponential Distribution

The exponential distribution models the time between events in a Poisson process. It's commonly used to describe the time until the next event occurs, such as the time until the next customer arrives at a store or the time until a machine fails.

import random
import math

def exponential_distribution(lambda_param, n):
    return [-math.log(1 - random.random()) / lambda_param for _ in range(n)]

lambda_param = 0.5
samples = exponential_distribution(lambda_param, 1000)

mean = sum(samples) / len(samples)
variance = sum((x - mean) ** 2 for x in samples) / len(samples)

print(f"Theoretical mean: {1 / lambda_param:.4f}")
print(f"Sample mean: {mean:.4f}")
print(f"Theoretical variance: {1 / (lambda_param ** 2):.4f}")
print(f"Sample variance: {variance:.4f}")

Results for: Exponential Distribution

Theoretical mean: 2.0000
Sample mean: 2.0164
Theoretical variance: 4.0000
Sample variance: 4.0658

Real-Life Example: Customer Service

Imagine a customer service center where calls arrive randomly. We can model this scenario using probability distributions:

1. Poisson distribution: Model the number of calls received per hour
2. Exponential distribution: Model the time between incoming calls

import random
import math

def simulate_call_center(hours, avg_calls_per_hour):
    total_calls = 0
    for _ in range(hours):
        calls_this_hour = poisson_random_variable(avg_calls_per_hour)
        total_calls += calls_this_hour
    
    return total_calls

def simulate_call_times(num_calls, avg_time_between_calls):
    return exponential_distribution(1/avg_time_between_calls, num_calls)

# Simulate a 8-hour workday with an average of 10 calls per hour
workday_calls = simulate_call_center(8, 10)
print(f"Total calls in 8 hours: {workday_calls}")

# Simulate time between calls (in minutes) for these calls
call_times = simulate_call_times(workday_calls, 6)
print(f"Average time between calls: {sum(call_times)/len(call_times):.2f} minutes")

Results for: Real-Life Example: Customer Service

Total calls in 8 hours: 85
Average time between calls: 5.98 minutes

Real-Life Example: Quality Control

In a manufacturing process, we can use probability distributions to model defect rates and perform quality control:

1. Binomial distribution: Model the number of defective items in a batch
2. Normal distribution: Model the variation in a product's measurements

import random
import math

def inspect_batch(batch_size, defect_rate):
    return sum(random.random() < defect_rate for _ in range(batch_size))

def measure_products(n, target, std_dev):
    return [random.gauss(target, std_dev) for _ in range(n)]

# Inspect 1000 items with a 1% defect rate
defective_items = inspect_batch(1000, 0.01)
print(f"Defective items in batch of 1000: {defective_items}")

# Measure 100 products with target length 10cm and std dev 0.1cm
measurements = measure_products(100, 10, 0.1)
mean_length = sum(measurements) / len(measurements)
print(f"Average product length: {mean_length:.2f} cm")

# Count products outside tolerance (±0.3 cm)
out_of_tolerance = sum(abs(m - 10) > 0.3 for m in measurements)
print(f"Products out of tolerance: {out_of_tolerance}")

Results for: Real-Life Example: Quality Control

Defective items in batch of 1000: 8
Average product length: 10.00 cm
Products out of tolerance: 3

Additional Resources

For a deeper understanding of probability distributions and their applications, consider exploring these peer-reviewed articles from arXiv.org:

1. "A Survey of Probability Theory with Applications to Machine Learning" (arXiv:2006.09280) URL: https://arxiv.org/abs/2006.09280
2. "Probability Distributions in Statistical Machine Learning" (arXiv:1804.01747) URL: https://arxiv.org/abs/1804.01747

These resources provide more advanced topics and applications of probability distributions in various fields of study.