Python Générateur d'Expression pour l'Accumulation de Dictionnaire des Valeurs

Un générateur d'expression est en train de jeter à côté d'un grand nombre de tuple paires par exemple. sous forme de liste:

pairs = [(3, 47), (6, 47), (9, 47), (6, 27), (11, 27), (23, 27), (41, 27), (4, 67), (9, 67), (11, 67), (33, 67)]

Pour chaque paire en paire avec key = paire[0] et la valeur = paire[1], je veux nourrir ce flux de paires dans un dictionnaire de cumulativement ajouter les valeurs pour les touches correspondantes. La solution la plus évidente est:

dict_k_v = {}
for pair in pairs:
    try:
        dict_k_v[pair[0]] += pair[1]
    except:
        dict_k_v[pair[0]] = pair[1]

>>> dict_k_v
{33: 67, 3: 47, 4: 67, 6: 74, 9: 114, 11: 94, 41: 27, 23: 27}

Toutefois, cela pourrait être réalisé avec un générateur d'expression ou d'une même construction que ne pas utiliser une boucle for?

MODIFIER

Pour clarifier, le générateur d'expression est en train de jeter à côté d'un grand nombre de tuple paires:

(3, 47), (6, 47), (9, 47), (6, 27), (11, 27), (23, 27), (41, 27), (4, 67), (9, 67), (11, 67), (33, 67) ...

et je veux accumuler chaque paire clé-valeur dans un dictionnaire (voir Paul McGuire réponse) que chaque paire est généré. Les paires = liste[] déclaration est inutile et désolé à ce sujet. Pour chaque paire (x,y), x est un entier et y peuvent être un nombre entier ou décimal/float.

Mon générateur d'expression est de la forme:

((x,y) for y in something() for x in somethingelse())

et pour accumuler chaque (x,y) de la paire dans un defaultdict. Hth.

Qu'est-ce que cette aversion pour les boucles dernièrement? Une boucle enroulée autour d'une accumulation dans un defaultdict est la solution la plus propre.
J'ai juste eu une longue discussion à propos de toutes les options pour pousser dans un dict et il s'avère que le moyen le plus efficace pour le code c'est avec des si la clé dans le dict: / autre: (non pas que vous vouliez utiliser une boucle for 🙂
Le premier aversion pour les boucles le risque de dégradation des performances lorsque les ensembles de données sont très importantes et/ou de l'exécution de l'opération continuellement. Une option est Cython, mais je voudrais voir si il y a un Python solution qui utilise les fonctions intégrées.
Dans sa réponse, Paul McGuire ajoute explicitement à la question de ce que j'avais supposé évident (oups!) c'est à dire. "... accepter chaque paire clé-valeur qui lui sont envoyées, et de les accumuler dans un defaultdict passés dans celui-ci". J'ai ajouté ceci à la question d'origine.

InformationsquelleAutor Henry Thornton | 2012-02-14

6

