NumPy Random Distributions, Permutations, Seaborn Visualisation, and Universal Functions (ufuncs)

What is a Python Array (NumPy ndarray)?

Before we start, a very quick reminder. In NumPy, data is stored in an ndarray (n-dimensional array). Think of it as a super-powered list that can hold numbers very efficiently.

import numpy as np

arr = np.array([10, 20, 30, 40])
print(arr)

Expected Output:

[10 20 30 40]

What is a Python List?

A Python list is the built-in container: [1, 2, 3]. NumPy arrays and Python lists look similar but NumPy arrays are far faster for maths operations. You will see both used in this lesson.

What is a Library Import?

When you write from numpy import random, you are saying: "Go into the NumPy toolkit and bring out the random tool so I can use it directly." Instead of typing numpy.random.choice() every time, you just type random.choice().

What is a Data Distribution?

Imagine a bag of coloured marbles. You reach in and pull one out. A data distribution tells you the complete story of the bag: how many of each colour exist, and therefore how likely you are to pull each one.

In statistics and data science, a data distribution is a description of all the possible values a variable can take, and how often each value appears.

Real-world analogy: Think about a school canteen that sells only four snacks: biscuits, chips, juice, and water. If you ask 100 students what they bought, maybe 10 bought biscuits, 30 bought chips, 60 bought juice, and 0 bought water. That pattern · 10%, 30%, 60%, 0% · is the distribution of purchases.

What is Probability?

Probability is just a fancy word for "how likely is something to happen?" It is always a number between 0 and 1:

• 0 means it will never happen.
• 1 means it will always happen.
• 0.5 means it happens roughly half the time.

The probabilities for all possible outcomes must always add up to exactly 1.0 (because something must happen).

What is a Probability Density Function (PDF)?

A Probability Density Function is a mathematical description of a continuous distribution · that is, a distribution where the values can be any decimal number, not just whole numbers. It describes the probability of all values in an array or dataset.

Simple explanation: Think of a PDF like a recipe that tells you the "shape" of your data. A bell-curve PDF means most values cluster in the middle. A flat PDF means all values are equally likely.

The random.choice() Method

NumPy's random module gives us a method called choice(). This method lets you:

1. Give it a list of possible values.
2. Tell it exactly how likely each value should be (using probabilities).
3. Ask it to generate as many random picks as you want.

Syntax breakdown:

random.choice(values_list, p=probabilities_list, size=how_many_you_want)

• values_list · the list of values to pick from, e.g. [3, 5, 7, 9]
• p= · the probability for each value; must be the same length as the values list and must sum to exactly 1.0
• size= · how many random values to generate; can be a single number like (100,) or a shape like (3, 5) for a 2D array

Important rule: The probabilities in the p list must sum to exactly 1.0. If they don't, Python will raise an error.

Simple Example 1 · Weighted Coin Flip

Let's start with the simplest possible example: a coin that is more likely to land on heads.

from numpy import random

# Our coin: 1 = heads, 0 = tails
# Probability of heads = 0.7, tails = 0.3
result = random.choice([0, 1], p=[0.3, 0.7], size=(10))

print(result)

Expected Output (your output will vary because it is random):

[1 1 0 1 1 1 0 1 1 1]

Line-by-line explanation:

Thinking prompt: What would happen if you changed p=[0.3, 0.7] to p=[0.0, 1.0]? Would you ever see a 0? Try it!

Simple Example 2 · Weighted Choice with Four Values

Now let's pick from four possible values with different probabilities, just like the canteen example.

from numpy import random

# Values: 3, 5, 7, 9
# 3 has 10% chance, 5 has 30% chance, 7 has 60% chance, 9 has 0% chance
x = random.choice([3, 5, 7, 9], p=[0.1, 0.3, 0.6, 0.0], size=(100))

print(x)

Expected Output (yours will be different but follow the same pattern):

[7 7 5 7 7 3 7 5 7 7 7 5 7 7 7 7 7 5 7 7 7 5 7 7 7 7 7 5 7 7
 7 5 7 7 7 7 7 7 7 7 7 7 3 7 5 7 7 5 7 5 5 7 7 7 7 5 7 7 7 7
 5 7 7 7 5 5 7 7 7 5 7 7 5 7 7 7 7 7 7 5 7 7 3 5 7 7 5 7 7 7
 7 7 5 7 5 7 7 7 7 7]

Notice: The value 9 never appears because its probability is 0.0. The value 7 appears most often because it has the highest probability (0.6 = 60%).

