Moyenne courante en Python

Est-il un pythonic façon de créer une liste qui contient un moyen d'une certaine fonction?

Après la lecture d'un amusant petit morceau d'environ Les martiens, des boîtes noires, et la Cauchy de distributionj'ai pensé qu'il serait amusant de calculer une moyenne de la distribution de Cauchy moi-même:

import math 
import random

def cauchy(location, scale):
    p = 0.0
    while p == 0.0:
        p = random.random()
    return location + scale*math.tan(math.pi*(p - 0.5))

# is this next block of code a good way to populate running_avg?
sum = 0
count = 0
max = 10
running_avg = []
while count < max:
    num = cauchy(3,1)
    sum += num
    count += 1
    running_avg.append(sum/count)

print running_avg     # or do something else with it, besides printing

Je pense que cette approche fonctionne, mais je suis curieux de savoir si il y a peut être un plus élégant à l'approche de la construction que running_avg liste que d'utiliser des boucles et des compteurs (par exemple interprétations de la liste).

Il y a des questions connexes, mais ils traitent aussi des problèmes plus complexes (petite taille de la fenêtre, l'exponentielle de pondération) ou ne sont pas spécifiques à Python:

source d'informationauteur Nate Kohl

Vous pourriez écrire un générateur:

def running_average():
  sum = 0
  count = 0
  while True:
    sum += cauchy(3,1)
    count += 1
    yield sum/count

Ou un générateur de Cauchy de nombres et une fonction d'utilité pour une somme en cours d'exécution generator, vous pouvez avoir une maison propre générateur d'expression:

# Cauchy numbers generator
def cauchy_numbers():
  while True:
    yield cauchy(3,1)

# running sum utility function
def running_sum(iterable):
  sum = 0
  for x in iterable:
    sum += x
    yield sum

# Running averages generator expression (** the neat part **)
running_avgs = (sum/(i+1) for (i,sum) in enumerate(running_sum(cauchy_numbers())))

# goes on forever
for avg in running_avgs:
  print avg

# alternatively, take just the first 10
import itertools
for avg in itertools.islice(running_avgs, 10):
  print avg

6

Vous pouvez utiliser coroutines. Ils sont semblables à des générateurs, mais vous permet d'envoyer des valeurs. Coroutines a été ajouté dans Python 2.5, donc cela ne fonctionnera pas dans les versions d'avant.
```
def running_average():
    sum = 0.0
    count = 0
    value = yield(float('nan'))
    while True:
        sum += value
        count += 1
        value = yield(sum/count)

ravg = running_average()
next(ravg)   # advance the corutine to the first yield

for i in xrange(10):
    avg = ravg.send(cauchy(3,1))
    print 'Running average: %.6f' % (avg,)
```
Comme une compréhension de liste:
```
ravg = running_average()
next(ravg)
ravg_list = [ravg.send(cauchy(3,1)) for i in xrange(10)]
```
Modifications:
- À l'aide de la next() fonction de la place de la it.next() méthode. Il en est ainsi, il sera également travailler avec Python 3. Le next() fonction a également été porté à la version 2.6 de Python+.
  
  Dans Python 2.5, vous pouvez soit remplacer les appels à it.next(), ou de définir un next fonction de vous-même.
  
  (Merci Adam Parkin)

J'ai deux solutions possibles ici pour vous. Les deux sont tout simplement génériques moyen de fonctions qui fonctionnent sur une liste de nombres. (peut-être faite pour fonctionner avec n'importe quel itérable)

Générateur de fonction:

nums = [cauchy(3,1) for x in xrange(10)]

def running_avg(numbers):
    for count in xrange(1, len(nums)+1):
        yield sum(numbers[:count])/count

print list(running_avg(nums))

Liste de Compréhension de base (vraiment le même code que précédemment):

nums = [cauchy(3,1) for x in xrange(10)]

print [sum(nums[:count])/count for count in xrange(1, len(nums)+1)]

Générateur-compatabile Générateur de fonction:

Modifier: Ce que je viens de tester pour voir si je pouvais faire ma solution compatible avec les générateurs facilement et ce qu'il serait. C'est ce que je suis venu avec.

def running_avg(numbers):
    sum = 0
    for count, number in enumerate(numbers):
        sum += number
        yield sum/(count+1)

Voir les statistiques ci-dessous, en vaut la peine.

Caractéristiques de Performance:

Modifier: j'ai aussi décidé de tester Orip est intéressant d'utiliser de multiples générateurs de voir l'impact sur les performances.

À l'aide de timeit et la suivante (1 000 000 d'itérations 3 fois):

print "Generator based:", ', '.join(str(x) for x in Timer('list(running_avg(nums))', 'from __main__ import nums, running_avg').repeat())
print "LC based:", ', '.join(str(x) for x in Timer('[sum(nums[:count])/count for count in xrange(1, len(nums)+1)]', 'from __main__ import nums').repeat())
print "Orip's:", ', '.join(str(x) for x in Timer('list(itertools.islice(running_avgs, 10))', 'from __main__ import itertools, running_avgs').repeat())

print "Generator-compatabile Generator based:", ', '.join(str(x) for x in Timer('list(running_avg(nums))', 'from __main__ import nums, running_avg').repeat())

J'obtiens les résultats suivants:

Generator based: 17.653908968, 17.8027219772, 18.0342400074
LC based: 14.3925321102, 14.4613749981, 14.4277560711
Orip's: 30.8035550117, 30.3142540455, 30.5146529675

Generator-compatabile Generator based: 3.55352187157, 3.54164409637, 3.59098005295

Voir les commentaires de code:

Orip's genEx based: 4.31488609314, 4.29926609993, 4.30518198013

Résultats sont en quelques secondes, et de montrer l' LC nouveau générateur compatible générateur de méthode pour être toujours plus vite, vos résultats peuvent varier. J'attends de la différence énorme entre mon générateur original et le nouveau est le fait que la somme n'est pas calculé à la volée.

Vous devez vous connecter pour publier un commentaire.