Creating Z-Score Tables in Python: A Step-by-Step Guide

Yashmeet Singh · Sep 30, 2024 · 9 minute read

Introduction

In a recent article, we covered the concept of z-score and its applications. We also learned about cumulative probability. It is the probability of selecting a random value that is less than or equal to a specific value in a given distribution.

In this article, we’ll cover the z-score table (aka z-table), which is used to find the cumulative probability for a specific z-score in a standard normal distribution¹.

I’ll show you how to use a z-score table. Then, we’ll dive into a hands-on session where we’ll create this table in Python using popular data analysis and statistical libraries.

Let’s get started!

Using Z-Score Table

The z-score tables allow us to find the cumulative probabilities for z-scores between $-4$ to $4$ for a normal distribution.

The table arranges the z-scores along the left column and the top row. The left column contains the z-score to one decimal. The top row has the second decimal of the z-score. Each cell in the table shows the cumulative probability for a z-score that’s calculated by adding the row and column headers:

Let me illustrate how to use the z-score table using an example.

Suppose you want to determine the probability that a random value falls below the z-score of $1.25$. First, we find z-score to one decimal ($1.2$) in the left column. Then, go across that row to the column with the second decimal ($+ 0.05$) at the top. The probability is found in the intersecting cell ($0.89435$).

Thus, $89.435\%$ of values in normal distribution fall below the z-score of $1.25$. We can depict this using the density curve as well. The below graph shows this cumulative probability as the shaded area to the left of z-score of $1.25$:

Now that you know how to use the z-score table, let’s create it using Python.

Creating Z-Score Table

The full z-table is usually broken into two tables - one containing probabilities for positive z-scores $(0$ to $4)$ and another for the negative z-scores $(-4$ to $0)$. The screenshot in the last section showed the positive z-score table.

We’ll first build the table with the positive z-scores. Here are the steps we’ll follow:

• Build a 2-dimensional grid where:
  • The left column has the z-score from $0$ to $4.0$ in increments of $0.1$.
  • The top row goes from $0.00$ to $0.09$ with a step of $0.01$.
• Each cell of the grid represents a z-score up to 2 decimals - it is the sum of the corresponding row and column headers (e.g., $1.2 + 0.05 = 1.25$)
• Find the cumulative probability for the z-score in each cell.
• The resulting grid with the above probabilities is the z-score table.

We’ll implement these steps in Python using the popular libraries for data analysis (NumPy, Pandas) and statistics (SciPy stats).

Let’s start off by importing these libraries:

# Import required libraries
import numpy as np
import scipy.stats as stats
import pandas as pd

Step 1: Create Row and Column Headers

We’ll use NumPy’s arange() function to create the row and column headers. The row headers will contain the z-scores from $0$ to $4$, evenly spaced with a step of $0.1$:

# The row headers (the first column in the table).
# The 2nd parameter (end of interval) is excluded from the output.  
# Thus, we'll set it to 4.1 to get values from 0 to 4.
row_headers = np.arange(0, 4.1, 0.1)
row_headers

array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 
       1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. , 
       2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3. , 
       3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4. ])

And the column headers has the second decimal values $(0.0, 0.01, 0.02,..., 0.09)$:

# The column headers (the first row in the table)
column_headers = np.arange(0.0, 0.10, 0.01)
column_headers

array([0.  , 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09])

Step 2: Create a 2-Dimensional Grid

Next, we want to create a table with all possible combinations of the above two headers. Let’s use NumPy’s meshgrid() for this purpose. It’ll generate a 2D grid with coordinate pairs for each combination of row and column headers.

# Generate a 2D grid of column and row headers.
# It'll return two 2D arrays containing pairs for 
# for each combination of row and column headers.
X1, X2 = np.meshgrid(column_headers, row_headers)

When we add X1 and X2, we’ll get the grid of z-scores values of 2 decimal places. Let’s look at the first 5 rows:

z_score_grid = X1 + X2
z_score_grid[:5]

array([[0.  , 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09],
       [0.1 , 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19],
       [0.2 , 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29],
       [0.3 , 0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39],
       [0.4 , 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49]])

And the last 5 rows:

z_score_grid[-5:]

array([[3.6 , 3.61, 3.62, 3.63, 3.64, 3.65, 3.66, 3.67, 3.68, 3.69],
       [3.7 , 3.71, 3.72, 3.73, 3.74, 3.75, 3.76, 3.77, 3.78, 3.79],
       [3.8 , 3.81, 3.82, 3.83, 3.84, 3.85, 3.86, 3.87, 3.88, 3.89],
       [3.9 , 3.91, 3.92, 3.93, 3.94, 3.95, 3.96, 3.97, 3.98, 3.99],
       [4.  , 4.01, 4.02, 4.03, 4.04, 4.05, 4.06, 4.07, 4.08, 4.09]])

We’ve got the grid of evenly spaced z-scores going from $0$ to $4$. Lets move to the next step.

Step 3: Calculate Cumulative Probability

The norm.cdf() function from SciPy stats returns the cumulative probability for a given z-score in a normal distribution. Let’s use it for the z-score of $1.25$:

# Find the cumulative 
stats.norm.cdf(1.25)