Thinking prompt: Add up the probabilities: 0.1 + 0.3 + 0.6 + 0.0 = 1.0. They add up to exactly 1. This is always required.

Generating 2D Distribution Arrays

You can also generate the random values as a two-dimensional array (like a grid/table) by passing a tuple as the size parameter.

from numpy import random

# Same four values, same probabilities, but now get a 3×5 table
x = random.choice([3, 5, 7, 9], p=[0.1, 0.3, 0.6, 0.0], size=(3, 5))

print(x)

Expected Output:

[[7 5 7 7 7]
 [5 7 7 3 7]
 [7 7 5 7 7]]

Line-by-line explanation:

Real-world use: In data science, you might model a weather system where rain (probability 0.4), cloud (0.35), sun (0.2), and storm (0.05) occur across a 10-day, 5-city forecast grid.

What is a Permutation?

A permutation is simply a rearrangement of the same elements in a different order.

Everyday analogy: Imagine you have three books on your shelf: A, B, C. One arrangement is A-B-C. A permutation could be B-C-A or C-A-B. All three books are still there · they're just in a different order.

Examples of permutations:

• [1, 2, 3] is a permutation of [3, 2, 1]
• ["apple", "banana", "cherry"] is a permutation of ["banana", "cherry", "apple"]

NumPy's random module gives us two methods for working with permutations:

This is an important difference! Let's see both in action.

Method 1: shuffle() · Rearrange In-Place

"In-place" means the method directly modifies the original array. The array you started with gets a new order. Nothing new is created.

from numpy import random
import numpy as np

arr = np.array([1, 2, 3, 4, 5])

print("Before shuffle:", arr)

random.shuffle(arr)

print("After shuffle:", arr)

Expected Output (your shuffle order will vary):

Before shuffle: [1 2 3 4 5]
After shuffle:  [3 1 5 2 4]

Key point: After calling shuffle(arr), the original arr is permanently changed. The values [1, 2, 3, 4, 5] are now in a random order.

Common beginner mistake: Assigning the result to a new variable like this:

python❐ Copy

new_arr = random.shuffle(arr)  # WRONG! new_arr will be None

shuffle() does NOT return anything. It modifies arr directly and returns None. Simply call random.shuffle(arr) and then use arr.

Method 2: permutation() · Return a New Arrangement

permutation() is the safe option when you want a shuffled copy but need to keep your original data intact.

from numpy import random
import numpy as np

arr = np.array([1, 2, 3, 4, 5])

print("Original arr:", arr)

new_arr = random.permutation(arr)

print("New permutation:", new_arr)
print("Original arr still:", arr)

Expected Output:

Original arr: [1 2 3 4 5]
New permutation: [4 1 3 5 2]
Original arr still: [1 2 3 4 5]

Notice: arr is completely unchanged! The shuffled version is stored in new_arr.

Real-world use case: Imagine you have a list of 1000 student names for a quiz draw. You want to shuffle the order for fair selection, but you also want to keep the original alphabetical list intact for your records. Use permutation() · not shuffle().

Comparing shuffle() and permutation() Side by Side

from numpy import random
import numpy as np

original = np.array([10, 20, 30, 40, 50])

# --- Using shuffle ---
arr_for_shuffle = original.copy()  # Make a copy first to preserve original
random.shuffle(arr_for_shuffle)
print("After shuffle():     ", arr_for_shuffle)

# --- Using permutation ---
new_version = random.permutation(original)
print("After permutation(): ", new_version)
print("Original unchanged:  ", original)

Expected Output:

After shuffle():      [30 10 50 20 40]
After permutation():  [20 50 10 40 30]
Original unchanged:   [10 20 30 40 50]

Why Do We Need to Visualise?

Numbers alone can be hard to understand. When you generate 1000 random numbers, looking at them as a list tells you very little. A chart instantly shows you the shape: Are most values clustered together? Are they spread evenly? Are there extreme values?

This is exactly why data scientists use visualisation libraries · tools that turn numbers into charts.

What is Seaborn?

Seaborn is a Python library specifically built for making statistical charts and visualising data distributions beautifully. It sits on top of another library called Matplotlib · think of Seaborn as the fancy user-friendly wrapper around Matplotlib's more technical engine.

Analogy: Matplotlib is like a professional artist's full studio · powerful but takes time to set up. Seaborn is like a smart automated art assistant that handles all the setup for you.

Installing Seaborn

Before using Seaborn, you need to install it. Open your terminal/command prompt and run:

pip install seaborn

If you are using Jupyter Notebook, run this inside a cell:

