## The Question :

*524 people think this question is useful*

I have to find the average of a list in Python. This is my code so far

l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
print reduce(lambda x, y: x + y, l)

I’ve got it so it adds together the values in the list, but I don’t know how to make it divide into them?

*The Question Comments :*

## The Answer 1

*641 people think this answer is useful*

On Python 3.4+ you can use `statistics.mean()`

l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
import statistics
statistics.mean(l) # 20.11111111111111

On older versions of Python you can do

sum(l) / len(l)

On Python 2 you need to convert `len`

to a float to get float division

sum(l) / float(len(l))

There is no need to use `reduce`

. It is much slower and was removed in Python 3.

## The Answer 2

*541 people think this answer is useful*

l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
sum(l) / len(l)

## The Answer 3

*296 people think this answer is useful*

You can use `numpy.mean`

:

l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
import numpy as np
print(np.mean(l))

## The Answer 4

*236 people think this answer is useful*

A statistics module has been added to python 3.4. It has a function to calculate the average called mean. An example with the list you provided would be:

from statistics import mean
l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
mean(l)

## The Answer 5

*47 people think this answer is useful*

Why would you use `reduce()`

for this when Python has a perfectly cromulent `sum()`

function?

print sum(l) / float(len(l))

(The `float()`

is necessary to force Python to do a floating-point division.)

## The Answer 6

*37 people think this answer is useful*

There is a statistics library if you are using python >= 3.4

https://docs.python.org/3/library/statistics.html

You may use it’s mean method like this. Let’s say you have a list of numbers of which you want to find mean:-

list = [11, 13, 12, 15, 17]
import statistics as s
s.mean(list)

It has other methods too like stdev, variance, mode, harmonic mean, median etc which are too useful.

## The Answer 7

*18 people think this answer is useful*

Instead of casting to float, you can add 0.0 to the sum:

def avg(l):
return sum(l, 0.0) / len(l)

## The Answer 8

*10 people think this answer is useful*

`sum(l) / float(len(l))`

is the right answer, but just for completeness you can compute an average with a single reduce:

>>> reduce(lambda x, y: x + y / float(len(l)), l, 0)
20.111111111111114

Note that this can result in a slight rounding error:

>>> sum(l) / float(len(l))
20.111111111111111

## The Answer 9

*8 people think this answer is useful*

I tried using the options above but didn’t work.
Try this:

from statistics import mean
n = [11, 13, 15, 17, 19]
print(n)
print(mean(n))

worked on python 3.5

## The Answer 10

*6 people think this answer is useful*

Or use `pandas`

‘s `Series.mean`

method:

pd.Series(sequence).mean()

**Demo:**

>>> import pandas as pd
>>> l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
>>> pd.Series(l).mean()
20.11111111111111
>>>

From the docs:

`Series.mean(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)`

¶

And here is the docs for this:

https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.mean.html

And the whole documentation:

https://pandas.pydata.org/pandas-docs/stable/10min.html

## The Answer 11

*6 people think this answer is useful*

In terms of efficiency and speed, these are the results that I got testing the other answers:

# test mean caculation
import timeit
import statistics
import numpy as np
from functools import reduce
import pandas as pd
LIST_RANGE = 10000000000
NUMBERS_OF_TIMES_TO_TEST = 10000
l = list(range(10))
def mean1():
return statistics.mean(l)
def mean2():
return sum(l) / len(l)
def mean3():
return np.mean(l)
def mean4():
return np.array(l).mean()
def mean5():
return reduce(lambda x, y: x + y / float(len(l)), l, 0)
def mean6():
return pd.Series(l).mean()
for func in [mean1, mean2, mean3, mean4, mean5, mean6]:
print(f"{func.__name__} took: ", timeit.timeit(stmt=func, number=NUMBERS_OF_TIMES_TO_TEST))

and the results:

mean1 took: 0.17030245899968577
mean2 took: 0.002183011999932205
mean3 took: 0.09744236000005913
mean4 took: 0.07070840100004716
mean5 took: 0.022754742999950395
mean6 took: 1.6689282460001778

so clearly the winner is:
`sum(l) / len(l)`

## The Answer 12

*4 people think this answer is useful*

