282

Is there a built-in or standard library method in Python to calculate the arithmetic mean (one type of average) of a list of numbers?

Improve this question
3
  • Average is ambiguous - mode and median are also commonly-used averages Commented Jun 11, 2018 at 8:13
  • 1
    Mode and median are other measures of central tendency. They are not averages. The mode is the most common value seen in a data set and is not necessarily unique. The median is the value that represents the center of the data points. As the question implies, there are a few different types of averages, but all are different from median and mode calculations. purplemath.com/modules/meanmode.htm Commented Aug 1, 2018 at 4:48
  • @Jarom That link disagrees with you: 'Mean, median, and mode are three kinds of "averages"' Commented Feb 7, 2019 at 3:39

13 Answers 13

Reset to default
288

I am not aware of anything in the standard library. However, you could use something like:

def mean(numbers):
    return float(sum(numbers)) / max(len(numbers), 1)

>>> mean([1,2,3,4])
2.5
>>> mean([])
0.0

In numpy, there's numpy.mean().

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

A common thing is to consider that the average of [] is 0, which can be done by float(sum(l))/max(len(l),1).
PEP 8 says that l is a bad variable name because it looks so much like 1. Also, I would use if l rather than if len(l) > 0. See here
Why have you called max?
See the question above: To avoid division by zero ( for [] )
Empty lists have no mean. Please don't pretend they do.
|
196

NumPy has a numpy.mean which is an arithmetic mean. Usage is as simple as this:

>>> import numpy
>>> a = [1, 2, 4]
>>> numpy.mean(a)
2.3333333333333335
Improve this answer

9 Comments

numpy is a nightmare to install in a virtualenv. You should really consider not using this lib
@vcarel: "numpy is a nightmare to install in a virtualenv". I'm not sure why you say this. It used to be the case, but for the last year or more it's been very easy.
I must second this comment. I'm currently using numpy in a virtualenv in OSX, and there is absolutely no problem (currently using CPython 3.5).
With continuous integration systems like Travis CI, installing numpy takes several extra minutes. If quick and light build is valuable to you, and you need only the mean, consider.
@AkseliPalén virtual environments on Travis CI can use a numpy installed via apt-get using the system site packages. This may be quick enough to use even if one only needs a mean.
|
192

Use statistics.mean:

import statistics
print(statistics.mean([1,2,4])) # 2.3333333333333335

It's available since Python 3.4. For 3.1-3.3 users, an old version of the module is available on PyPI under the name stats. Just change statistics to stats.

Improve this answer

4 Comments

Note that this is extremely slow when compared to the other solutions. Compare timeit("numpy.mean(vec)), timeit("sum(vec)/len(vec)") and timeit("statistics.mean(vec)") - the latter is slower than the others by a huge factor (>100 in some cases on my PC). This appears to be due to a particularly precise implementation of the sum operator in statistics, see PEP and Code. Not sure about the reason for the large performance difference between statistics._sum and numpy.sum, though.
@jhin this is because the statistics.mean tries to be correct. It calculates correctly the mean of [1e50, 1, -1e50] * 1000.
statistics.mean will also accept a generator expression of values, which all solutions that use len() for the divisor will choke on.
Since python 3.8, there is a faster statistics.fmean function
55

You don't even need numpy or scipy...

>>> a = [1, 2, 3, 4, 5, 6]
>>> print(sum(a) / len(a))
3
Improve this answer

6 Comments

then mean([2,3]) would give 2. be careful with floats. Better use float(sum(l))/len(l). Better still, be careful to check if the list is empty.
@jesusiniesta except in python3, where division does what it is intended to do : divide
And in Python 2.2+ if you from __future__ import division at the top of your program
What about big numbers and overflow?
What about a = list()? The proposed code results in ZeroDivisionError.
|
8

Use scipy:

import scipy;
a=[1,2,4];
print(scipy.mean(a));
Improve this answer

1 Comment

7

Instead of casting to float you can do following

def mean(nums):
    return sum(nums, 0.0) / len(nums)

or using lambda

mean = lambda nums: sum(nums, 0.0) / len(nums)

UPDATES: 2019-12-15

Python 3.8 added function fmean to statistics module. Which is faster and always returns float.

Convert data to floats and compute the arithmetic mean.

This runs faster than the mean() function and it always returns a float. The data may be a sequence or iterable. If the input dataset is empty, raises a StatisticsError.

fmean([3.5, 4.0, 5.25])

4.25

New in version 3.8.

Improve this answer

Comments

3 
from statistics import mean
avarage=mean(your_list)

for example

from statistics import mean

my_list=[5,2,3,2]
avarage=mean(my_list)
print(avarage)

and result is

3.0
Improve this answer

Comments

2

If you're using python >= 3.8, you can use the fmean function introduced in the statistics module which is part of the standard library:

>>> from statistics import fmean
>>> fmean([0, 1, 2, 3])
1.5

It's faster than the statistics.mean function, but it converts its data points to float beforehand, so it can be less accurate in some specific cases.

You can see its implementation here

Improve this answer

Comments

1 
def avg(l):
    """uses floating-point division."""
    return sum(l) / float(len(l))

Examples:

l1 = [3,5,14,2,5,36,4,3]
l2 = [0,0,0]

print(avg(l1)) # 9.0
print(avg(l2)) # 0.0
Improve this answer

Comments

1 
def list_mean(nums):
    sumof = 0
    num_of = len(nums)
    mean = 0
    for i in nums:
        sumof += i
    mean = sumof / num_of
    return float(mean)
Improve this answer

Comments

1

The proper answer to your question is to use statistics.mean. But for fun, here is a version of mean that does not use the len() function, so it (like statistics.mean) can be used on generators, which do not support len():

from functools import reduce
from operator import truediv
def ave(seq):
    return truediv(*reduce(lambda a, b: (a[0] + b[1], b[0]), 
                           enumerate(seq, start=1), 
                           (0, 0)))
Improve this answer

Comments

0

I always supposed avg is omitted from the builtins/stdlib because it is as simple as

sum(L)/len(L) # L is some list

and any caveats would be addressed in caller code for local usage already.

Notable caveats:

  1. non-float result: in python2, 9/4 is 2. to resolve, use float(sum(L))/len(L) or from __future__ import division

  2. division by zero: the list may be empty. to resolve:

    if not L:
    raise WhateverYouWantError("foo")
avg = float(sum(L))/len(L)
Improve this answer

Comments

-1

Others already posted very good answers, but some people might still be looking for a classic way to find Mean(avg), so here I post this (code tested in Python 3.6):

def meanmanual(listt):

mean = 0
lsum = 0
lenoflist = len(listt)

for i in listt:
    lsum += i

mean = lsum / lenoflist
return float(mean)

a = [1, 2, 3, 4, 5, 6]
meanmanual(a)

Answer: 3.5
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.