python - standard - Encontrar el promedio de una lista
standard deviation python (21)
Si desea obtener más que solo la media (también conocido como promedio) puede consultar las estadísticas de scipy
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)
Tengo que encontrar el promedio de una lista en Python. Este es mi código hasta ahora
l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
print reduce(lambda x, y: x + y, l)
Lo tengo así que suma los valores de la lista, pero no sé cómo dividirlos en ellos.
¿Por qué utilizarías reduce() para esto cuando Python tiene una función sum() perfectamente cromulenta?
print sum(l) / float(len(l))
(El float() es necesario para forzar a Python a hacer una división de punto flotante).
Ambos pueden darle valores cercanos a valores similares en un número entero o al menos 10 valores decimales. Pero si realmente estás considerando valores flotantes largos, ambos pueden ser diferentes. El enfoque puede variar en lo que quiere lograr.
>>> 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
Valores flotantes
>>> print reduce(lambda x, y: x + y, l) / float(len(l))
20.1111111111
>>> print sum(l)/float(len(l))
20.1111111111
@Andrew Clark estaba en lo correcto en su declaración.
Combinando un par de las respuestas anteriores, se me ocurrió lo siguiente que funciona con reducir y no asumo que tenga L disponible dentro de la función de reducción:
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
Como principiante, simplemente codifiqué esto:
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)
En lugar de lanzar para flotar, puedes agregar 0.0 a la suma:
def avg(l):
return sum(l, 0.0) / len(l)
Hay una biblioteca de estadísticas si está usando python> = 3.4
https://docs.python.org/3/library/statistics.html
Puedes usar su método medio como este. Supongamos que tiene una lista de números que quiere encontrar significa: -
list = [11, 13, 12, 15, 17]
import statistics as s
s.mean(list)
También tiene otros métodos como stdev, varianza, modo, media armónica, mediana, etc. que son demasiado útiles.
Intenté usar las opciones anteriores pero no funcionó. Prueba esto:
from statistics import mean
n = [11, 13, 15, 17, 19]
print(n)
print(mean(n))
trabajó en python 3.5
O podrías usar numpy.mean :
l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
import numpy as np
print np.mean(l)
O use el método Series.mean pandas :
pd.Series(sequence).mean()
Manifestación:
>>> import pandas as pd
>>> l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
>>> pd.Series(l).mean()
20.11111111111111
>>>
De la documentación:
Series.mean(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)¶
Y aquí está la documentación para esto:
https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.mean.html
Y toda la documentación:
Para utilizar reduce para tomar un promedio de ejecución, deberá realizar un seguimiento del total, pero también del número total de elementos vistos hasta el momento. Ya que no es un elemento trivial en la lista, también tendrá que pasar, reduce un argumento adicional para plegarse.
>>> 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
Quiero añadir solo otro enfoque
import itertools,operator
list(itertools.accumulate(l,operator.add)).pop(-1) / len(l)
Se ha agregado un módulo de statistics a Python 3.4 . Tiene una función para calcular el promedio llamado mean . Un ejemplo con la lista que proporcionó sería:
from statistics import mean
l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
mean(l)
Si su reducción ya está devolviendo su suma, entonces todo lo que le queda por hacer es dividir.
l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
print reduce(lambda x, y: x + y, l) / len(l)
aunque sum(l)/len(l) sería más simple, ya que no necesitarías un lambda.
Si desea un resultado de flotación más exacto en lugar de un int, simplemente use float(len(l)) lugar de len(l) .
Tuve una pregunta similar para resolver en los problemas de un Udacity. En lugar de una función incorporada, codifiqué:
def list_mean(n):
summing = float(sum(n))
count = float(len(n))
if n == []:
return False
return float(summing/count)
Mucho más largo de lo habitual, pero para un principiante es bastante desafiante.
suponer que
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]]
puede notar que x tiene dimensión 3 * 10 si necesita obtener la mean de cada fila, puede escribir esto
theMean = np.mean(x1,axis=1)
no olvides import numpy as np
sum(l) / float(len(l)) es la respuesta correcta, pero solo para completar puede calcular un promedio con una sola reducción:
>>> reduce(lambda x, y: x + y / float(len(l)), l, 0)
20.111111111111114
Tenga en cuenta que esto puede dar lugar a un ligero error de redondeo:
>>> sum(l) / float(len(l))
20.111111111111111
l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
l = map(float,l)
print ''%.2f'' %(sum(l)/len(l))
l = [15, 18, 2, 36, 12, 78, 5, 6, 9]
sum(l) / float(len(l))
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)
print reduce(lambda x, y: x + y, l)/(len(l)*1.0)
o como publicado anteriormente
sum(l)/(len(l)*1.0)
El 1.0 es para asegurarse de obtener una división de punto flotante