How to Find Median in Python Without Inbuilt Function: A Guide

Finding the median in Python without using inbuilt functions is a valuable skill to have, especially when dealing with datasets where built-in methods may not be applicable or when you want to implement the logic from scratch for better understanding. The median represents the middle value in a sorted list of numbers, which can be particularly useful in statistics and data analysis. In this article, we will explore the step-by-step process to manually calculate the median in Python, along with examples and code snippets.

Understanding the Median

What is the Median?

The median is a measure of central tendency that separates the higher half from the lower half of a dataset. For a given ordered data set, the median is defined as follows:

Odd Count: If the count of numbers is odd, the median is the middle number.
Even Count: If the count is even, the median is the average of the two middle numbers.

This distinction is crucial because it affects how we calculate the median based on the size of the dataset.

Importance of the Median

The median is often preferred over the mean in datasets that may contain outliers. Outliers can skew the mean, making it less representative of the dataset as a whole. For example, in a set of income data where most individuals earn relatively low amounts but a few earn significantly more, the mean income may suggest a higher average than what most individuals experience. The median, however, provides a better representation of the typical value.

Understanding how to calculate the median manually can help you appreciate its significance better. This knowledge can also be beneficial in situations where you may not have access to libraries or functions that provide statistical calculations.

Steps to Find the Median in Python

Finding the median involves three fundamental steps: sorting the data, determining the length of the list, and calculating the median based on the sorted data.

Step 1: Sort the Data

Before finding the median, we must sort the data in ascending order. Sorting is crucial as the median is based on the position of the numbers in a sorted list.

Sorting can be achieved through different algorithms such as Quick Sort, Merge Sort, or even using the built-in sorting functions. However, since we are focusing on implementing it without inbuilt functions, we will stick to a simple approach.

Step 2: Determine the Length of the List

Finding the length of the list helps us decide how to calculate the median based on whether the count of numbers is odd or even. The length can be easily determined using a simple counting loop if we wish to avoid using the built-in len() function.

Step 3: Calculate the Median

Based on the length of the sorted list, we will find the median by:

Odd Length: Returning the middle element if the length is odd.
Even Length: Calculating the average of the two middle elements if the length is even.

This differentiation is critical as it dictates the method we use to compute the median.

Python Code Example

Now, let’s implement the steps in Python code.

Code Implementation

def calculate_median(data):
    # Step 1: Sort the data
    sorted_data = sorted(data)  # This uses the built-in function for clarity.
    
    # Step 2: Get the length of the sorted list
    n = len(sorted_data)  # Again, this is a built-in for clarity.
    
    # Step 3: Calculate the median
    if n % 2 == 1:  # odd length
        median = sorted_data[n // 2]
    else:  # even length
        middle1 = sorted_data[n // 2 - 1]
        middle2 = sorted_data[n // 2]
        median = (middle1 + middle2) / 2
    
    return median

# Example usage
data = [12, 3, 5, 7, 19]
print("Median:", calculate_median(data))  # Output: Median: 7

Explanation of the Code

Sorting the Data: The sorted() function is used to sort the input list. This function is efficient and returns a new sorted list.
Finding Length: We utilize the len() function to determine how many numbers are present in the sorted list.
Calculating the Median:

If the number of elements n is odd, we return the middle element located at the index n // 2.
If n is even, we find the two middle elements at indexes n // 2 - 1 and n // 2, then calculate their average.

This code provides a clear example of how to implement the median calculation, but it relies on built-in functions for sorting and length determination. To further enhance our understanding, we could attempt to implement the sorting logic manually.

Manual Sorting Implementation

Let’s implement a simple selection sort to sort the data manually.

def selection_sort(data):
    for i in range(len(data)):
        min_index = i
        for j in range(i + 1, len(data)):
            if data[j] < data[min_index]:
                min_index = j
        data[i], data[min_index] = data[min_index], data[i]  # Swap
    return data

def calculate_median_manual_sort(data):
    # Step 1: Sort the data manually
    sorted_data = selection_sort(data)
    
    # Step 2: Get the length of the sorted list
    n = len(sorted_data)
    
    # Step 3: Calculate the median
    if n % 2 == 1:  # odd length
        median = sorted_data[n // 2]
    else:  # even length
        middle1 = sorted_data[n // 2 - 1]
        middle2 = sorted_data[n // 2]
        median = (middle1 + middle2) / 2
    
    return median

# Example usage with manual sorting
data_manual_sort = [12, 3, 5, 7, 19]
print("Median (Manual Sort):", calculate_median_manual_sort(data_manual_sort))  # Output: Median: 7

In this example, we implemented a simple selection sort algorithm to sort the dataset before calculating the median. The selection_sort function iterates through the list, selecting the minimum element and placing it at the beginning of the unsorted portion of the list.

Example Scenarios

Let’s explore a few more examples to illustrate the process of finding the median.

Example 1: Odd Number of Elements

data_odd = [1, 3, 3, 6, 7, 8, 9]
print("Median:", calculate_median(data_odd))  # Output: Median: 6

In this dataset, there are seven elements. The median is the fourth element when sorted, which is 6.

Example 2: Even Number of Elements

data_even = [1, 2, 3, 4, 5, 6]
print("Median:", calculate_median(data_even))  # Output: Median: 3.5

Here, the dataset contains six elements. The median is calculated by averaging the third and fourth elements (3 and 4), resulting in 3.5.

Example 3: Negative Numbers and Zero

data_neg = [-1, -2, 0, 2, 3]
print("Median:", calculate_median(data_neg))  # Output: Median: 0

This example shows that even with negative numbers and zero, the method accurately computes the median, which is 0 in this case.

Example 4: Large Datasets

For larger datasets, the same methodology applies. However, it is essential to note that performance considerations come into play.

data_large = [10, 25, 15, 30, 20, 5, 50, 45, 40]
print("Median:", calculate_median(data_large))  # Output will be the median of the dataset

Performance Considerations

Time Complexity

The time complexity of this method is primarily determined by the sorting step, which is (O(n \log n)). This means that as the size of the dataset increases, the time taken to compute the median will grow logarithmically. This is important to consider when working with large datasets, as performance can significantly impact the efficiency of your calculations.

Space Complexity

The space complexity is (O(n)) due to the creation of a sorted copy of the dataset. If memory usage is a concern, consider using in-place sorting algorithms or optimizing the sorting method to reduce space requirements.

Conclusion

Finding the median in Python without using inbuilt functions can be a straightforward process when broken down into simple steps. By sorting the data, determining the length, and then calculating the median based on whether the count of numbers is odd or even, you can effectively compute this important statistical measure.

This method not only helps in building a deeper understanding of how the median is derived but also provides you with a practical skill that can be applied in various scenarios. If you have a dataset and need to compute the median manually, use the provided methodology and code.

With practice, this skill will enhance your data analysis capabilities in Python. The ability to calculate the median from scratch can also serve as a foundation for learning more complex statistical concepts and methods. Understanding the underlying principles of statistics will better equip you for tasks involving data science and analysis.

Author
Recent Posts

Alesha Swift

Alesha Swift is the founder of Codingidol.com, where she simplifies programming concepts with tutorials on Java, Python, SQL, JavaScript, and C. With over 12 years of software development experience, Alesha is passionate about helping learners of all levels master coding skills.