Indexlisten "vereinigen"

[Photor]

Hallo Forum,

zur Zeit versuche ich endlich mal wieder etwas zu programmieren und nutze dafür Python. Ich habe mehrere parallele Zeitreihen (z.B. Kraft über Zeit), die ich auf ihre jeweiligen lokalen Extrempunkte eingedampft habe. Ich brauche aber zu jedem Zeitpunkt jeweils Werte aller Zeitreihen. Ich merke mir für jede Zeitreihe nur den Index der rel. Extrema (Beispiel mit 2 hypothetischen Reihen):

Code: Alles auswählen

extrem1 = [0,11,25,47,58,62,75,97,100]
extrem2 = [0,14,25,40,75,100]

Daraus sollte also folgendes werden:

Code: Alles auswählen

beide = [0,11,14,25,40,47,58,62,75,97,100]

Natürlich konnte man

1. Man könnte jetzt Index für Index in jeder Liste anschauen und in die beide-Liste packen, wenn er noch nicht da ist. Das erscheint mir aber zu zeitaufwändig (so müsste man es wohl in Delphi oder so machen).
2. beide Arrays oder Listen aneinanderhängen, sortieren und dann doppelte rauswerfen. Das erscheint mir aber auch relativ aufwändig.
3. Ich habe auch an die Möglichkeit gedacht, die beiden Indexlisten als Sets zu betrachen und die Vereinigungsmenge zu bilden (doppelte fallen dann ja sofort raus. Aber was ist mit der Sortierung?

Wie mache ich das auf einem möglichst pythonischen Weg? kann mir jemand einen Schubs in die richtige Richtung geben?

Danke,

Photor

PS: üblicherweise haben die Zeitreihen ca 15000 Wertepaare und es sollen 6 bis 25 Zeitreihen parallel betrachtet werden.

[Hyperion]

@1.) Inwiefern Delphi da nun schneller ist, kann ich nicht beurteilen, aber Du solltest primär erst einmal die Zeitkomplexität des Algoritmus analysieren - ein ineffizienter Algoritmus wird ab einer gewissen Problemgröße selbst in einer extrem schnellen Sprach(implementierung) immer langsamer abalufen, als ein effizienter in einer schnarch langsamen Sprach(implementierung). Primär kommt es auf die Effizienz an, bei selber Effizienz kann man dann auch auf die Sprache gucken (in Python würde man üblicher Weise dann Cython oder eine C-Erweiterung nutzen - sofern PyPy nicht schon ausreicht), wenn eine Implementierung zu langsam ist. Die Effizienz oder Zeitkomplexität gibt man idR. in O-Notation an.

Ich würde es erst einmal über eine Mengenvereinigung und anschließend dem Sortieren probieren. Ersteres kostet Dich O(n*m), bei m Zahlenreihen mit je maximal n Einträgen. Das Sortieren dann O(n log n) für die "neue" Länge n der neu entstandenen Menge.

Zum einen ist das einfach zu implementieren (und damit ein gutes Indiz für pythonisches Vorgehen), zum anderen bekommst Du schnell einen Messwert, an dem Du Ablesen kannst, ob das "schnell genug" ist. Wenn nicht, kann man sich ggf. noch über andere Ansätze Gedanken machen.

[Photor]

Hallo,

ich habe jetzt erstmal sowas gemacht:

Code: Alles auswählen

indexset = set()
for zr in allTS:
    indexset = indexset | set(zr.ExtremIndex)
indexlist = sorted(list(indexset))
print ('Index-Set ({:d}): {}'.format(len(indexlist), indexlist))

allTS ist eine Liste aller Zeitreihen-Objekte; die Klasse enthält die ExtremIndex-Liste.

In meinen Tests habe ich erstmal kein Problem mit dem Timing festgestellt.

Ciao,

Photor

[BlackJack]

@Photor: Da werden einige Objekte zu viel erstellt, hauptsächlich lauter `set()`-Exemplare für Zwischenergebnisse und eine überflüssige Liste (ungetestet):

Code: Alles auswählen

    indexset = set()
    for zeitreihe in alle_zeitreihen:
        indexset.update(zeitreihe.extrem_index)
    indexlist = sorted(indexset)
    print('Index-Set ({}): {}'.format(len(indexlist), indexlist))

[Photor]

Hallo BlackJack,

danke für den Hinweis. Ist jetzt (angepasst) getestet - und tut fein.

Ich denke wohl noch nicht pythonisch genug Danke jedenfalls.

Ciao,

Photor