!pip install seaborn

What is Matplotlib?

Matplotlib is the core plotting library for Python. Seaborn uses it behind the scenes. You need to import both.

import matplotlib.pyplot as plt   # For displaying charts
import seaborn as sns              # For creating distribution charts

• matplotlib.pyplot is imported as plt · a short name by convention
• seaborn is imported as sns · another short name by convention

What is a Displot?

Displot stands for distribution plot. It is Seaborn's function for visualising how data is distributed. It takes an array (a list of numbers) and draws a curve showing how the values are spread out.

Think of it like this: if you measured the heights of 1000 people and plotted them, the displot would show a curve peaking around the average height, with fewer and fewer people as you go towards very short or very tall heights.

Simple Example 1 · Basic Displot

import matplotlib.pyplot as plt
import seaborn as sns

# A small list of 6 numbers
sns.displot([0, 1, 2, 3, 4, 5])

plt.show()

What this produces: A distribution chart with:

• A histogram (vertical bars showing how often each value appears)
• A smooth curve over the bars showing the overall distribution shape

Line-by-line explanation:

Why plt.show()? Seaborn creates the chart in memory, but plt.show() is the command that pushes it to your screen. Without it, nothing appears.

Simple Example 2 · Displot Without the Histogram (KDE Only)

Sometimes you want to see only the smooth curve (called a KDE · Kernel Density Estimate) without the histogram bars underneath. This is useful when you have a lot of data and just want to see the shape.

import matplotlib.pyplot as plt
import seaborn as sns

# Pass kind="kde" to show only the smooth curve
sns.displot([0, 1, 2, 3, 4, 5], kind="kde")

plt.show()

What this produces: Only the smooth density curve · no bars.

What is KDE (Kernel Density Estimate)? A KDE is a smooth curve that estimates the probability distribution of your data. Instead of counting exact values in bins (like a histogram), it draws a flowing curve that approximates the shape of the data.

Key note: For the rest of the NumPy tutorial (particularly when visualising random distributions like Normal, Binomial, Poisson, etc.), the standard approach is to use sns.displot(arr, kind="kde").

Practical Example · Visualising a Random Distribution

Now let's combine what we learned in Part 1 with Seaborn to actually see a distribution:

from numpy import random
import matplotlib.pyplot as plt
import seaborn as sns

# Generate 1000 random values from our weighted choice
x = random.choice([3, 5, 7, 9], p=[0.1, 0.3, 0.6, 0.0], size=(1000))

# Visualise the distribution
sns.displot(x, kind="kde")
plt.title("Distribution of Weighted Random Choices")
plt.show()

What you will see: A curve with a large peak around 7 (since it has 60% probability), a smaller bump around 5 (30%), and a tiny presence near 3 (10%). The value 9 will not appear at all.

Thinking prompt: What would the chart look like if all four values had equal probability of 0.25? Try changing the p values and observe the shape.

What Are ufuncs?

ufuncs stands for Universal Functions. These are special NumPy functions that are designed to work on entire arrays at once · on every element simultaneously · instead of going through them one by one.

Analogy: Imagine you need to paint 100 fence posts. The slow way: you paint them one at a time with a small brush. The fast way: you use a spray painter that covers all 100 at once. ufuncs are NumPy's spray painter.

Why Use ufuncs?

The main reasons to use ufuncs are:

1. Speed (Vectorization): They are dramatically faster than Python loops for large datasets.
2. Simplicity: One line of code replaces a multi-line loop.
3. Extra power: They support special options like where, dtype, and out for advanced control.

What is Vectorization?

Vectorization means converting an operation that would normally loop over elements one-by-one into a single operation that processes the entire array at once.

Modern CPUs (the chips inside your computer) are specifically designed to perform these "do-it-to-everything-at-once" operations extremely fast. This is called SIMD (Single Instruction, Multiple Data) at the hardware level · but you don't need to worry about that. Just know that vectorization uses the computer's hardware more efficiently.

The Problem: Slow Python Loops

Let's first see the old slow way of adding two lists together:

# The slow Python way — using a loop
x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = []   # Empty list to store results

for i, j in zip(x, y):      # zip() pairs up elements: (1,4), (2,5), (3,6), (4,7)
    z.append(i + j)          # Add each pair and store the result

print(z)

Expected Output:

[5, 7, 9, 11]

Line-by-line explanation:

This works! But imagine doing this with 1 million numbers · it would be slow.

The Fast Way: NumPy's np.add() ufunc

NumPy has a built-in ufunc called add() that does exactly the same thing in one line, but much faster:

