How to Calculate Relative Frequency in Python

Relative frequency measures how frequently a certain value occurs in a data set relative to the total number of values in that data set.

You can use the following function in Python to calculate relative frequencies for any iterable list:

def rel_freq(x):
    freqs = [(value, x.count(value) / len(x)) for value in set(x)] 
    return freqs

The following practical examples demonstrate how to apply and utilize this robust function across various data types and structures commonly encountered in statistical programming.

Case Study 1: Analyzing Numerical Data in a List

Our first example applies the rel_freq function to a simple list containing integer data. This scenario is typical when dealing with raw measurement results, scores, or coded responses. The list data represents seven observations, and our goal is to determine the proportion associated with each unique numerical observation, such as the number 1, 2, 3, and 4.

Executing the custom function against this list initiates the process: the unique set of values is identified as {1, 2, 3, 4}. The function then calculates the count for each (e.g., 1 appears 3 times, 4 appears 2 times) and divides these counts by the total length of the list, which is 7. The resulting output, presented as a list of tuples, maps each unique value to its corresponding Relative frequency, providing an immediate snapshot of the data distribution.

#define data
data = [1, 1, 1, 2, 3, 4, 4]

#calculate relative frequencies for each value in list
rel_freq(data)

[(1, 0.42857142857142855),
 (2, 0.14285714285714285),
 (3, 0.14285714285714285),
 (4, 0.2857142857142857)]

The output from this calculation is interpreted by matching the value to its proportion of occurrence within the entire data set, providing a quantitative understanding of how often each number appears:

• The value “1” has a Relative frequency of 0.42857 in the dataset, meaning it accounts for roughly 42.86% of all observations.
• The value “2” has a Relative frequency of 0.142857 in the dataset, accounting for approximately 14.29% of the total.
• The value “3” has a Relative frequency of 0.142857 in the dataset, identical to value “2.”
• The value “4” has a Relative frequency of 0.28571 in the dataset, representing about 28.57% of the data.

A critical validation step is performed by summing all of the calculated relative frequencies. As expected, when these values are aggregated, their total must precisely equate to 1.0, confirming that the entire sample space has been correctly normalized and accounted for during the statistical calculation.

Case Study 2: Working with Categorical Data

Relative frequency calculation is not limited to numerical data; it is equally effective and necessary for analyzing categorical data, such as strings, characters, or text labels. This is particularly relevant in natural language processing or when analyzing qualitative survey responses. In this case study, we examine a list composed of characters representing different categories (‘a’, ‘b’, and ‘c’).

The process remains identical: the function identifies the unique categories {‘a’, ‘b’, ‘c’}, counts their absolute frequency (e.g., ‘a’ appears 2 times, ‘b’ appears 2 times, ‘c’ appears 1 time), and divides these counts by the total number of observations, which is 5. The resulting relative proportions immediately clarify the distribution of these categories.

#define data
data = ['a', 'a', 'b', 'b', 'c']

#calculate relative frequencies for each value in list
rel_freq(data)

[('a', 0.4), ('b', 0.4), ('c', 0.2)]

Interpreting this output provides clear insights into the distribution of these categorical variables within the sample data set:

• The category “a” has a relative frequency of 0.4 in the dataset, indicating that it makes up 40% of the sample.
• The category “b” has a relative frequency of 0.4 in the dataset, also accounting for 40% of the sample.
• The category “c” has a relative frequency of 0.2 in the dataset, representing the remaining 20%.

As before, the sum of these calculated proportions (0.4 + 0.4 + 0.2) equals 1.0, confirming the mathematical accuracy of the Relative frequency distribution for this categorical data set. This consistent summing to unity is a hallmark of a properly normalized probability distribution.

Case Study 3: Handling Tabular Data with pandas

In real-world data science projects, data is rarely stored in simple Python lists; it is typically organized in tabular formats, often handled using the powerful pandas library. While pandas offers highly optimized built-in methods for frequency counting (like value_counts(normalize=True)), our custom rel_freq function can still be adapted to process data extracted from a pandas DataFrame column.

