Durchschnitt von zwei aufeinander folgenden Elementen in der Liste in Python

Ich habe eine Liste mit einer geraden Anzahl von float-zahlen:

[2.34, 3.45, 4.56, 1.23, 2.34, 7.89, ...].

Meine Aufgabe ist es, die Berechnung der durchschnittlichen 1-und 2-Elemente, 3 und 4, 5 und 6, usw. Was ist der kurze Weg, dies zu tun in Python?

InformationsquelleAutor drastega | 2013-12-11
  1. 18
    data = [2.34, 3.45, 4.56, 1.23, 2.34, 7.89]
print [(a + b) / 2 for a, b in zip(data[::2], data[1::2])]

    Erklärung:

    data[::2] ist die Elemente 2.34, 4.56, 2.34

    data[1::2] ist die Elemente 3.45, 1.23, 7.89

    zip kombiniert Sie in ein 2-Tupel: (2.34, 3.45), (4.56, 1.23), (2.34, 7.89)

    • +1 für sexy (für die Erklärung)
    • Nizza Verwendung von zip - und list-comprehension! Macht die Berechnung schlank und effizient.
    InformationsquelleAutor Paul Draper
  2. 9

    Wenn die Liste nicht zu lang, Paul Draper, die Antwort ist einfach. Wenn es ist wirklich lange, Sie wahrscheinlich wollen zu berücksichtigen, eine der beiden anderen Optionen.

    Zuerst mit Iteratoren, können Sie vermeiden, kopieren um riesige temporäre Listen:

    avgs = [(a + b) / 2 for a, b in zip(*[iter(data)]*2)]

    Bedeutet dies effektiv das gleiche, aber träge, was bedeutet, es hat nur zum speichern einen Wert in einer Zeit, in Erinnerung (gut, drei Werte a, b, und der Durchschnitt) anstelle von alle von Ihnen.

    • iter(data) schafft ein fauler iterator über Daten.
    • [iter(data)]*2 erstellt eine Liste mit zwei Referenzen auf das gleiche iterator, so dass, wenn ein Fortschritt, der andere als gut.
    • Dann sind wir mit den gleichen zip und Liste Verständnis, dass Paul schon so gut erklärt. (In Python 2.x, im Gegensatz zu 3.x, zip ist nicht faul, so sind Sie verwenden möchten itertools.izip eher als zip.)

    Wenn Sie nicht wirklich brauchen, die Ergebnis-Liste, sondern nur etwas, das Sie Durchlaufen, ändern sich die äußeren eckigen Klammern zu Klammern, und es wird ein generator-Ausdruck, Bedeutung es gibt einen iterator statt einer Liste, und Sie sind sich nicht speichern überhaupt nichts.

    Beachten Sie, dass die itertools docs haben ein Rezept für eine grouper hat, der die knifflige bit (und Sie finden es auch in der third-party-Modul mehr-itertools), so kann man nur schreiben grouper(data, 2) statt zip(*[iter(data)]*2), das ist sicherlich besser lesbar, wenn Sie es Häufig. Wenn Sie möchten, eine nähere Erläuterung, siehe Wie Zackenbarsch funktioniert.

    Alternativ können Sie NumPy arrays anstelle von Listen:

    data_array = np.array(data)

    Dann können Sie genau dies tun:

    avg_array = (data_array[::2] + data_array[1::2]) / 2

    Das ist nicht nur einfacher (keine Notwendigkeit für explizite Schleifen), es ist auch etwa 10x schneller, und dauert etwa 1/4th der Speicher.

    Wenn Sie generalisieren wollen, auf diese willkürliche-Länge-Gruppen...

    Für die iterator-Lösung, ist es trivial:

    [sum(group) / size for group in zip(*[iter(data)]*size)]

    Für die NumPy-Lösung, ist es ein bisschen schwieriger. Sie haben, um dynamisch erstellen Sie etwas iterator über data[::size], data[1::size], ..., data[size-1::size] wie diese:

    sum(data[x::size] for x in range(size)) / size

    Gibt es andere Möglichkeiten, dies zu tun in NumPy, aber solange size ist nicht zu groß, das wird gut—und es hat den Vorteil, dass die exakt gleiche trick funktioniert für Paul Draper Lösung:

    [sum(group) / size for group in zip(*(data[x::size] for x in range(size)))]
    • Ich würde geneigt sein, um generische, indem das Auspacken und machen Sie es so, dass die einzige variable ist die Größe der Gruppe: avgs = [sum(vals, 0.0) / size for vals in zip(*[iter(data)]*size)] oder ähnliches
    • Ich verknüpft mit "Wie Zackenbarsch arbeiten", das sollte erklären, wie der harte Teil, aber ja, es könnte sich lohnen, erklärt der einfache Teil (mit sum statt +) sowie... außer, dass ich denke, Ihr Kommentar sagt bereits alles, was nötig ist.
    • Am zweiten Gedanken, ich denke, dass es war Wert, zu erklären, zu zeigen, wie die "einfache" Lösung ist tatsächlich schwieriger zu erweitern, um beliebige/dynamische Größen als die zwei "harten" Lösungen. Also, danke für die Erziehung.
    • und das "es gibt andere Wege, dies zu tun in NumPy" wäre so etwas wie: np.array([1, 2, 3, 4, 5, 6]).reshape(3, 2).mean(axis=1) ?
    • Ja, aber zu verallgemeinern, dass Sie als-ist, müssen Sie berechnen die Form als (len(data)//size, size), das wird schnell hässlich, so dass an diesem Punkt, ich denke, es ist Zeit zu beginnen, factoring Teile von diesem in eine Funktion.
    • Es war nicht eine fehlende ). Die / size außerhalb der sum. Also rollte ich zurück zu ändern. (Sie können testen Sie es einfach durch das einfügen der Zeile in Ihrem interpreter.)
    • Wie seltsam. Ich dachte, dass es seltsam ist, Sie würde sowas lassen slip, und sah es, und dachte - okay, besser korrekt, dass man. Dann betrachtet es heute morgen - es ist in der Tat absolut nichts falsch. Guter Vorsatz, der nicht so Recht überwinden, müde Augen erscheinen würde. Ich entschuldige mich.

    InformationsquelleAutor abarnert
  3. 4
    s= [2.34, 3.45, 4.56, 1.23, 2.34, 7.89, ...]

