Ein unvollständige PositionsArray in Matrix füllen

[cimi25]

Hallo liebe Community,

ich bin total am verzweifeln.. Ich habe einen Array, der aus einem Datensatz zusammenhängede CSV Datein in Matrizen speichern soll. Ich weiß vorher nicht wie groß der Datensatz ist daher soll er die Matrixen einfach erzeugen.
In dem Beispiel bekomme ich diesen Array für die Positionen der Matrix:
[[1, 1, 1, 0], [1, 1, 5, 0], [1, 2, 0, 0], [1, 2, 0, 1], [1, 2, 0, 2], [1, 2, 1, 0], [1, 2, 1, 1], [1, 2, 1, 2], [1, 2, 2, 0], [1, 2, 2, 1], [1, 2, 2, 2], [1, 3, 0, 1], [1, 3, 0, 1], [1, 3, 0, 1], [1, 3, 0, 2], [1, 3, 1, 1], [1, 3, 1, 1], [1, 3, 1, 1], [1, 3, 1, 2], [1, 3, 1, 2], [1, 3, 1, 2], [2, 1, 1, 0], [2, 1, 5, 0], [2, 2, 0, 0], [2, 2, 0, 1], [2, 2, 0, 2], [2, 2, 1, 0], [2, 2, 1, 1], [2, 2, 1, 2], [2, 2, 2, 0], [2, 2, 2, 1], [2, 2, 2, 2], [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 4, 0, 10], [2, 4, 1, 10], [3, 1, 0, 0], [3, 1, 1, 0], [3, 1, 1, 0], [3, 1, 2, 0], [3, 1, 3, 0], [3, 1, 10, 0], [3, 2, 0, 0], [3, 2, 0, 1], [3, 2, 0, 2], [3, 2, 1, 0], [3, 2, 1, 1], [3, 2, 1, 2], [3, 2, 2, 0], [3, 2, 2, 1], [3, 2, 2, 2], [3, 3, 0, 2], [3, 3, 0, 2], [3, 3, 0, 2], [3, 3, 1, 2], [3, 3, 1, 2]]

Ich möchte jetzt aus den Positionen eine Matrix der Tiefe 4 erzeugen, wobei jeder Eintrag seine Position darstellt:

Code: Alles auswählen

fertige_matrix =fertige_matrix =np.array([[[[]]]])
for element in position: 
    if element[tiefe1] <  element[tiefe1+1]:
        tiefe2,tiefe3,tiefe4=0  
        fertige_matrix[tiefe1][tiefe2][tiefe3][tiefe4].append([0,0])
        tiefe1=tiefe1+1
    elif element[tiefe2] <  element[tiefe2+1]:
        tiefe3,tiefe4=0        
        fertige_matrix[tiefe1][tiefe2][tiefe3][tiefe4].append([0,0])
        tiefe2=tiefe2+1
    elif element[tiefe3] <  element[tiefe3+1]:
        tiefe4 = 0
        fertige_matrix[tiefe1][tiefe2][tiefe3][tiefe4].append([0,0])
        tiefe3=tiefe3+1
    elif element[tiefe4] <  element[tiefe4+1]:
        fertige_matrix[tiefe1][tiefe2][tiefe3][tiefe4].append([0,0])
                          
        

Leider bekomme ich die Fehlermeldung TypeError: cannot unpack non-iterable int object. Ich sehe den Wald vor lauter Bäumen nicht mehr. Ich sitze seit Tagen dran und irgendwie ist jeder Versuch ein anderer Knoten im Kopf. Vielleicht hat einer von euch eine Idee, oder sowas ähnliches gemacht..

[Sirius3]

Was denkst Du macht diese Zeile: `tiefe2,tiefe3,tiefe4=0`?

`tiefe1`, `tiefe2`, `tiefe3` und `tiefe4` sind gar nicht definiert.
Warum wird `fertige_matrix` zweimal zugeweisen?
Numpy-Arrays haben eine fixe Größe. Daher sollte Dein erster Schritt sein, aus den Positionen die Maximal-Werte zu bestimmen und dann einfach eine Matrix der passenden Größe erzeugen. Ist `position` (eigentlich `positionen`) schon ein numpy-Array geht das ganz einfach per max und dem axis-Argument.

[cimi25]

Hallo Sirius,
danke für deine Antwort:
Ich habe mich wahrscheinlich unklar ausgedrückt, deswegen hier nochmal ein Versuch mit einem Beispiel mit nur 3 "tiefen":

Input: ([ [1,0,0],[1,0,1],[1,0,5],[1,3,0], [2,0,1] ]

Output: [ [ [ [1,00],[1,01][1,0,5] ], [1,3,0] ] ], [[[2,0,1]]] ]

Daher meine Ich mit Tiefen mein Verschaltelungsgrad. Die Variablen habe ich alle Definiert gehabt. Sind beim übertragen leider nicht mitgekommen

[einfachTobi]

Bitte poste funktionierende Beispiele. Das ist ganz sicher nicht der Input und auch ganz sicher nicht der verlangte Output, da beide syntaktische Fehler enthalten.

[Sirius3]

