基于抛硬币实验：如何在Python中实现随机变量运算？

Great question! When working with random variable operations in Python—especially for straightforward experiments like counting heads across two fair, independent coins—there are a few clean, standardized approaches depending on whether you want to work with formal statistical distributions or simulate raw samples directly. Let’s break them down with best practices in mind:

If you want to work with the statistical properties of your random variables (like their distribution, expected value, or probability mass function), scipy.stats is the way to go. Here’s how to handle the two-coin experiment properly:

• Leverage known distribution properties: Since each coin flip is an independent Bernoulli random variable (p=0.5), the sum of two such variables follows a Binomial distribution with n=2 and p=0.5. You can directly use this combined distribution for sampling or calculations:

  from scipy.stats import binom
  
  # Generate 10 samples of total heads across two coins
  total_heads_samples = binom.rvs(n=2, p=0.5, size=10)
  
  # Calculate the probability of getting exactly 1 head
  prob_one_head = binom.pmf(k=1, n=2, p=0.5)
  

• Explicitly combine independent variables: If you need to track the outcome of each coin separately (not just the sum), you can sample each Bernoulli variable and add them:

  from scipy.stats import bernoulli
  
  num_experiments = 10
  coin1_samples = bernoulli.rvs(p=0.5, size=num_experiments)
  coin2_samples = bernoulli.rvs(p=0.5, size=num_experiments)
  total_heads = coin1_samples + coin2_samples
  

  Pro tip: Use the random_state parameter in rvs() to ensure your results are reproducible (e.g., bernoulli.rvs(p=0.5, size=10, random_state=42)).

If your goal is to simulate raw coin flip outcomes quickly (especially for large numbers of experiments), numpy’s vectorized operations are ideal. Here’s the clean, efficient way to do it:

• Batch-generate all flips at once: Instead of calling np.random.randint multiple times, create a 2D array where each row represents one experiment with two coins, then sum across rows:

  import numpy as np
  
  num_experiments = 10
  # Generate 10 experiments, each with 2 coin flips (0=tails, 1=heads)
  coin_flips = np.random.randint(0, 2, size=(num_experiments, 2))
  # Sum each row to get total heads per experiment
  total_heads = coin_flips.sum(axis=1)
  

• Directly sample the sum: Just like with scipy.stats, you can use numpy’s built-in binomial sampler to generate the total heads directly, skipping the individual flip step:

  total_heads = np.random.binomial(n=2, p=0.5, size=num_experiments)
  

  Pro tip: Always set a random seed (np.random.seed(42)) if you need to replicate your simulation results later.

• Match your tool to your goal: Use scipy.stats when you need to work with statistical properties (PMFs, expectations, variances). Use numpy when you need fast, large-scale simulations.
• Avoid redundant code: Batch operations are always better than repeated single calls—they’re faster and more readable.
• Prioritize readability: Name variables clearly (e.g., total_heads instead of x) so anyone reading your code can immediately understand what’s happening.
• Reproducibility: Never skip setting a random seed for experiments that need to be verified or repeated.

内容的提问来源于stack exchange，提问作者fuglede