0.8943502263331446

About $89.435$% of values fall below the z-score of 1.25. This is the same result we saw earlier.

Applying norm.cdf() to z_score_grid will return a 2D array containing the cumulative probability for all z-scores:

# Get cumulative probability for all the z-scores. 
z_score_cdf_grid = stats.norm.cdf(z_score_grid)
# Print the first five rows
z_score_cdf_grid[:5]

array([[0.5       , 0.50398936, 0.50797831, 0.51196647, 0.51595344,
        0.51993881, 0.52392218, 0.52790317, 0.53188137, 0.53585639],
       [0.53982784, 0.54379531, 0.54775843, 0.55171679, 0.55567   ,
        0.55961769, 0.56355946, 0.56749493, 0.57142372, 0.57534543],
       [0.57925971, 0.58316616, 0.58706442, 0.59095412, 0.59483487,
        0.59870633, 0.60256811, 0.60641987, 0.61026125, 0.61409188],
       [0.61791142, 0.62171952, 0.62551583, 0.62930002, 0.63307174,
        0.63683065, 0.64057643, 0.64430875, 0.64802729, 0.65173173],
       [0.65542174, 0.65909703, 0.66275727, 0.66640218, 0.67003145,
        0.67364478, 0.67724189, 0.68082249, 0.6843863 , 0.68793305]])

Next, let’s convert the above 2D array into a pandas DataFrame and set the row and column headers. That’ll make it easy to look up the probability for a given z-score:

positive_z_score_table = pd.DataFrame(
    # Pass the z-score CDF 2D array 
    z_score_cdf_grid,
    # Set the single decimal z-scores as the index
    index=row_headers, 
    # Set array with 2nd decimal as the columns header
    columns=column_headers
)
# Print the first 5 rows
positive_z_score_table.head()

Let’s make a few more improvements. We’ll add a plus sign in front of the column header values. That’ll indicate that we need to add the z-score from the row header to the $2$^nd decimal value found in the column header. We’ll also round all the probabilities to 5 decimals:

# Format the column headers - add leading + sign
formatted_cols = [f"+ {col:.2f}" for col in column_headers]
positive_z_score_table.columns = formatted_cols
 
# round all probability values to 5 decimals 
positive_z_score_table.round(5)

This is the z-score table you’ll find in most statistics textbooks and online resources.

Negative Z-Score Table

So far, we have constructed the table for positive z-scores ($0$ to $4$). Let’s build a similar table for the negative z-scores ($-4$ to $0$). We’ll follow the steps from the last section, but with a few modifications.

The row and column headers will contain negative values. First, prepare row headers with the negative z-scores from $-4$ to $0$, going up evenly by $0.1$:

# Row headers from -4 to 0, with a step of 0.1
# The 2nd parameter (end of interval) is excluded from the output.  
# Thus, we'll set it to 0.01 to get values from -4 to 0. 
row_headers = np.arange(-4, 0.01, 0.1).round(2)
row_headers

array([-4. , -3.9, -3.8, -3.7, -3.6, -3.5, -3.4, -3.3, -3.2, -3.1, 
       -3. , -2.9, -2.8, -2.7, -2.6, -2.5, -2.4, -2.3, -2.2, -2.1, 
       -2. , -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3, -1.2, -1.1, 
       -1. , -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1,  
       0. ])

And prepare the column headers going from $0$ to $-0.09$, with a step of $-0.01$:

# From 0.0 to -0.09 with a step of -0.01
column_headers = np.arange(0.0, -0.10, -0.01)
column_headers

array([ 0.  , -0.01, -0.02, -0.03, -0.04, -0.05, -0.06, -0.07, -0.08,
       -0.09])

Next, use NumPy’s meshgrid() to create a 2D grid with all the possible combinations of above row and column headers:

# Generate coordinate pairs for each combination of
# row and column headers 
X1, X2 = np.meshgrid(column_headers, row_headers)

Finally, calculate the cumulative probability of each cell in the grid using SciPy norm.cdf(). And convert the output into a pandas DataFrame with appropriate headers:

# Add the coordinates in each cell and 
# get cumulative probability for the sum 
z_score_cdf_grid = stats.norm.cdf(X1 + X2)
 
# Prepare pandas dataframe
negative_z_score_table = pd.DataFrame(
    z_score_cdf_grid,
    index=row_headers, 
    columns=column_headers
)
 
# Round the probabilities to 5 decimals
negative_z_score_table.round(5)

There you have it. We’ve created the negative z-score table as well!

We now have two z-score tables - one with positive z-scores ($0$ to $4$) and another with negative z-scores ($-4$ to $0$). Together, these tables allow us to find the cumulative probability for any z-score from $-4$ to $4$.

Summary

In this article, you learned about the z-score tables and how to use them to find cumulative probability for any given z-score. Then we created the z-score tables using Python, NumPy, SciPy, and pandas.

While it’s true that you can easily find these tables online, the process of creating them from scratch deepens your understanding of z-score and normal distribution, and allows you to customize them for any purpose. This invaluable combination of conceptual knowledge and practical skills provides you with a strong foundation for advanced data and statistical analysis.