Normal distribution with normal() in NumPy - Step-by-Step Execution

Concept Flow - Normal distribution with normal()

Call np.random.normal(mean, std, size)

↓

Generate random values

↓

Return array of values

↓

Use values for analysis or plot

The function np.random.normal() generates random numbers following a bell-shaped curve defined by mean and standard deviation.

Execution Sample

NumPy

import numpy as np
values = np.random.normal(0, 1, 5)
print(values)

Generate 5 random numbers from a normal distribution with mean 0 and std 1, then print them.

Execution Table

Step	Action	Parameters	Generated Values	Output
1	Call np.random.normal	mean=0, std=1, size=5	N/A	N/A
2	Generate 5 random values	N/A	[0.5, -1.2, 0.3, 1.1, -0.7]	N/A
3	Return array	N/A	[0.5, -1.2, 0.3, 1.1, -0.7]	[0.5, -1.2, 0.3, 1.1, -0.7]
4	Print values	N/A	N/A	[0.5, -1.2, 0.3, 1.1, -0.7]

💡 All 5 values generated and printed, execution ends.

Variable Tracker

Variable	Start	After np.random.normal call	Final
values	undefined	[0.5, -1.2, 0.3, 1.1, -0.7]	[0.5, -1.2, 0.3, 1.1, -0.7]

Key Moments - 2 Insights

Why do the generated values look different each time I run the code?

Because np.random.normal generates random numbers each time, the values change on every run as shown in the execution_table rows 2 and 3.

What do the mean and std parameters control?

Mean shifts the center of the values, std controls how spread out they are. This is why in the execution_table step 1, mean=0 and std=1 define the shape of generated values.

Visual Quiz - 3 Questions

Look at the execution_table, what is the variable 'values' after step 2?

A undefined

B [0.5, -1.2, 0.3, 1.1, -0.7]

C N/A

D [0, 0, 0, 0, 0]

💡 Hint

Check the 'Generated Values' column in row 2 of execution_table.

At which step does the function return the generated array?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look for the 'Return array' action in execution_table.

If we change std from 1 to 2, how would the generated values change?

A Values would all be zero

B Values would be closer to the mean

C Values would be more spread out from the mean

D Values would not change

💡 Hint

Recall std controls spread as explained in key_moments and concept_flow.

Concept Snapshot

np.random.normal(mean, std, size) generates random numbers
from a normal distribution with given mean and std deviation.
Returns an array of 'size' values.
Mean shifts center; std controls spread.
Values differ each run due to randomness.

Full Transcript

This visual execution shows how np.random.normal works step-by-step. First, the function is called with mean 0, std 1, and size 5. Then, it generates 5 random values following the bell curve shape. These values are returned as an array and printed. The variable 'values' holds these numbers after generation. The randomness means values change each run. Mean and std control the center and spread of the numbers. This helps in simulations and data analysis where normal distribution is assumed.

Practice

1. What does the loc parameter control in the numpy.random.normal() function?

easy

A. The spread (standard deviation) of the normal distribution

B. The center (mean) of the normal distribution

C. The number of random values generated

D. The shape of the distribution curve

Solution

1. Step 1: Understand the parameters of normal()

   The normal() function has parameters loc and scale. loc sets the mean (center) of the distribution.

2. Step 2: Identify the role of loc

   The mean is the center point where most values cluster in a bell curve.

3. Final Answer:

   The center (mean) of the normal distribution -> Option B

4. Quick Check:

   loc = center [OK]

Hint: Remember: loc = center, scale = spread [OK]

Common Mistakes:

• Confusing loc with scale
• Thinking loc controls number of samples
• Assuming loc changes distribution shape

2. Which of the following is the correct syntax to generate 5 random numbers from a normal distribution with mean 10 and standard deviation 2 using numpy?

easy

A. numpy.random.normal(size=5, mean=10, std=2)

B. numpy.normal(10, 2, 5)