This example demonstrates how to define a DataFrame and then extract a specific column (‘A’) into a standard Python list using list(data['A']). This conversion step is necessary because our custom rel_freq function was written to operate on standard Python lists, not native pandas Series objects. Once converted, the function executes the frequency calculation as demonstrated in the previous cases, providing the relative distribution of values within that specific column.

import pandas as pd

#define data
data = pd.DataFrame({'A': [25, 15, 15, 14, 19],
                     'B': [5, 7, 7, 9, 12],
                     'C': [11, 8, 10, 6, 6]})

#calculate relative frequencies of values in column 'A'
rel_freq(list(data['A']))

[(25, 0.2), (19, 0.2), (14, 0.2), (15, 0.4)]

The resulting output specifically details the relative distribution of the numerical values found within Column ‘A’ of the pandas DataFrame:

• The value “25” has a relative frequency of 0.2 in the column, meaning 20% of the entries in Column A are 25.
• The value “19” has a relative frequency of 0.2 in the column, representing 20% of the data points.
• The value “14” has a relative frequency of 0.2 in the column, accounting for another 20%.
• The value “15” has a relative frequency of 0.4 in the column, indicating that it is the modal value, occurring 40% of the time.

This powerful application demonstrates how a simple, custom Python function can be integrated into environments dominated by advanced libraries like pandas, provided the data is correctly prepared for input. Furthermore, the sum of these relative frequencies (0.2 + 0.2 + 0.2 + 0.4) confirms that the total probability remains exactly 1.0.

Advantages and Limitations of the Custom Function

The custom rel_freq function implemented using base Python features offers several distinct advantages, primarily its simplicity and independence from external dependencies. It is an excellent pedagogical tool for understanding the underlying statistical mechanics of Relative frequency calculation, relying only on native data structures like lists and sets. For small- to medium-sized data sets, its performance is perfectly acceptable, offering rapid computation and clear, tuple-based output that is easy to integrate into further analyses.

However, this approach also carries certain limitations, especially when compared to specialized libraries. For extremely large data sets (millions of entries), the repeated use of the list.count() method within the list comprehension can become computationally expensive. The count() method necessitates iterating over the entire list for every unique element, leading to O(n*k) complexity, where n is the data size and k is the number of unique values. Libraries like pandas and NumPy use highly optimized C-based implementations that reduce this overhead significantly, often achieving near O(n) complexity.

Therefore, while the custom function is ideal for educational purposes and lightweight tasks, professionals dealing with big data should pivot to library-optimized solutions. For instance, the pandas value_counts(normalize=True) method achieves the same result as our function but with vastly superior performance and seamless integration into the DataFrame workflow, avoiding the need for list conversion. Understanding the trade-off between implementation simplicity and computational efficiency is paramount in data engineering.

Conclusion: The Power of Proportional Analysis

Calculating the Relative frequency is a powerful statistical technique that shifts focus from raw counts to proportional distribution, essential for comparisons and probability estimation. The custom Python function presented herein provides a robust and clear way to execute this calculation using foundational programming concepts, making it accessible even to beginners in data analysis.

By successfully applying this function to numerical lists, categorical data, and columns extracted from complex structures like pandas DataFrames, we have demonstrated its versatility. Whether you are identifying the most common error code in a log file or the proportion of specific genotypes in a population study, relative frequencies are the cornerstone of informed decision-making based on empirical data.

Mastering this technique ensures that analysts can accurately summarize the distributional properties of any data set, moving beyond simple counts to reveal the probability structure of the underlying data generation process.

Further Resources for Statistical Computing

To deepen your understanding of proportional analysis and related statistical tools, the following resources are highly recommended for continued study:

Relative Frequency Calculator
Relative Frequency Histogram: Definition + Example
How to Calculate Relative Frequency in Excel