Last Updated : 28 Jan, 2024

Comments

Improve

In this article, we will learn how to calculate ** Mean, Median, and Mode with Python** without using external libraries.

**1. Mean:**

**1. Mean:**

The mean is the average of all numbers and is sometimes called the arithmetic mean. This code calculates Mean or Average of a list containing numbers:

We define a list of numbers and calculate the length of the list. We then use sum() function to get sum of all the elements in a list. We finally divide the total sum by the number of elements in the list and we print the result to get the mean/average of a list.

## Python3

`# Python program to print `

`# mean of elements `

`# list of elements to calculate mean `

`n_num `

`=`

`[`

`1`

`, `

`2`

`, `

`3`

`, `

`4`

`, `

`5`

`] `

`n `

`=`

`len`

`(n_num) `

`get_sum `

`=`

`sum`

`(n_num) `

`mean `

`=`

`get_sum `

`/`

`n `

`print`

`(`

`"Mean / Average is: "`

`+`

`str`

`(mean)) `

**Output**

Mean / Average is: 3.0

** Time Complexity:** O(N)

**O(1)**

**Auxiliary Space:****2. Median :**

**2. Median :**

The median is the middle number in a group of numbers. This code calculates the Median of a list containing numbers

We define a list of numbers and calculate the length of the list. To find a median, we first sort the list in Ascending order using sort() function. Now we check if the number is even or odd by checking their remainders. If the number is even, we find 2 middle elements in a list and get their average to print it out. But if the number is odd, we find the middle element in a list and print it out.

## Python3

`# Python program to print `

`# median of elements `

`# list of elements to calculate median `

`n_num `

`=`

`[`

`1`

`, `

`2`

`, `

`3`

`, `

`4`

`, `

`5`

`] `

`n `

`=`

`len`

`(n_num) `

`n_num.sort() `

`if`

`n `

`%`

`2`

`=`

`=`

`0`

`: `

`median1 `

`=`

`n_num[n`

`/`

`/`

`2`

`] `

`median2 `

`=`

`n_num[n`

`/`

`/`

`2`

`-`

`1`

`] `

`median `

`=`

`(median1 `

`+`

`median2)`

`/`

`2`

`else`

`: `

`median `

`=`

`n_num[n`

`/`

`/`

`2`

`] `

`print`

`(`

`"Median is: "`

`+`

`str`

`(median)) `

**Output**

Median is: 3

** Time Complexity:** O(N log N)

**O(1)**

**Auxiliary Space:****3. Mode :**

**3. Mode :**

The mode is the number that occurs most often within a set of numbers. This code calculates Mode of a list containing numbers:

We will import Counter from collections library which is a built-in module in Python 2 and 3. This module will help us count duplicate elements in a list. We define a list of numbers and calculate the length of the list. We then call Counter (a dict subclass) which helps to count hashable objects, and we then convert it to dict object. We then initialize a list with a For Loop to compare all the dict values (Number of elements) to the max of all dict values (count of most occurring element) and it returns all the elements equal to max count. If the elements returned are equal to the number of total elements in a list then we print out ‘No mode’, else we print out the modes returned.

## Python3

`# Python program to print `

`# mode of elements `

`from`

`collections `

`import`

`Counter `

`# list of elements to calculate mode `

`n_num `

`=`

`[`

`1`

`, `

`2`

`, `

`3`

`, `

`4`

`, `

`5`

`, `

`5`

`] `

`n `

`=`

`len`

`(n_num) `

`data `

`=`

`Counter(n_num) `

`get_mode `

`=`

`dict`

`(data) `

`mode `

`=`

`[k `

`for`

`k, v `

`in`

`get_mode.items() `

`if`

`v `

`=`

`=`

`max`

`(`

`list`

`(data.values()))] `

`if`

`len`

`(mode) `

`=`

`=`

`n: `

`get_mode `

`=`

`"No mode found"`

`else`

