Map-Liste von Tupeln in ein Wörterbuch, python

Ich habe eine Liste von Tupeln extrahiert aus einer Tabelle in einer DB, die aussieht wie (Schlüssel , foreignkey , Wert). Es gibt viele zu-eins-Beziehung zwischen dem Schlüssel und foreignkeys und möchte ich es konvertieren in ein dict-indiziert durch den foreignkey mit der Summe aller Werte, mit denen foreignkey, also { foreignkey , sumof( Wert ) }. Ich schrieb etwas, das ziemlich ausführlich:

myDict = {}
for item in myTupleList:
    if item[1] in myDict:
        myDict [ item[1] ] += item[2]
    else:
        myDict [ item[1] ] = item[2]

aber nachdem ich diese Frage ist Antwort oder diese zwei es muss ein übersichtlicher Art und Weise auszudrücken, was ich gerne tun würde. Und wenn dies ist eine Wiederholung, habe ich es verpasst, und entfernen Sie die Frage, wenn Sie den link.

Vielleicht off-topic, aber ich Frage... Warum ist das nicht geschehen, auf der Ebene der DB? Das ist die Art von Sache, die DBMS sind gut...
Es ist tatsächlich nicht der DB, sondern auf die der Zugriff über eine Schnittstelle, die behandelt Sie wie eine DB. Es ist nur ein Haufen von flachen Dateien.

InformationsquelleAutor wheaties | 2010-02-05

8

Vorausgesetzt, alle Ihre Werte sind ints, könnte man eine defaultdict um dies zu erleichtern:
```
from collections import defaultdict

myDict = defaultdict(int)

for item in myTupleList:
    myDict[item[1]] += item[2]
```
defaultdict ist wie ein Wörterbuch, außer, wenn Sie versuchen, um einen Schlüssel, der nicht da ist, er füllt in der Rückgabewert aufrufbar - in diesem Fall int, die gibt 0 zurück, wenn ohne Argumente aufgerufen.

UPDATE: Dank @gnibbler mich daran erinnert, aber Tupeln können entpackt werden in einer for-Schleife:
```
from collections import defaultdict

myDict = defaultdict(int)

for _, key, val in myTupleList:
    myDict[key] += val
```
Hier, die 3-Elemente-Tupel wird ausgepackt, in die Variablen _, key, und val. _ ist eine gemeinsame Platzhalter name in Python, verwendet, um anzuzeigen, dass der Wert ist nicht wirklich wichtig. Mit diesem können wir vermeiden, dass Sie die haarige item[1] und item[2] Indizierung. Wir können nicht auf diese angewiesen sind, wenn die Tupel in myTupleList sind nicht alle die gleiche Größe, aber ich Wette, Sie sind.

(Wir haben auch die situation vermeiden, dass jemand den code betrachten und denken, es ist kaputt, weil der Autor dachte, arrays wurden 1-indiziert, das ist, was ich dachte, wenn ich zuerst Lesen Lesen Sie den code. Ich war nicht gelindert, bis ich Lesen die Frage. In der obigen Schleife, aber es ist offensichtlich, dass myTupleList ist ein Tupel mit drei Elementen, und wir brauchen nicht die erste.)
- Die, BTW, war ein Vorschlag in einem der SO posting zitiert in der Frage...
- Danke. Das ist sehr leicht zu Lesen.
- myDict = reduce(lambda d, t: (d[t[1]] += t[2], d)[1], myTupleList, defaultdict(int)) - Sie wissen, jeder sollte nutzen senken! big grin
- Omnifarious, können Sie post, als Antwort und erklären? Das sieht sehr interessant aus. Ich bin auf der Suche nach etwas, das lehren mich etwas neues, vor allem eine funktional gewürzte Antwort.
- okay, seit Ihr gefragt. lacht bevorzuge ich Chris' Lösung viel mehr, obwohl. In diesem Fall reduce verdunkelt. Und meine Lösung ist etwas sowieso falsch, aber ich poste in der richtigen version.
InformationsquelleAutor Chris Lutz
5
```
from collections import defaultdict

myDict = defaultdict(int)

for _, key, value in myTupleList:
    myDict[key] += value
```
- Es gibt drei Werte im Tupel-Liste, die ersten einfach nicht verwendet. Aber die einfache Lösung ist, um _, vor key, also +1.
- Das wird nicht funktionieren, weil myTupleList ist ein drei-Tupel-element. Sie erhalten ValueError: too many values to unpack.
- Lutz, ich hätte nichts dagegen gehabt, wenn Sie es behoben ... 🙂
- Manche Menschen bekommen ein bisschen uppidy wenn die Menschen Bearbeiten Ihre Antworten, aber danke.
- Ich denke, das ist wahrscheinlich ein wenig effizienter als Chris' original-version.
- Ich mag diese Antwort auch eine Menge. Sehr bündig. Ganz klar auf der Bedeutung.
InformationsquelleAutor John La Rooy
4

Hier ist meine (Zunge, Wange) Antwort:
```
myDict = reduce(lambda d, t: (d.__setitem__(t[1], d.get(t[1], 0) + t[2]), d)[1], myTupleList, {})
```
Es ist hässlich und schlecht, aber hier ist, wie es funktioniert.

