zip-Funktion mit Hilfe Tupeln

Ich hoffe jemand kann mir helfen mit ein problem, ich bin stecken mit. Ich habe eine große Anzahl von Tupeln (>500), die wie folgt Aussehen:

(2,1,3,6)  
(1,2,5,5)  
(3,0,1,6)  
(10,1,1,4)  
(0,3,3,0)

Einen Ausschnitt aus meinem code lautet:

sum1 = (A,B,C,D) # creates a tuple of sums of (A,B,C,D)  
mysum = map(sum, zip(A, B, C, D))
print(mysum)

Erkenne ich den oben aufgeführten code nicht richtig ist. Ich bin versucht, einen Weg finden, um alle Werte zusammen, die alle Werte von B zusammen, alle Werte von C zusammen, und alle Werte von D zusammen mit der zip-Funktion. Zum Beispiel, ich möchte etwas ausdrucken, die wie folgt aussieht:

Asum = 16  
Bsum = 7  
Csum = 13  
Dsum = 21

Kann jemand helfen bitte? Vielen Dank für Ihre Zeit.

InformationsquelleAutor drbunsen | 2011-04-17

python tuples

14
```
>>> zip((1,2,3),(10,20,30),(100,200,300))
[(1, 10, 100), (2, 20, 200), (3, 30, 300)]

>>> [sum(x) for x in zip((1,2,3),(10,20,30),(100,200,300))]
[111, 222, 333]
```
Tun dies mit einer beliebig großen Menge von Tupeln:
```
>>> myTuples = [(1,2,3), (10,20,30), (100,200,300)]
>>> [sum(x) for x in zip(*myTuples)]
[111, 222, 333]
```
nebenbei bemerkt: in Python ist3, beachten Sie, dass zip gibt eine lazy iterierbar, der Sie immer explizit wiederum in eine Liste wie jede andere Art von iterierbar: list(zip(...))

_{(Dank Seganku für den Fang Fehler, die in Beispielen in einen edit-war dreimal abgelehnt, von anderen Editoren)}
- itertools.izip ist wahrscheinlich besser geeignet für längere Listen.
- Wenn ich zip((1,2,3),(10,20,30),(100,200,300)) ich verstehe das nicht [(1, 10, 100), (2, 20, 200), (3, 30, 300)]. Bekomme ich <zip-Objekt an 0x10240af80>. Irgendeine Idee was schief läuft?
- Es gibt einige Unterschiede in der Art python2-Griffe zip-compated zu Python ist3. Ich bin mir nicht sicher, warum in Python ist3 den oben genannten zip nicht funktioniert? Irgendwelche Vorschläge?
- Es funktioniert Prima; die zip-Objekts gibt ein iterierbar Objekt (genau wie Bereich ist, oder ein initialisiertes generator-Funktion). Dies ist generell eine gute Sache, weil Sie nicht haben, um zu berechnen, jeden einzelnen Wert, wenn Sie initialisiert ("lazy ist besser"). Sie können immer explizit konvertieren solche durchsuchbar zu einer Liste etwa so: Liste(zip((1,2),(3,4))), das erzwingen der Auswertung dann-und-dort. Ich habe eine Anmerkung zu dieser Frage, danke.
- Könnten Sie bitte zeigen Sie mich in die richtige Richtung, um das Bild zu bekommen von der * im *myTuples?
- Von "get the picture" meinst du verstehen? Das ist die syntax für die Liste und 'anwenden' als Argumente an eine Funktion. So f(*[1,2,3]) bedeutet f(1,2,3). Es gibt eine Variante für Schlüsselwort-Argumente: f(**dict(x=1, y=2)) bedeutet f(x=1, y=2). Siehe stackoverflow.com/questions/3394835/args-and-kwargs und die stackoverflow.com/questions/36901/...
- Ja, ich meinte zu begreifen. Danke. Ich hatte gelesen das offizielle Dokument, in dem es heißt "mit der * - operator kann verwendet werden, um entpacken Sie eine Liste", aber ich blieb verwirrt. Dank sehr viel.
InformationsquelleAutor ninjagecko
4
```
map(sum, zip(a, b, c, d, e))
```
Den ersten Anruf zu zip, kehrt die Listen - macht eine Liste der ersten Elemente, zweiten Elemente, etc.

Den zweiten Aufruf map ruft das erste argument sum auf dem zweiten argument, diese Listen zurückgeben einer Liste der Ergebnisse der sum -, die passiert werden die Summen.
- Danke, ich denke, das ist, was ich brauche. Ich bin gerade noch ein bisschen verwirrt aber. zip(a, b, c, d, e)... nicht sicher, was 'e' ist? Gibt es nicht nur vier zahlen in jedem Tupel (a,b,c,d)? Wenn ich diese in mein script, erhalte ich einen " TypeError: zip-argument #1 muss zur Unterstützung der iteration.' Irgendwelche Ideen? Ich bearbeitete meinen ursprünglichen post zu reflektieren, was ich getan habe.
- a, b, c, d, und e sind die Tupel, die Sie aufgelistet. Jeder ist ein Tupel mit vier Elementen.
InformationsquelleAutor
2

Es deine sets sind alle die gleiche Größe und sind Sie arbeiten in C, Python, sollten Sie erwägen,numpy. Sie können dies tun, in numpy etwa so:
```
In [5]: sets = ((2,1,3,6),
   ...:         (1,2,5,5),
   ...:         (3,0,1,6),
   ...:         (10,1,1,4),
   ...:         (0,3,3,0)  )*100

In [6]: import numpy as np

In [7]: A = np.array(sets)

In [8]: np.sum(A, axis=0)
Out[8]: array([1600,  700, 1300, 2100])
```
Numpy wandelt die Werte in ein array und arbeitet mit Ihnen effizient mit optimierten LAPACK-Funktionen.

Leistung vergleichen, ich profilierter unter zwei Sätze von Annahmen. In der ersten, gehe ich davon aus, dass Ihre Daten gespeichert, so dass die Einfuhr in ein Numpy-array ist effizient, so dass ich nicht die Zeit, erforderlich zum konvertieren von Datensätzen in ein array. Ich verglich die Leistung der np.sum [sum(x) für x in einer zip-Datei(*sets)]. Hier sind die timeit Ergebnisse für jeden Fall:
```
Excluding numpy Array Conversion: 0.0735958760122
Including numpy Array Conversion: 17.1435046214
Plain old zip: 0.660146750495
```
Die Schlussfolgerung ist, dass numpy ist schneller, wenn sich Ihre input-Daten können einfach importiert und mit numpy.
- Ich vermute, der Aufwand von numpy wäre sehr groß hier, es sei denn, Sie sind den Umgang mit tausenden von Artikeln.
- Ich füge einen "timeit" - Beispiel in einer Sek.
InformationsquelleAutor Carl F.
0

Wenn Sie haben Sie alle, die Tupel in einer Liste haben, dann könnten Sie reduce():
```
>>> list(reduce(lambda x,y: (i+j for i,j in zip(x,y)), tuples, [0]*4))
[16, 7, 13, 21]
```
InformationsquelleAutor Felix Kling

tuples  = [(2,1,3,6), (1,2,5,5),  (3,0,1,6), (10,1,1,4), (0,3,3,0)]
s = [sum(tup) for tup in zip(*tuples)]
Asum, Bsum, Csum, Dsum = s

InformationsquelleAutor Vasil

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.