res= [(s[i]+s[i+1])/2 for i in range(0, len(s)-1, 2)]
    InformationsquelleAutor Twisted Meadow
  4. 0

    Benutzen Sie einfach als index für die Aufgabe.

    Für das einfache Beispiel,

    avg = []
list1 = [2.34, 3.45, 4.56, 1.23, 2.34, 7.89]

for i in range(len(list1)):
    if(i+1 < len(list1):
        avg.append( (list1[i] + list1[i+1]) / 2.0 )

avg2 = []
avg2 = [j for j in avg[::2]]

    avg2 ist, was Sie wollen. Diese vielleicht leicht zu verstehen..

    • Bitte vermeiden Sie die Verwendung von Indizes, um den Zugriff auf Daten in Sequenzen, und kümmern sich nicht um die Verwendung list als Variablen-name: for elem_odd, elem_even in zip( data[::2], data[1::2]): print (elem_odd + elem_even)/2.0, ist viel schlanker.
    • Hängt davon ab, was du meinst mit "schlanker". Seine version ist total storage-Kosten 3 schwebt; deine 3 Listen und 2*N schwimmt. Wenn N 6, who cares. Aber wenn N 1000000, das ist nicht gerade eine Verbesserung.
    • Ich meine einfach, aber du hast Recht, dies kann eine Verbesserung, wenn Leistung benötigt wird, als Sie speichern nur eine Liste. Aber in meinem Algorithmus, wenn ich bin nicht falsch, elem_odd und elem_even werden nur einmal gespeichert, auch wenn ich drei der Liste (wie Paul Draper ' s Antwort). Nota: zip faul ist in Python ist3, so würde dies schaffen Sie nur zwei Listen.
    • Ich weiß zip faul ist in Python 3, aber dein code ist eindeutig Python 2, da es verwendet print als eine Aussage. Mittlerweile, du hast Recht, dass Sie nicht zur Schaffung von 2*N neuen Wagen, aber Sie immer noch schaffen, 3*N-Liste slots (in CPython Bedingungen, nur 2 zusätzliche PyFloatObjects, aber 3*N extra-Zeiger). Jedenfalls kann man umgehen, indem itertools.islice anstelle von Listen-slicing, aber ich glaube, an diesem Punkt sind Sie besser, nur die Gruppierung von iterator in den ersten Platz (wie in meiner Antwort).
    InformationsquelleAutor GoodGJ
Schreibe einen Kommentar