Calcul de la moyenne arithmétique (un type de moyenne) en Python

Existe-t-il une méthode de bibliothèque intégrée ou standard en Python pour calculer la moyenne arithmétique (un type de moyenne) d'une liste de nombres?

Je ne suis au courant de rien dans la bibliothèque standard. Cependant, vous pouvez utiliser quelque chose comme:

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

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

En numpy, il y a numpy.mean().

NumPy a un numpy.meanqui est une moyenne arithmétique. L'utilisation est aussi simple que cela:

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

Utilisation statistics.mean:

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

Il est disponible depuis Python 3.4. Pour les utilisateurs 3.1-3.3, une ancienne version du module est disponible sur PyPI sous le nom stats. Changez simplement statisticsen stats.

Vous n'avez même pas besoin d'engourdi ou de scipy ...

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

Utilisez scipy:

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

Au lieu de lancer pour flotter, vous pouvez suivre

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

ou en utilisant lambda

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

MISES À JOUR: 2019-12-15

Python 3.8 a ajouté la fonction fmean au module de statistiques . Ce qui est plus rapide et renvoie toujours float.

Convertissez les données en flottants et calculez la moyenne arithmétique.

Cela s'exécute plus rapidement que la fonction mean () et renvoie toujours un flottant. Les données peuvent être une séquence ou itérables. Si l'ensemble de données d'entrée est vide, déclenche une StatisticsError.

fmean ([3.5, 4.0, 5.25])

4,25

Nouveau dans la version 3.8.

from statistics import mean
avarage=mean(your_list)

par exemple

from statistics import mean

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

et le résultat est

3.0

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

Exemples:

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

print(avg(l1)) # 9.0
print(avg(l2)) # 0.0

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)

J'ai toujours supposé qu'il avgest omis dans les buildins / stdlib car c'est aussi simple que

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

et toute mise en garde serait déjà traitée dans le code de l'appelant pour une utilisation locale .

Mises en garde notables:

1. résultat non flottant: en python2, 9/4 est 2. pour résoudre, utiliser float(sum(L))/len(L)oufrom __future__ import division

2. division par zéro: la liste peut être vide. résoudre:

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

La bonne réponse à votre question est d'utiliser statistics.mean. Mais pour le plaisir, voici une version de mean qui n'utilise pas la len()fonction, donc elle (comme statistics.mean) peut être utilisée sur des générateurs, qui ne supportent pas 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)))

D'autres ont déjà posté de très bonnes réponses, mais certaines personnes pourraient toujours chercher un moyen classique de trouver Mean (avg), alors ici je poste ceci (code testé en 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