@cimi25: das macht die Sache nicht gerade verständlicher. Da fehlen auch noch einige leere Listen, wenn ich das wieder dekodieren will.
Da die Struktur nichts regelmäßiges hat, ist numpy das falsche Werkzeug.

[cimi25]

Hallo einfachTobi und Sirius3,

ich wollte euch keine Unannehmlichkeiten machen, ich bin sehr dankbar für Hilfe. Mein Problem ist eine unregelmäßige Struktur in eine Regelmäßige zu biegen. Ich habe das ganze nochmal neu aufgesetzt und es mit listen versucht. Leider ist der listindex out of range beim zweiten Durchlauf:

Code: Alles auswählen

position = [[0,0,0,0],[1, 1, 1, 0], [1, 1, 5, 0], [1, 2, 0, 0], [1, 2, 0, 1], [1, 2, 0, 2], [1, 2, 1, 0], [1, 2, 1, 1], [1, 2, 1, 2], [1, 2, 2, 0], [1, 2, 2, 1], [1, 2, 2, 2], [1, 3, 0, 1], [1, 3, 0, 1], [1, 3, 0, 1], [1, 3, 0, 2], [1, 3, 1, 1], [1, 3, 1, 1], [1, 3, 1, 1], [1, 3, 1, 2], [1, 3, 1, 2], [1, 3, 1, 2], [2, 1, 1, 0], [2, 1, 5, 0], [2, 2, 0, 0], [2, 2, 0, 1], [2, 2, 0, 2], [2, 2, 1, 0], [2, 2, 1, 1], [2, 2, 1, 2], [2, 2, 2, 0], [2, 2, 2, 1], [2, 2, 2, 2], [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 4, 0, 10], [2, 4, 1, 10], [3, 1, 0, 0], [3, 1, 1, 0], [3, 1, 1, 0], [3, 1, 2, 0], [3, 1, 3, 0], [3, 1, 10, 0], [3, 2, 0, 0], [3, 2, 0, 1], [3, 2, 0, 2], [3, 2, 1, 0], [3, 2, 1, 1], [3, 2, 1, 2], [3, 2, 2, 0], [3, 2, 2, 1], [3, 2, 2, 2], [3, 3, 0, 2], [3, 3, 0, 2], [3, 3, 0, 2], [3, 3, 1, 2], [3, 3, 1, 2]]
fertige_matrix = [[[[[]]]]]
tiefe0=0
tiefe1=0
tiefe2=0
tiefe3=0

for element in range(len(position)-1):
    print(position[element], position[element+1])
    
    if position[element][0] <  position[element+1][0]:
        tiefe1,tiefe2,tiefe3=0,0,0
        fertige_matrix[tiefe0][tiefe1][tiefe2][tiefe3].append(5)
        tiefe0=tiefe0+1
    elif position[element][1] <  position[element+1][1]:
        tiefe2,tiefe3=0,0        
        fertige_matrix[tiefe0][tiefe1][tiefe2][tiefe3].append(5)
        tiefe1=tiefe1+1
    elif position[element][2] <  position[element+1][2]:
        tiefe3 = 0
        fertige_matrix[tiefe0][tiefe1][tiefe2][tiefe3].append(5)
        tiefe2=tiefe2+1
    elif position[element][3] <  position[element+1][3]:
        fertige_matrix[tiefe0][tiefe1][tiefe2][tiefe3].append(5)
        tiefe3=tiefe3+1

[Sirius3]

Und immer noch kein Beispiel, wie denn das Ergebnis nun aussehen soll...

[einfachTobi]

Ich glaube ich kann erahnen, wie es funktionieren soll. Hier ein Versuch, auf dem man ggf. aufsetzen kann:

Code: Alles auswählen

import numpy as np
positionen = np.array([[0, 0, 0, 0], [1, 1, 1, 0], [1, 1, 5, 0], [1, 2, 0, 0], [1, 2, 0, 1], [1, 2, 0, 2], [1, 2, 1, 0],
                       [1, 2, 1, 1], [1, 2, 1, 2], [1, 2, 2, 0], [1, 2, 2, 1], [1, 2, 2, 2], [1, 3, 0, 1], [1, 3, 0, 1],
                       [1, 3, 0, 1], [1, 3, 0, 2], [1, 3, 1, 1], [1, 3, 1, 1], [1, 3, 1, 1], [1, 3, 1, 2], [1, 3, 1, 2],
                       [1, 3, 1, 2], [2, 1, 1, 0], [2, 1, 5, 0], [2, 2, 0, 0], [2, 2, 0, 1], [2, 2, 0, 2], [2, 2, 1, 0],
                       [2, 2, 1, 1], [2, 2, 1, 2], [2, 2, 2, 0], [2, 2, 2, 1], [2, 2, 2, 2], [2, 3, 0, 2], [2, 3, 0, 2],
                       [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2],
                       [2, 4, 0, 10], [2, 4, 1, 10], [3, 1, 0, 0], [3, 1, 1, 0], [3, 1, 1, 0], [3, 1, 2, 0],
                       [3, 1, 3, 0], [3, 1, 10, 0], [3, 2, 0, 0], [3, 2, 0, 1], [3, 2, 0, 2], [3, 2, 1, 0],
                       [3, 2, 1, 1], [3, 2, 1, 2], [3, 2, 2, 0], [3, 2, 2, 1], [3, 2, 2, 2], [3, 3, 0, 2], [3, 3, 0, 2],
                       [3, 3, 0, 2], [3, 3, 1, 2], [3, 3, 1, 2]])