I had a similar question to solve in a Udacity´s problems. Instead of a built-in function i coded:

def list_mean(n):
summing = float(sum(n))
count = float(len(n))
if n == []:
return False
return float(summing/count)

Much more longer than usual but for a beginner its quite challenging.

## The Answer 13

*4 people think this answer is useful*

as a beginner, I just coded this:

L = [15, 18, 2, 36, 12, 78, 5, 6, 9]
total = 0
def average(numbers):
total = sum(numbers)
total = float(total)
return total / len(numbers)
print average(L)

## The Answer 14

*4 people think this answer is useful*

### If you wanted to get more than just the mean (aka average) you might check out scipy stats

from scipy import stats
l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
print(stats.describe(l))
# DescribeResult(nobs=9, minmax=(2, 78), mean=20.11111111111111,
# variance=572.3611111111111, skewness=1.7791785448425341,
# kurtosis=1.9422716419666397)

## The Answer 15

*3 people think this answer is useful*

In order to use `reduce`

for taking a running average, you’ll need to track the total but also the total number of elements seen so far. since that’s not a trivial element in the list, you’ll also have to pass `reduce`

an extra argument to fold into.

>>> l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
>>> running_average = reduce(lambda aggr, elem: (aggr[0] + elem, aggr[1]+1), l, (0.0,0))
>>> running_average[0]
(181.0, 9)
>>> running_average[0]/running_average[1]
20.111111111111111

## The Answer 16

*3 people think this answer is useful*

Both can give you close to similar values on an integer or at least 10 decimal values. But if you are really considering long floating values both can be different. Approach can vary on what you want to achieve.

>>> l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
>>> print reduce(lambda x, y: x + y, l) / len(l)
20
>>> sum(l)/len(l)
20

Floating values

>>> print reduce(lambda x, y: x + y, l) / float(len(l))
20.1111111111
>>> print sum(l)/float(len(l))
20.1111111111

@Andrew Clark was correct on his statement.

## The Answer 17

*3 people think this answer is useful*

suppose that

x = [
[-5.01,-5.43,1.08,0.86,-2.67,4.94,-2.51,-2.25,5.56,1.03],
[-8.12,-3.48,-5.52,-3.78,0.63,3.29,2.09,-2.13,2.86,-3.33],
[-3.68,-3.54,1.66,-4.11,7.39,2.08,-2.59,-6.94,-2.26,4.33]
]

you can notice that `x`

has dimension 3*10 if you need to get the `mean`

to each row you can type this

theMean = np.mean(x1,axis=1)

don’t forget to `import numpy as np`

## The Answer 18

*1 people think this answer is useful*

l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
l = map(float,l)
print '%.2f' %(sum(l)/len(l))

## The Answer 19

*1 people think this answer is useful*

Find the average in list
By using the following **PYTHON** code:

l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
print(sum(l)//len(l))

try this it easy.

## The Answer 20

*0 people think this answer is useful*

print reduce(lambda x, y: x + y, l)/(len(l)*1.0)

or like posted previously

sum(l)/(len(l)*1.0)

The 1.0 is to make sure you get a floating point division

## The Answer 21

*0 people think this answer is useful*

Combining a couple of the above answers, I’ve come up with the following which works with reduce and doesn’t assume you have `L`

available inside the reducing function:

from operator import truediv
L = [15, 18, 2, 36, 12, 78, 5, 6, 9]
def sum_and_count(x, y):
try:
return (x[0] + y, x[1] + 1)
except TypeError:
return (x + y, 2)
truediv(*reduce(sum_and_count, L))
# prints
20.11111111111111

## The Answer 22

*0 people think this answer is useful*

I want to add just another approach

import itertools,operator
list(itertools.accumulate(l,operator.add)).pop(-1) / len(l)

## The Answer 23

*-5 people think this answer is useful*

numbers = [0,1,2,3]
numbers[0] = input("Please enter a number")
numbers[1] = input("Please enter a second number")
numbers[2] = input("Please enter a third number")
numbers[3] = input("Please enter a fourth number")
print (numbers)
print ("Finding the Avarage")
avarage = int(numbers[0]) + int(numbers[1]) + int(numbers[2]) + int(numbers [3]) / 4
print (avarage)