Encontrar el promedio de una lista

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 sum los valores en la lista, pero no sé cómo dividirlos en ellos.

Si su reducción ya está devolviendo su sum, entonces todo lo que tiene que 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) .

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

O podrías usar numpy.mean :

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

Se ha agregado un módulo de estadísticas a Python 3.4 . Tiene una función para calcular la media llamada media . 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) 

¿Por qué usarías reduce() para esto cuando Python tiene una función de sum() perfecta?

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

(El float() es necesario para forzar a Python a hacer una división de punto flotante).

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. Digamos que usted tiene una lista de números de los que quiere encontrar el medio:

 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.

En lugar de lanzar para flotar, puedes agregar 0.0 a la sum:

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

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 

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

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.

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) 

O utilice 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 los documentos:

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:

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

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 extra 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 

Ambos le pueden dar valores cercanos a valores similares en un 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 statement.

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 observar 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

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) 
 l = [15, 18, 2, 36, 12, 78, 5, 6, 9] l = map(float,l) print '%.2f' %(sum(l)/len(l)) 
 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

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 

Quiero añadir solo otro enfoque

 import itertools,operator list(itertools.accumulate(l,operator.add)).pop(-1) / 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)