positionen_max = np.max(positionen, axis=0)
dimensionen = np.append(positionen_max + 1, positionen.shape[1])
matrix = np.zeros(dimensionen)
for i, position in enumerate(positionen):
    matrix[positionen[i, 0], positionen[i, 1], positionen[i, 2], positionen[i, 3]] = position
print(matrix[1, 1, 5, 0])

Das ist der erste Schuss aus der Hüfte. Ich gebe zu bedenken, dass der Code mindestens folgende Nachteile hat: Schleife für die einzelnen Positionen, Indizierung der Matrix innerhalb der for-Schleife ist hart codiert und damit nicht startklar für wechselnde Eingangsdaten. Ich denke, dass man das eleganter lösen kann. Mir fällt jedoch auf die Schnelle nichts ein.
Habe ich die Aufgabe überhaupt richtig verstanden? Jede Zeile in `positionen` enthält die Koordinate an dem die Zeile in der Gesamtmatrix stehen soll? Ohne Ergebnisbeispiel ist das nur eine Vermutung.

[cimi25]

Das hilft schon mal sehr weiter, ist aber nicht genau was ich brauche. Aber ich glaube ich habe es dank eurer hilfe gelöst:

Code: Alles auswählen

position = [[0,0,0,0],[1, 1, 1, 0], [1, 1, 5, 0], [1, 2, 0, 0], [1, 2, 0, 1], [1, 2, 0, 2], [1, 2, 1, 0], [1, 2, 1, 1], [1, 2, 1, 2], [1, 2, 2, 0], [1, 2, 2, 1], [1, 2, 2, 2], [1, 3, 0, 1], [1, 3, 0, 1], [1, 3, 0, 1], [1, 3, 0, 2], [1, 3, 1, 1], [1, 3, 1, 1], [1, 3, 1, 1], [1, 3, 1, 2], [1, 3, 1, 2], [1, 3, 1, 2], [2, 1, 1, 0], [2, 1, 5, 0], [2, 2, 0, 0], [2, 2, 0, 1], [2, 2, 0, 2], [2, 2, 1, 0], [2, 2, 1, 1], [2, 2, 1, 2], [2, 2, 2, 0], [2, 2, 2, 1], [2, 2, 2, 2], [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 0, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 3, 1, 2], [2, 4, 0, 10], [2, 4, 1, 10], [3, 1, 0, 0], [3, 1, 1, 0], [3, 1, 1, 0], [3, 1, 2, 0], [3, 1, 3, 0], [3, 1, 10, 0], [3, 2, 0, 0], [3, 2, 0, 1], [3, 2, 0, 2], [3, 2, 1, 0], [3, 2, 1, 1], [3, 2, 1, 2], [3, 2, 2, 0], [3, 2, 2, 1], [3, 2, 2, 2], [3, 3, 0, 2], [3, 3, 0, 2], [3, 3, 0, 2], [3, 3, 1, 2], [3, 3, 1, 2]]

fertige_matrix = []
tiefe1=0
tiefe2=1
tiefe3=2
tiefe4=3


for element in range(len(position)-1):

        if element==0:
            fertige_matrix.append([[[  ]]])
        if position[element][tiefe1] < position[element+1][tiefe1]:
            fertige_matrix.append([[[  ]]])
        elif position[element][tiefe2] < position[element+1][tiefe2]:
            fertige_matrix[-1].append([[  ]])
        elif position[element][tiefe3] < position[element+1][tiefe3]:
            fertige_matrix[-1][-1].append([  ])
        elif position[element][tiefe4] < position[element+1][tiefe4]:
            fertige_matrix[-1][-1].append([  ])


print(fertige_matrix) 

mein Output sollte so aussehen:
[[[[]]], [[[], []], [[], [], [], [], [], [], [], [], []], [[], [], [], []]], [[[], []], [[], [], [], [], [], [], [], [], []], [[], []], [[], []]], [[[], [], [], [], []], [[], [], [], [], [], [], [], [], []], [[], []]]]

[einfachTobi]

Ok, es handelt es sich also gar nicht um Arrays, sondern um reine Listen. Schön, dass es nun für dich funktioniert. Das was du da machst scheint mir allerdings recht losgelöst und ich vermute, das wird dir früher oder später neue Probleme einhandeln. Nur interessehalber: Wozu brauchst du leere Listenstrukturen? Was ist Hintergrund der ganzen Sortiererei?

[cimi25]

Die liste wird nicht leer sein. In jedem Listenelement wird repräsentiert eine Mean-Value eines Datensatzes. Aus der Matrix möchte ich dann die Determante bilden um die Entwicklung meiner Proben zu zeigen.

nochmals vielen lieben Dank