Das erste argument zu verringern (denn es ist nicht klar, es) ist lambda d, t: (d.__setitem__(t[1], d.get(t[1], 0) + t[2]), d)[1]. Ich werde später darüber sprechen, aber für jetzt, ich ' ll nennen es einfach joe (keine Beleidigung an irgendwelche Leute namens Joe soll). Die senken-Funktion funktioniert im Prinzip so:
```
 joe(joe(joe({}, myTupleList[0]), myTupleList[1]), myTupleList[2])
```
... Und das ist für eine drei-element-Liste. Wie Sie sehen können, es ist im Grunde verwendet das erste argument Art von sammeln jedes Ergebnis in die endgültige Antwort. In diesem Fall, die Letzte Antwort ist das Wörterbuch, das Sie wollte.

Nun für joe selbst. Hier ist joe als def:
```
def joe(myDict, tupleItem):
   myDict[tupleItem[1]] = myDict.get(tupleItem[1], 0) + tupleItem[2]
   return myDict
```
Leider keine form der = oder return durfte in Python lambda so zu bekommen, um. Ich bekomme um die fehlende = durch den Aufruf der dicts __setitem__ Funktion direkt. Ich bekomme um die fehlende Rückkehr in durch die Schaffung eines Tupels mit der return-Wert von __setitem__ und das Wörterbuch, und dann wieder die Tupel-element mit dem Wörterbuch. Ich werde langsam verändern joe so können Sie sehen, wie ich das bewerkstelligen.

Entfernen Sie zuerst die =:
```
def joe(myDict, tupleItem):
   # Using __setitem__ to avoid using '='
   myDict.__setitem__(tupleItem[1], myDict.get(tupleItem[1], 0) + tupleItem[2])
   return myDict
```
Weiter, machen Sie den gesamten Ausdruck zu evaluieren, um den Wert, den wir zurückgeben möchten:
```
def joe(myDict, tupleItem):
   return (myDict.__setitem__(tupleItem[1], myDict.get(tupleItem[1], 0) + tupleItem[2]),
           myDict)[1]
```
Habe ich in diesem use-case, für reduce und dict viele Male in meinem Python-Programmierung. Meiner Meinung nach dict könnte verwenden Sie eine member-Funktion reduceto(keyfunc, reduce_func, iterable, default_val=None). keyfunc würde den aktuellen Wert aus den wiederholenden und den Schlüssel zurückzugeben. reduce_func würde nehmen Sie den vorhandenen Wert in das dictionary und den Wert aus der iterierbar und der neue Wert wird zurückgegeben für das Wörterbuch. default_val wäre, was übergeben wurde, in reduce_func wenn das Wörterbuch fehlt ein Schlüssel. Der Rückgabewert sollte das Wörterbuch selbst, so konnten Sie Dinge tun, wie:
```
myDict = dict().reduceto(lambda t: t[1], lambda o, t: o + t, myTupleList, 0)
```
- Vielen Dank für Entsendung es. Das ist hässlich und unkenntlich, aber es ist zumindest lehrreich. Ich bin so gern Liste Verstehens, dass ich hoffte, dass es sein könnte, irgendeine Art von Wörterbuch Verständnis konnte ich nutzen. Ich habe mich mit seiner Antwort. Es ist so präzise, wie Sie bekommen konnte.
- neuere Versionen von Python (obwohl ich nicht sicher bin, wie neu, Sie haben zu sein) zu tun haben Wörterbuch Verstehens. Ich bin nicht positiv, Sie könnte Sie für Sie arbeiten hier in der Art und Weise, die Sie möchten. Habe ich update meine Antwort hinzufügen, um eine nette Funktion, die Hinzugefügt werden könnten, um die dict interface würde, dass Situationen wie diese viel einfacher zu handhaben.
- python 3 hat dict-Verstehens docs.python.org/dev/3.0/whatsnew/3.0.html
- Goldberg, danke, ich dachte, es könnte eine Py3k Sache. Und, wie ich vermutete, Sie nicht helfen, Sie lösen dieses problem effizient. Prägnant vielleicht, aber nicht effizient, weil es keine gute Möglichkeit zum sammeln der Ergebnisse, die von dictionary-Schlüssel.
InformationsquelleAutor Omnifarious
0

Vielleicht nicht genau lesbar, aber es sollte funktionieren:
```
fks = dict([ (v[1], True) for v in myTupleList ]).keys()
myDict = dict([ (fk, sum([ v[2] for v in myTupleList if v[1] == fk ])) for fk in fks ])
```
Der ersten Zeile findet alle einzigartig Fremdschlüssel. Die zweite Zeile baut Ihr Wörterbuch, indem Sie zuerst konstruieren eine Liste von (fk, sum(alle Werte für diese fk))-paar und drehen, dass in einem Wörterbuch.

InformationsquelleAutor Wim
0

Blick auf SQLAlchemy und sehen, ob das funktioniert die Zuordnung, die Sie benötigen und vielleicht mehr

InformationsquelleAutor user151019

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.