De discussion, ici est un simple générateur de fonction pour nous donner quelques données:
```
from random import randint
def generator1():
    for i in range(10000):
        yield (randint(1,10), randint(1,100))
```
Et voici la solution de base qui utilise un Python pour la boucle de consommer le générateur et représenter les nombres pour chaque paire clé-valeur
```
from collections import defaultdict

tally = defaultdict(int)
for k,v in generator1():
    tally[k] += v

for k in sorted(tally):
    print k, tally[k]
```
Impression sera quelque chose comme:
```
1 49030
2 51963
3 51396
4 49292
5 51908
6 49481
7 49645
8 49149
9 48523
10 50722
```
Mais nous pouvons créer une coroutine qui va accepter de chaque paire clé-valeur qui lui sont envoyées, et de les accumuler dans un defaultdict passés dans celui-ci:
```
# define coroutine to update defaultdict for every
# key,value pair sent to it
def tallyAccumulator(t):
    try:
        while True:
            k,v = (yield)
            t[k] += v
    except GeneratorExit:
        pass
```
Nous allons initialiser la coroutine avec un pointage defaultdict, et qu'elle soit prête à accepter les valeurs par l'envoi d'une valeur None à elle:
```
# init coroutine
tally = defaultdict(int)
c = tallyAccumulator(tally)
c.send(None)
```
Nous pourrions utiliser une boucle for ou une compréhension de liste pour envoyer toutes les générateur de valeurs de la coroutine:
```
for val in generator1():
    c.send(val)
```
ou
```
[c.send(val) for val in generator1()]
```
Mais au lieu de cela, nous allons utiliser une taille zéro deque pour traiter tout le générateur d'expression de valeurs sans créer temporaires inutiles de la liste d'Aucun de:
```
# create generator expression consumer
from collections import deque
do_all = deque(maxlen=0).extend

# loop thru generator at C speed, instead of Python for-loop speed
do_all(c.send(val) for val in generator1())
```
Maintenant nous regardons les valeurs de nouveau:
```
for k in sorted(tally):
    print k, tally[k]
```
Et on a une liste semblable à la première:
```
1 52236
2 49139
3 51848
4 51194
5 51275
6 50012
7 51875
8 46013
9 50955
10 52192
```
Lire plus à propos de coroutines à David Beazley page: http://www.dabeaz.com/coroutines/
- Cette réponse est bien écrit, mais peu motivés: à l'aide de coroutine-style générateurs de ne pas ajouter de la valeur à la solution en utilisant un simple générateur de consommation.
- merci bien, au moins pour ne pas downvoting moi. Je suis d'accord que c'est l'extrême overkill pour ce problème particulier, mais il semblait un bon exercice pour montrer une coroutine démonstration.
- Obtenu mon générateur de travailler avec: do_all(c.envoyer((x,y)) pour y dans quelque chose() pour x dans somethingelse()) avec la defaultdict tally contenant le cumul des valeurs pour les touches correspondantes.
- Votre boucle imbriquée sera de retour toutes les paires de valeurs x et y. Si c'est vraiment ce que vous voulez, vous pouvez réécrire comme for x,y in itertools.product(something(), somethingelse()) Si vous voulez juste pour lier les valeurs retournées par les deux fonctions, utilisez zip au lieu de produit. Notez également que somethingelse() est appelée à y fois - vous ne savez pas si le produit est assez intelligent pour éviter cela ou pas.
- Merci, Paul. Assez pour y aller avec. Co-incidemment, était à la recherche d'Beazley co-routines de travail tout récemment, et ils ont maintenant un parfait exemple. Permettra d'effectuer des synchronisations entre Ignacio et votre solution plus tard.
- C'est un très bel article à propos de coroutines, un concept que je n'ai différé à regarder, malheureusement. Cependant, à partir de votre description, je suppose que ce générateur/consommateurs approche devrait également avoir un avantage de performance en plus de la conceptionnelle d'avantage. Je vous ne pouvez pas reproduire ce, cependant, ni en Python 2.7.2 ni à l'article 3.2.2. Est-il quelque chose que je suis absent?
- Il se peut que les avantages réels de coroutines surviennent lorsque le travail à faire consiste à i/o pour les bases de données ou des systèmes distants, et les coroutines eux-mêmes peuvent être gérés dans une expédition de cadre, à l'instar de Torsadée avec la gestion de Deferreds. Cela permet à un thread d'exécution pour le calcul de chevauchement avec les e/s en attente sur plusieurs tâches simultanément, la simulation de threads. Pour quelque chose d'aussi déterministe et synchrone dans cet exemple, les coroutines peut être juste un exercice académique.
- (suite) Si vous avez ajouté un hasard dormir à la coroutine, et a rompu le travail à travers plusieurs coroutines, routage à chacun à son tour, peut-être alors vous devez voir certains avantages, et un potentiel d'évolutivité.
InformationsquelleAutor PaulMcG
4

Vous pouvez utiliser un tuple déstructuration et une defaultdict de raccourcir la boucle de beaucoup de choses:
```
from collections import defaultdict
d = defaultdict(int)
for k,v in pairs: d[k] += v
```
Ce encore utilise une boucle for, mais vous n'avez pas à gérer le cas où la clé n'a pas été vu avant. Je pense que c'est probablement la meilleure solution, à la fois la lisibilité et de performance.

La preuve de concept à l'aide de groupby

Cela dit, vous pourrait faire à l'aide de itertools.groupby, mais c'est un peu un hack:
```
import itertools
dict((k, sum(v for k,v in group)) for k, group 
     in itertools.groupby(sorted(pairs), lambda (k,v): k))
```
Aussi, cela devrait en fait être moins performant que la première approche, parce que en mémoire une liste de toutes les paires doit être créé pour le tri.
- Étant donné que les OP membres qu'ils travaillent avec des "un générateur d'expression", et un "grand nombre" de paires, je voudrais côté avec la defaultdict solution par rapport à un tri+groupby solutions, comme pour la boucle proprement processus du flux de paires, récapitulant le total dans les entrées de la defaultdict, et aucun intermédiaire en mémoire une liste de valeurs doit être créé (comme cela se fait en interne par triés).
- C'est exactement mon avis, mais en regardant en arrière à cette réponse, il n'est pas absolument évident que je considère comme la solution avec un for-boucle d'autant mieux.
InformationsquelleAutor Niklas B.
3
```
>>> dict((x[0], sum(y[1] for y in x[1])) for x in itertools.groupby(sorted(pairs, key=operator.itemgetter(0)), key=operator.itemgetter(0)))
{33: 67, 3: 47, 4: 67, 6: 74, 9: 114, 11: 94, 41: 27, 23: 27}
```
- Ne devrait pas sorted comparaison lexicographiquement par défaut?
- Assurez-vous. Mais je n'ai pas de soins sur le deuxième élément, donc je le laisse tranquille pour qu'elle ne soit pas dans sorted's way.
- Qui semble juste.
- Votre solution est court et doux, performant et qui s'accorde avec le reste de mon code. Parce que j'ai demandé pour un dictionnaire de la solution qui accumule les paires où ils sont générés, il ne serait pas juste d'accepter votre solution. Désolé!
InformationsquelleAutor Ignacio Vazquez-Abrams
1