C. numpy.random.normal(5, loc=10, scale=2)

D. numpy.random.normal(loc=10, scale=2, size=5)

Solution

1. Step 1: Recall the correct function and parameters

   The function is numpy.random.normal() with parameters loc for mean, scale for std dev, and size for number of samples.

2. Step 2: Match parameters to correct syntax

   numpy.random.normal(loc=10, scale=2, size=5) correctly uses loc=10, scale=2, and size=5.

3. Final Answer:

   numpy.random.normal(loc=10, scale=2, size=5) -> Option D

4. Quick Check:

   Correct parameter names and order [OK]

Hint: Use loc=mean, scale=std, size=number [OK]

Common Mistakes:

• Using wrong parameter names like mean or std
• Mixing order without keywords
• Calling numpy.normal instead of numpy.random.normal

3. What is the output shape of the following code?

import numpy as np
arr = np.random.normal(loc=0, scale=1, size=(3,4))
print(arr.shape)

medium

A. (12,)

B. (4, 3)

C. (3, 4)

D. (3,)

Solution

1. Step 1: Understand the size parameter

   The size argument is set to (3,4), which means generate a 2D array with 3 rows and 4 columns.

2. Step 2: Check the shape of the generated array

   Printing arr.shape returns the shape tuple, which matches the size argument.

3. Final Answer:

   (3, 4) -> Option C

4. Quick Check:

   size=(3,4) means shape=(3,4) [OK]

Hint: size tuple = output shape [OK]

Common Mistakes:

• Confusing rows and columns order
• Expecting flattened array shape
• Ignoring tuple format for size

4. Identify the error in this code snippet:

import numpy as np
samples = np.random.normal(mean=0, std=1, size=10)
print(samples)

medium

A. Incorrect parameter names: should use loc and scale instead of mean and std

B. Missing import statement for numpy

C. size parameter must be a tuple, not an integer

D. The print statement syntax is wrong

Solution

1. Step 1: Check parameter names for normal()

   The function np.random.normal() expects loc for mean and scale for standard deviation, not mean or std.

2. Step 2: Verify other parts of the code

   Import is correct, size can be integer, and print syntax is valid.

3. Final Answer:

   Incorrect parameter names: should use loc and scale instead of mean and std -> Option A

4. Quick Check:

   Use loc and scale for mean and std [OK]

Hint: Use loc=mean, scale=std; mean/std are invalid [OK]

Common Mistakes:

• Using mean or std instead of loc and scale
• Thinking size must be tuple always
• Assuming print syntax error

5. You want to simulate daily temperatures for a week that average 20°C with a standard deviation of 3°C. Which code correctly generates this data and calculates the average temperature?

hard

A. temps = np.random.normal(loc=20, scale=3, size=7)
avg_temp = temps.mean()
print(round(avg_temp, 2))

B. temps = np.random.normal(mean=20, std=3, size=7)
avg_temp = temps.sum()
print(avg_temp)

C. temps = np.random.normal(loc=3, scale=20, size=7)
avg_temp = temps.mean()
print(avg_temp)

D. temps = np.random.normal(loc=20, scale=3, size=7)
avg_temp = temps.median()
print(avg_temp)

Solution

1. Step 1: Generate temperatures with correct parameters

   Use loc=20 for mean temperature and scale=3 for standard deviation, with size=7 for a week.

2. Step 2: Calculate the average temperature correctly

   Use temps.mean() to get the average. Round for neat output.

3. Final Answer:

   temps = np.random.normal(loc=20, scale=3, size=7) avg_temp = temps.mean() print(round(avg_temp, 2)) -> Option A

4. Quick Check:

   loc=mean, scale=std, mean() for average [OK]

Hint: Use loc=mean, scale=std, mean() to average [OK]

Common Mistakes:

• Swapping loc and scale values
• Using mean or std instead of loc and scale
• Using sum() instead of mean() for average
• Using median() instead of mean()