Why Random sampling distributions in NumPy? - Purpose & Use Cases

The Big Idea

What if you could see all the ways your data might behave, not just one guess?

The Scenario

Imagine you want to understand the average height of people in a city. You try measuring a few friends manually and guess the average. But your small group might not represent the whole city well.

The Problem

Manually picking samples is slow and biased. You might pick friends who are all tall or all short, leading to wrong conclusions. It's hard to repeat this fairly many times to see how averages change.

The Solution

Random sampling distributions let computers pick many fair samples automatically. This shows how averages or other stats vary naturally, helping you trust your results and understand uncertainty.

Before vs After

✗ Before

samples = [170, 172, 168, 171]
avg = sum(samples)/len(samples)

✓ After

import numpy as np
population = np.array([160, 165, 170, 175, 180, 185, 190])
samples = np.random.choice(population, size=30, replace=True)
avg = np.mean(samples)

What It Enables

It opens the door to understanding how data behaves across many samples, making predictions and decisions more reliable.

Real Life Example

Pollsters use random sampling distributions to estimate election results by surveying a small, fair group instead of every voter.

Key Takeaways

Manual sampling is slow and biased.

Random sampling distributions automate fair, repeated sampling.

This helps us understand data variability and trust our conclusions.

Practice

1. What does the numpy.random.choice function do in random sampling?

easy

A. It selects random elements from a given array or list.

B. It generates random numbers from a normal distribution.

C. It creates a sequence of numbers with equal spacing.

D. It calculates the mean of a dataset.

Solution

1. Step 1: Understand the purpose of numpy.random.choice

   This function is used to randomly pick elements from an input array or list, optionally with replacement.

2. Step 2: Compare with other options

   Options A, B, and C describe different numpy functions or operations unrelated to random selection from an array.

3. Final Answer:

   It selects random elements from a given array or list. -> Option A

4. Quick Check:

   numpy.random.choice = random selection [OK]

Hint: Remember: choice picks from arrays, normal generates bell curve numbers [OK]

Common Mistakes:

• Confusing choice with normal distribution generator
• Thinking choice creates sequences
• Assuming choice calculates statistics

2. Which of the following is the correct syntax to generate 5 samples from a binomial distribution with 10 trials and success probability 0.3 using numpy?

easy

A. numpy.binomial(10, 0.3, 5)

B. numpy.random.binomial(10, 0.3, size=5)

C. numpy.random.binomial(size=5, 10, 0.3)

D. numpy.random.binomial(5, 10, 0.3)

Solution

1. Step 1: Recall the numpy binomial function signature

   The correct syntax is numpy.random.binomial(n, p, size) where n is number of trials, p is success probability, and size is number of samples.

2. Step 2: Check each option

   numpy.random.binomial(10, 0.3, size=5) matches the correct order and uses the keyword size. numpy.binomial(10, 0.3, 5) misses .random. numpy.random.binomial(size=5, 10, 0.3) mixes keyword size=5 followed by positionals, causing SyntaxError. numpy.random.binomial(5, 10, 0.3) swaps parameters incorrectly.

3. Final Answer:

   numpy.random.binomial(10, 0.3, size=5) -> Option B

4. Quick Check:

   binomial(n, p, size) = numpy.random.binomial(10, 0.3, size=5) [OK]

Hint: Remember order: trials, probability, then size keyword [OK]

Common Mistakes:

• Mixing argument order
• Omitting size keyword
• Using wrong function name

3. What is the output of the following code?

import numpy as np
np.random.seed(0)
samples = np.random.normal(loc=5, scale=2, size=3)
print(np.round(samples, 2))

medium

A. [7.65 5.12 6.34]

B. [8.53 4.32 6.58]

C. [8.82 4.0 6.89]

D. [8.53 5.8 6.96]

Solution

1. Step 1: Understand the code

   The code sets a random seed for reproducibility, then generates 3 samples from a normal distribution with mean 5 and standard deviation 2.

2. Step 2: Run or recall the output

   Using seed 0, the samples generated are [8.53, 5.8, 6.96] after rounding to 2 decimals.

3. Final Answer:

   [8.53 5.8 6.96] -> Option D

4. Quick Check:

   Seed 0 normal samples = [8.53 5.8 6.96] [OK]

Hint: Use seed for fixed output, then round to compare [OK]

Common Mistakes:

• Ignoring seed causes different outputs
• Rounding incorrectly
• Mixing mean and scale parameters

4. Identify the error in this code snippet that tries to sample 4 values from a uniform distribution between 0 and 1:

import numpy as np
samples = np.random.uniform(low=0, high=1, size=4)
print(samples)

medium

A. There is no error; the code runs correctly.

B. The parameters low and high are reversed.

C. The function name should be random.uniform without numpy prefix.

D. The size parameter must be a tuple, not an integer.

Solution

1. Step 1: Review the numpy uniform function syntax

   np.random.uniform(low, high, size) is the correct way to generate samples from a uniform distribution.

2. Step 2: Check the code correctness

   The code uses correct function name, parameter order, and size as integer for 1D array. It will run without error and print 4 random values between 0 and 1.

3. Final Answer:

   There is no error; the code runs correctly. -> Option A

4. Quick Check:

   Uniform sampling syntax correct = There is no error; the code runs correctly. [OK]

Hint: Check function name and parameter order carefully [OK]

Common Mistakes:

• Confusing numpy.random.uniform with Python's random.uniform
• Swapping low and high values
• Using tuple for size unnecessarily

5. You want to simulate rolling a fair six-sided die 1000 times and count how many times the number 4 appears. Which numpy code correctly performs this simulation?

hard

A. rolls = np.random.choice([1,2,3,4,5,6], size=1000)
count_4 = np.sum(rolls == 4)

B. rolls = np.random.binomial(6, 1/6, size=1000)
count_4 = np.count_nonzero(rolls == 4)

C. rolls = np.random.randint(1, 7, size=1000)
count_4 = np.sum(rolls == 4)

D. rolls = np.random.normal(4, 1, size=1000)
count_4 = np.sum(rolls == 4)

Solution

1. Step 1: Understand the problem

   We want to simulate rolling a die 1000 times, each roll equally likely from 1 to 6, then count how many times 4 appears.

2. Step 2: Evaluate each option

   rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4): rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4) uses randint from 1 to 6 (exclusive upper bound 7), perfect for die rolls. rolls = np.random.binomial(6, 1/6, size=1000) count_4 = np.count_nonzero(rolls == 4): rolls = np.random.binomial(6, 1/6, size=1000) count_4 = np.count_nonzero(rolls == 4) uses binomial which models number of successes in trials, not die rolls. rolls = np.random.choice([1,2,3,4,5,6], size=1000) count_4 = np.sum(rolls == 4): rolls = np.random.choice([1,2,3,4,5,6], size=1000) count_4 = np.sum(rolls == 4) omits replace=True (defaults to False), raising ValueError since size=1000 > 6. rolls = np.random.normal(4, 1, size=1000) count_4 = np.sum(rolls == 4): rolls = np.random.normal(4, 1, size=1000) count_4 = np.sum(rolls == 4) uses normal distribution, inappropriate for discrete die rolls.

3. Step 3: Choose the best correct code

   rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4) is the correct way to simulate die rolls and count 4s.

4. Final Answer:

   rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4) -> Option C

5. Quick Check:

   Use randint for discrete uniform die rolls = rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4) [OK]

Hint: Use randint(1,7) for dice rolls, then count matches [OK]

Common Mistakes:

• Using binomial instead of uniform discrete
• Using normal distribution for discrete outcomes
• Forgetting replace=True in choice