import numpy as np

x = [1, 2, 3, 4]
y = [4, 5, 6, 7]

z = np.add(x, y)   # Add all elements at once — no loop needed!

print(z)

Expected Output:

[ 5  7  9 11]

Notice: The result is exactly the same as the loop version! But np.add() did it in a single operation instead of iterating step by step.

Thinking prompt: The output looks like [ 5 7 9 11] (with spaces, no commas) instead of [5, 7, 9, 11]. Why? Because NumPy arrays print differently from Python lists · no commas, and numbers are aligned.

What Happens Inside np.add()?

Input x:  [1,  2,  3,  4]
Input y:  [4,  5,  6,  7]
            ↓   ↓   ↓   ↓
Result z: [5,  7,  9, 11]

NumPy processes each matching pair (position 0 with position 0, position 1 with position 1, and so on) all at the same time · this is element-wise operation.

Additional ufunc Arguments

ufuncs support special optional arguments that give you more control:

You do not need to memorise all of these right now. The key idea is: ufuncs are flexible tools that go beyond basic loops.

The Performance Difference: Why It Matters

To understand why vectorisation matters, consider this: if you have a dataset with 1 million data points (common in real data science work), a Python loop might take several seconds. The equivalent NumPy ufunc operation runs in milliseconds.

For example, adding two arrays of 1,000,000 numbers:

• Python loop: ~0.5 seconds
• NumPy ufunc: ~0.005 seconds (100x faster)

This is why data scientists, machine learning engineers, and scientists use NumPy · it makes working with large datasets practical.

Simple ufunc Examples to Consolidate

Example A · Adding arrays:

import numpy as np

a = np.array([10, 20, 30])
b = np.array([1, 2, 3])

result = np.add(a, b)
print(result)

Output: [11 22 33]

Example B · Multiplying arrays:

import numpy as np

a = np.array([2, 4, 6])
b = np.array([3, 3, 3])

result = np.multiply(a, b)
print(result)

Output: [ 6 12 18]

Example C · Squaring all elements (using np.power):

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

squared = np.power(arr, 2)   # Raise each element to the power of 2
print(squared)

Output: [ 1 4 9 16 25]

Thinking prompt: What would np.power(arr, 3) produce? Try to calculate the answer before running it.

Mistake 1 · Probabilities That Don't Sum to 1.0

# WRONG — probabilities sum to 0.9, not 1.0
x = random.choice([1, 2, 3], p=[0.2, 0.3, 0.4])  # Missing 0.1!

Error you will see:

ValueError: probabilities do not sum to 1

Correct version:

x = random.choice([1, 2, 3], p=[0.2, 0.3, 0.5])  # 0.2+0.3+0.5 = 1.0 ✓

Mistake 2 · Assigning the Return Value of shuffle()

# WRONG — shuffle() returns None, not the shuffled array
arr = np.array([1, 2, 3, 4])
shuffled = random.shuffle(arr)   # shuffled = None!
print(shuffled)  # Prints: None

Correct version:

arr = np.array([1, 2, 3, 4])
random.shuffle(arr)   # Modifies arr directly
print(arr)            # Prints the shuffled array

Mistake 3 · Wrong Number of Probabilities

# WRONG — 4 values but only 3 probabilities
x = random.choice([3, 5, 7, 9], p=[0.1, 0.3, 0.6])

Error:

ValueError: 'a' and 'p' must have same size

Correct version:

x = random.choice([3, 5, 7, 9], p=[0.1, 0.3, 0.6, 0.0])  # One probability per value

Mistake 4 · Forgetting plt.show() with Seaborn

import seaborn as sns
import matplotlib.pyplot as plt

sns.displot([1, 2, 3, 4, 5])
# Nothing appears! You forgot plt.show()

Correct version:

sns.displot([1, 2, 3, 4, 5])
plt.show()  # This actually displays the chart

Mistake 5 · Using a Python Loop Instead of a ufunc

# INEFFICIENT for large datasets
result = []
for val in big_array:
    result.append(val * 2)

Better version:

import numpy as np
result = np.multiply(big_array, 2)  # Faster and cleaner

Mistake 6 · Expecting shuffle() Not to Change the Original

arr = np.array([1, 2, 3, 4, 5])
random.shuffle(arr)
# arr is NOW changed — you cannot get the original back!

Safe version if you need the original:

arr = np.array([1, 2, 3, 4, 5])
arr_copy = arr.copy()    # Save a copy FIRST
random.shuffle(arr)       # Now it's safe — original is in arr_copy