Schönen code für b[1][2][3][4] = 5?

[p90]

Hi,

also habe folgendes Problem.
Möchte in Python die Möglichkeit haben einen Tensor 4 Grades darzustellen.
Konkret geht es um ein Lösungssystem für Sudokus.
Immo Spreche ich jedes der Felder 81 Felder mit einer 4 Stelligen Zahl von 0000 bis 2222 (also 3*3*3*3 = 81) an. Dies ermöglicht mir einfaches Gruppieren der sich gegenseitig beeinflussenden Blöcke.

Habe mir zum Lösen eine kleine Zellenklasse geschrieben. Diese Möchte ich nun in einer "Verwaltungsklasse" speichern damit diese die Interaktion zwischen den Zellen koordinieren kann.
Dazu muss ich mir einen Grid erschaffen in dem ich halt über diese Nummer die jeweilige Zelle ansprechen kann. Also grid[1][2][0][2] wäre z.B. die 1 * 3 + (2+1) Zelle in X und die 0 * 3 + (2+1) Zelle in Y Richtung. Um diesen Grid zu erschaffen benutze ich Immo verschachtelte Listen. Das sieht so aus:

Code: Alles auswählen

        self.grid = [
                        [
                            [  
                                [ 
                                    [], [], []  
                                ],
                                [
                                    [], [], []
                                ],
                                [
                                    [], [], []
                                ]
                            ],
                            [
                                [
                                    [], [], []
                                ],
                                [
                                    [], [], []
                                ],
                                [
                                    [], [], []
                                ]
                            ],
                            [
                                [
                                    [], [], []
                                ],
                                [
                                    [], [], []
                                ],
                                [
                                    [], [], []
                                ]
                            ]
                        ],
                        [
                            [
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ]
                                ],
                            [
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ]
                                ],
                            [
                                [
                                    [], [], []
                                ],
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ]
                                ]
                            ],
                        [
                            [
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ]
                                ],
                            [
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ]
                                ],
                            [
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ],
                                [
                                    [], [], []
                                    ]
                                ]
                            ]
                        ]

(ich habe die \ zum Zeilen abschließen noch nicht eingefügt)
Wie ihr seht ist das nicht gerade schön.
Man könnte zwar irgendwas mit Schleifen machen aber ich würde doch lieber ne schönere Lösung finden.

Hat irgendeiner ne Idee?


Bis später

p90

[BlackJack]

@p90: Mit Schleifen wäre das auf jeden Fall schonmal schöner.

Die \ brauchst Du hier nicht. Eine "logische" Zeile ist erst zuende, wenn alle geöffneten Klammern ('(', '{', oder '[') auch wieder geschlossen wurden.

Wenn Du das in eine eigene Klasse kapselst, könntest Du `__getitem__()` und `__setitem__()` überschreiben, so dass die Methoden Tupel mit Indizes entgegennehmen. Dann kannst Du beim Zugriff viele eckige Klammern sparen und zum Beispiel ``b[1, 2, 3, 4] = 5`` schreiben. Implementierung könnte so aussehen:

Code: Alles auswählen

    def __setitem__(self, indices, value):
        a, b, c, d = indices
        self.data[a][b][c][d] = value

[Hyperion]

Ansonsten mal bei numpy gucken ob die eine (schöne) Lösung für Tensoren haben.

[Defnull]

Code: Alles auswählen

def mlist(dim, *rec):
    return [mlist(*rec) for i in xrange(dim)] if rec else dim

Zur Erklärung: mlist(x1, x2, ..., xn, default) gibt eine n-dimensionale verschachtelte Liste zurück, wobei die Breite jeder Dimension durch x1 bis xn angegeben wird. Der letzte Parameter gibt den Wert der Elemente der letzte Dimension an.
Die Funktion ist rekursiv und entfernt bei jeder Rekursion das jeweils erste Argument. Die Rekursion terminiert, wenn nur noch ein Argument übrig bleibt.

Code: Alles auswählen

>>> mlist(1,2,3,4)
[[[4, 4, 4], [4, 4, 4]]]
>>> mlist(3,3,3,3,0)
[[[[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]], [[[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]], [[[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]]]]
>>> mlist(2,3,'x')
[['x', 'x', 'x'], ['x', 'x', 'x']]

[p90]

Hi,

@ BlackJack
Das ist schon mal interessant auch wenn ich es hier nicht verwenden werde.
Aber für die Zukunft ist das schon mal super!!

@ Hyperion
Ja daran hatte ich auch gedacht aber dachte die numpy arrays bzw tensoren würden nur ints oder floats nehmen. Habs aber gerade ausprobiert, die nehmen alles also auch meine eigene Class ^^

@ Defnull
Hm, da schaue ich gerade noch nicht ganz durch.
Aber werde es mir noch mal genauer ansehen!