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?
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?
Réponses:
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()
.
[]
est 0
, ce qui peut être fait par float(sum(l))/max(len(l),1)
.
max
?
NumPy a un numpy.mean
qui 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 statistics
en stats
.
timeit("numpy.mean(vec))
, timeit("sum(vec)/len(vec)")
et timeit("statistics.mean(vec)")
- ce dernier est plus lent que les autres par un facteur énorme (> 100 dans certains cas sur mon PC). Cela semble être dû à une implémentation particulièrement précise de l' sum
opérateur dans statistics
, voir PEP et Code . Je ne suis pas sûr de la raison de la grande différence de performances entre statistics._sum
et numpy.sum
, cependant.
statistics.mean
essaye d'être correct . Il calcule correctement la moyenne de [1e50, 1, -1e50] * 1000
.
statistics.mean
acceptera également une expression de générateur de valeurs, que toutes les solutions qui utilisent len()
pour le diviseur s'étoufferont.
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
from __future__ import division
au sommet de votre programme
a = list()
? Le code proposé se traduit par ZeroDivisionError
.
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))
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 avg
est 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:
résultat non flottant: en python2, 9/4 est 2. pour résoudre, utiliser float(sum(L))/len(L)
oufrom __future__ import division
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