`: `

`get_mode `

`=`

`"Mode is / are: "`

`+`

`', '`

`.join(`

`map`

`(`

`str`

`, mode)) `

`print`

`(get_mode) `

**Output**

Mode is / are: 5

** Time Complexity: O(n). **The time complexity of this algorithm is O(n). This is because the algorithm requires looping through the entire list of elements to calculate the mode.

**The space complexity of the algorithm is O(n) as it requires the use of a dictionary to store the count for each element in the list.**

**Auxiliary Space: O(n),****Another simple approach to find mode with simple coding**

## Python3

`# The list for which you need to find `

`# the Mode `

`y`

`=`

`[`

`11`

`, `

`8`

`, `

`8`

`, `

`3`

`, `

`4`

`, `

`4`

`, `

`5`

`, `

`6`

`, `

`6`

`, `

`6`

`, `

`7`

`, `

`8`

`] `

`# First you sort it `

`# You will get numbers arranged from 3 to `

`# 11 in asc order `

`y.sort() `

`# Now open an empty list. `

`# What you are going to do is to count `

`# the occurrence of each number and append `

`# (or to add your findings to) L1 `

`L1`

`=`

`[] `

`# You can iterate through the sorted list `

`# of numbers in y, `

`# counting the occurrence of each number, `

`# using the following code `

`i `

`=`

`0`

`while`

`i < `

`len`

`(y) : `

`L1.append(y.count(y[i])) `

`i `

`+`

`=`

`1`

`# your L1 will be [1, 2, 2, 1, 3, 3, 3, 1, 3, 3, 3, 1], `

`# the occurrences for each number in sorted y `

`# now you can create a custom dictionary d1 for k : V `

`# where k = your values in sorted y `

`# and v = the occurrences of each value in y `

`# the Code is as follows `

`d1 `

`=`

`dict`

`(`

`zip`

`(y, L1)) `

`# your d1 will be {3: 1, 4: 2, 5: 1, 6: 3, 7: 1, 8: 3, 11: 1} `

`# now what you need to do is to filter `

`# the k values with the highest v values. `

`# do this with the following code `

`d2`

`=`

`{k `

`for`

`(k,v) `

`in`

`d1.items() `

`if`

`v `

`=`

`=`

`max`

`(L1) } `

`print`

`(`

`"Mode(s) is/are :"`

`+`

`str`

`(d2)) `

**Output**

Mode(s) is/are :{8, 6}

### Another simple approach to find mode with simple coding (HR):

## Python

`number_list `

`=`

`[`

`1`

`, `

`2`

`, `

`2`

`, `

`3`

`, `

`4`

`, `

`4`

`, `

`5`

`, `

`5`

`, `

`6`

`, `

`7`

`, `

`8`

`, `

`8`

`, `

`8`

`]`

`uniq_values `

`=`

`[]`

`mode_values `

`=`

`[]`

`for`

`i `

`in`

`number_list:`

`if`

`i `

`not`

`in`

`uniq_values:`

`uniq_values.append(i)`

`else`

`:`

`mode_values.append(i)`

`print`

`(`

`set`

`(mode_values))`

**Output**

set([8, 2, 4, 5])

**Conclusion:**

**Conclusion:**

We have successfully calculated mean, median, and mode of a dataset but you might be thinking ‘Will I be using these algorithms every time I want to get mean, median and mode of a dataset?’ The answer is you can but you certainly won’t. This was just to show you how the algorithm works behind the scenes when finding out any of these. For any projects, this can be achieved by simply importing an inbuilt library ‘statistics’ in Python 3, and using the inbuilt functions mean(), median() and mode(). Also, there are other external libraries that can help you achieve the same results in just 1 line of code as the code is pre-written in those libraries.

${secondsToHms(duration)}

${getTagsString(tags)}

'; } else{ let view_all_url = `${GFG_SITE_URL}videos/`; videos_content+=`

View All