Non, vous ne pouvez pas le faire sans l'aide de certains forme de boucle. Et à l'aide d'un for boucle est vraiment la chose la plus sensée, parce que vous êtes en train de modifier quelque chose dans le corps de la boucle (et non pas, par exemple, la création d'un nouvel objet iterable ou de la liste.) Néanmoins, vous pouvez simplifier le code en utilisant un collections.defaultdict, comme suit:
```
import collections
dict_k_v = collections.defaultdict(int)
for k, v in pairs:
    dict_k_v[k] += v
```
- Vous pouvez faire cela avec la récursivité, ce qui n'est pas une structure en boucle, mais je suppose que peut-être "certaine" forme de boucle. Ce n'est pas à dire que vous devez résoudre ce problème particulier avec la récursivité.
InformationsquelleAutor Thomas Wouters
1

Haskell a un très beau générique d'assistance pour ceci: Data.Map's fromListWith.

fromListWith est similaire à Python dict les constructeurs, mais il accepte aussi un supplément de combinant la fonction de combiner répétée les touches de valeurs. De le traduire en Python:
```
def dict_fromitems(items, combine):
    d = dict()
    for (k, v) in items:
        if k in d:
            d[k] = combine(d[k], v)
        else:
            d[k] = v
    return d
```
À l'aide de cette aide, il est facile d'exprimer une multitude de combinaisons:
```
>>> import operator
>>> dict_fromitems(pairs, combine=operator.add)
{33: 67, 3: 47, 4: 67, 6: 74, 9: 114, 11: 94, 41: 27, 23: 27}

>>> dict_fromitems(pairs, combine=min)
{33: 67, 3: 47, 4: 67, 6: 27, 9: 47, 11: 27, 41: 27, 23: 27}

>>> dict_fromitems(pairs, combine=max)
{33: 67, 3: 47, 4: 67, 6: 47, 9: 67, 11: 67, 41: 27, 23: 27}

>>> dict_fromitems(((k, [v]) for (k, v) in pairs), combine=operator.add)
{33: [67], 3: [47], 4: [67], 6: [47, 27], 9: [47, 67], 11: [27, 67], 41: [27], 2
3: [27]}
```
Noter que, contrairement aux solutions à l'aide de defaultdict(int), cette approche n'est pas limitée à des valeurs numériques, comme en témoigne la liste exemple ci-dessus. (En général, tout monoïde est un utile: il se définit avec l'union/intersection, les booléens et, ou, des chaînes de caractères avec la concaténation, et ainsi de suite.)

Additif:

Comme d'autres commentaires l'a souligné, il n'y a rien de mal avec l'aide d'une boucle pour cela: c'est le faible niveau de la solution. Cependant, il est toujours bon si vous pouvez envelopper le faible niveau de code réutilisables, de plus haut niveau d'abstraction.

InformationsquelleAutor Pi Delport

Vous pouvez mettre en place un appel récursif, cependant Python n'est pas optimisé pour la récursion sur la queue de sorte que vous devrez payer une pénalité sur la vitesse et ont le potentiel d'une "récurrence" profondes exception.

import operator as o
def dict_sum(pairs, totals={}):
  k, v = pairs.pop()
  o.setitem(sum, k, totals.get(k, 0) + v)
  if not pairs:
    return totals
  else:
    return dict_sum(pairs, totals)

Je voudrais mettre en œuvre dans une boucle for:

import operator as o
totals={}
for k, v in pairs:
   o.setitem(totals, k, totals.get(k, 0) + v)

InformationsquelleAutor dietbuddha

pourquoi ne voulez-vous pas utiliser une boucle for?

pairs = [(3, 47), (6, 47), (9, 47), (6, 27), (11, 27), (23, 27), (41, 27), (4, 67), (9, 67), (11, 67), (33, 67)]
result={}
def add(pair):
    k,v=pair
    result[k]=result.get(k,0)+v
map(add,pairs)
print result

InformationsquelleAutor robert king

-2

Quelque chose comme:
```
dict_k_v = dict(pairs)
```
- Ce ne serait pas faire la bonne chose répétée les touches. (S'il vous plaît, ne supprimez pas la réponse ou nous allons simplement obtenir plus de gens à croire qu'il.)
InformationsquelleAutor Luka Rahne

Vous devez vous connecter pour publier un commentaire.

La preuve de concept à l'aide de groupby

La preuve de concept à l'aide de `groupby`