@bas_oldy: Naja, Du hängst halt immer das *selbe* Feld an und bearbeitest auch immer das *selbe* Feld, also hast Du am Ende 10× das *selbe* Feld. Der Indexzugriff oder `append()` entscheidet nicht einfach nicht das Objekt selbst sondern eine Kopie zu liefern oder anzuhängen, und dazu noch eine Tiefe Kopie, nur weil Du das an der Stelle praktisch finden würdest. Wenn Du eine Kopie willst, dann musst *Du* eine Kopie erstellen.
Da ist einiges was man so in Python nicht machen würde.
Zuerst einmal bekommen Funktionen und Methoden alles was sie ausser Konstanten benötigen als Argument(e) und greifen nicht auf irgendwelche globalen Variablen aus der Umgebung zu. `bearbeite_feld()` braucht also `ldf` und `ldz` als Argumente. Das sind übrigens verdammt schlechte Namen. Namen sollen dem Leser vermitteln was der Wert dahinter bedeutet.
Die Schleife über Indexwerte die bei 1 anfangen, und dann in der Funktion mit -1 wieder angepasst werden muss sollte gleich über die richtigen Werte laufen. Wobei das eigentlich gar nicht wirklich nötig ist, denn was Du da ja anscheinend machen willst ist immer auf das letzte Element von `ldf` zugerifen. Das geht mit dem Index -1, da braucht man kein `n` für.
Dann ist das herauslöschen des ersten Elements aus einer Liste in einer Funktion die diese Liste als Argument übergeben bekommt, absolut überraschend und komisch und schräg und ineffizient. Zudem muss das `range()` für die Schleife zur Länge von `ldz` passen. Fehleranfällig ist das neben der Undursichtigkeit auch noch. Was man hier eigentlich will ist eine Schleife über `ldz` und nicht ganz `ldz` an `bearbeite_feld()` übergeben, sondern immer nur das aktuelle Element von `ldz`, beziehungsweise beim iterieren über `ldz` schon die einzelnen Werte an Namen binden. Und dann sehe ich für das bisschen was da übrig bleibt auch keine Funktion mehr die *einen* Schritt der Schleife ausführt. Oder zumindest nicht in dieser Form.
Indexzugriffe in Schleifen sind in idiomatischem Python selten, weil man direkt über die Elemente von Sequenzen iterieren kann, ohne den Umweg über einen Index. Falls man *zusätzlich* eine laufende Zahl benötigt, gibt es die `enumerate()`-Funktion. Bei den beiden letzten Schleifen sind zudem wieder ”magische” Zahlen für die `range()`-Funktion die nur solange korrekt sind, solange man nichts an den Längen der betroffenen Listen ändern möchte.
Zeichenketten und Werte mit ``+`` und `str()` zusammenstückeln ist eher BASIC als Python. Python kennt dafür Zeichenkettenformatierung mit der `format()`-Methode auf Zeichenketten und ab Python 3.6 f-Zeichenkettenliterale.
Zwischenstand:
Code: Alles auswählen
#!/usr/bin/env python3
from copy import deepcopy
def main():
ldz = [
(0, 0, 1),
(4, 2, 2),
(1, 1, 3),
(1, 0, 4),
(2, 3, 5),
(3, 2, 6),
(0, 3, 7),
(4, 4, 8),
(2, 4, 9),
]
ldf = [
[
[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],
]
]
for x, y, z in ldz:
feld = deepcopy(ldf[-1])
feld[x][y] = z
ldf.append(feld)
for i, feld in enumerate(ldf):
print()
print(f"Feld_{i}:")
for row in feld:
print(row)
if __name__ == "__main__":
main()