`; } // videos_content+= '

'; } } return videos_content; } //function to show main video content with related videos content async function showMainVideoContent(main_video, course_link){ //Load main video $(".video-main").html(`

`); require(["ima"], function() { var player = videojs('article-video', { controls: true, // autoplay: true, // muted: true, controlBar: { pictureInPictureToggle: false }, playbackRates: [0.5, 0.75, 1, 1.25, 1.5, 2], poster: main_video['meta']['largeThumbnail'], sources: [{src: main_video['source'], type: 'application/x-mpegURL'}], tracks: [{src: main_video['subtitle'], kind:'captions', srclang: 'en', label: 'English', default: true}] },function() { player.qualityLevels(); try { player.hlsQualitySelector(); } catch (error) { console.log("HLS not working - ") } document.getElementById('article-video-tab-content').style.display = 'block'; } ); const video = document.querySelector("video"); const events =[ { 'name':'play', 'callback':()=>{videoPlayCallback(main_video['slug'])} }, ]; events.forEach(event=>{ video.addEventListener(event.name,event.callback); }); // error handling for no compatible source player.on('error', function() { var error = player.error(); console.log("Video Error: ", error); if (error && error.code === 4) { console.log("No compatible source was found for this media."); hideVideoPlayer(); } }); }, function(err) { var player = videojs('article-video'); player.createModal('Something went wrong. Please refresh the page to load the video.'); hideVideoPlayer(); // hiding video in case of timeout (requirejs) console.log(err); }); // function to hide the video player function hideVideoPlayer() { var videoPlayer = document.getElementById('article-video'); if (videoPlayer) { videoPlayer.parentNode.removeChild(videoPlayer); } } /*let video_date = main_video['time']; video_date = video_date.split("/"); video_date = formatDate(video_date[2], video_date[1], video_date[0]); let share_section_content = `

${video_date}

`;*/ let hasLikeBtn = false; // console.log(share_section_content); var data = {}; if(false){ try { if((loginData && loginData.isLoggedIn == true)){ const resp = await fetch(`${API_SCRIPT_URL}logged-in-video-details/${main_video['slug']}/`,{ credentials: 'include' }) if(resp.status == 200 || resp.status == 201){ data = await resp.json(); share_section_content+= `

`; hasLikeBtn = true; } else { share_section_content+= `

`; } } else { share_section_content+= `

`; } //Load share section // $(".video-share-section").html(share_section_content); // let exitCond = 0; // const delay = (delayInms) => { // return new Promise(resolve => setTimeout(resolve, delayInms)); // } // while(!loginData){ // let delayres = await delay(1000); // exitCond+=1; // console.log(exitCond); // if(exitCond>5){ // break; // } // } // console.log(loginData); /*if(hasLikeBtn && loginData && loginData.isLoggedIn == true){ setLiked(data.liked) setSaved(data.watchlist) }*/ } catch (error) { console.log(error); } } //Load video content like title, description if(false){ $(".video-content-section").html(`

${main_video['title']}

${hideMainVideoDescription(main_video['description'], main_video['id'])}

${getTagsString(main_video['category'])} ${(course_link.length)? `

View Course

`:''} `); let related_vidoes = main_video['recommendations']; if(!!videos && videos.length>0){ //Load related videos $(".related-videos-content").html(getvideosContent()); } } //show video content // element = document.getElementById('article-video-tab-content'); // element.style.display = 'block'; $('.spinner-loading-overlay:eq(0)').remove(); $('.spinner-loading-overlay:eq(0)').remove(); } await showMainVideoContent(video_data, course_link); // fitRelatedVideosDescription(); } catch (error) { console.log(error); } } getVideoData(); /* $(window).resize(function(){ onWidthChangeEventsListener(); }); $('#video_nav_tab').click('on', function(){ fitRelatedVideosDescription(); });*/ });

Next Article

How To Make Histogram with Median Line using Altair in Python?