GRID/Map mit Attributen füllen (numpy)

[pystarter02]

Hallo :_)

Ich bin neu hier im Forum und ebenfalls neu auf dem Gebiet der Python Programmiersprache

#### FRAGE ####

Hat jemand eine Idee , wie ich einer mit numpy erstellten GRID bestimmte Werte(Positionen Winkel ,Geschwindigkeit zuweisen könnte


#### GRUND ####

: Geometrische Berechnung ist wesentlich einfacher als mit Listen & schnellere Berechnung


Die GRID ist z.B 400x800 Meter groß


#### AKTUELLE LÖSUNG #MIT LISTEN[]#####

Momentan habe ich es so gelöst ,das ich die einzelnen Zell-Werte der GRID in eine Liste in einer For Loop anhänge

Code: Alles auswählen

class gridwelt_objekte():    # GRIDWELT Positionen werden später in die gridliste geschrieben)
    def __init__(self,posx,posz):
        self.pos = [posx,posz]

gridliste=[] # Leere Liste erstellen

 for x in range (401):    #(Gehe über alle Punkte der 400x800 Grid)
     for y in range(801):


            temp = gridwelt_objekte(x,y) # 'schreibt für alle 400x800 Felder die Attribute in die GRID
            gridliste.append(temp)         # fügt die einzelnen temporär erstellten Koordinaten zu einer Liste zusammen

###Weitere Hinweise #### VORSCHLAG ? ##########

--- Versuch mit numpy array ----

Code: Alles auswählen

GRIDWorld = np.zeros([x, y]) # erstellt eine Grid mit der Dimension x,y und füllt diese mit 0 (Null)

Wie könnte man hier eine Zuweisung der GRID Positionen hinbekommen ? ( Die Werte müssen später berechnet werden und dann an ein Neuronales Netz weitergegeben werden)



BIN FÜR JEDE HILFE DANKBAR !

[MagBen]

Damit könntest Du anfangen: http://cs231n.github.io/python-numpy-tutorial/

[pystarter02]

Danke MagBen ! ich schau mal rein...

Das Tutorial ist ziemlich ausführlich und sehr hilfreich , hab aber den ersten Blick keinen indirekten Ansatz gefunden wie ich das Zuweisen der Klassenobjekte berwerkstelligen soll.


übrigens , hast ne super Webseite

[BlackJack]

@pystarter02: Objekte in einem Numpy-Array zu speichern macht in der Regel auch nicht viel Sinn. Diese Arrays spielen ihre Vorteile hauptsächlich bei numerischen Typen aus.

Zum gezeigten Quelltext: Warum eine flache Liste mit Objekten die ihre Koordinaten kennen statt einer 2D-Listenstruktur wo die Koordinaten durch die Indexzugriffe ja schon festgelegt sind?

Unter anderen zur Namensschreibweise von Klassen lohnt sich auch ein Blick in den Style Guide for Python Code. Der Name der Klasse ist auch inhaltlich komisch. Die beschreibt ja nur *ein* Objekt, also ist `*_objekte` in Mehrzahl irreführend. Der Namenszusatz ist aber sowieso überflüssig denn in Python ist *alles* ein Objekt was man an einen Namen binden kann. `Zelle` oder `Position` oder so währe als Name für die Klasse wahrscheinlich besser. Und gute Namen sind *wichtig*. Das unterschätzen viele Anfänger gerne und denken die Namen kann man später ja noch anpassen. Wenn man dann endlich mal dazu kommt, dann hat man Probleme den eigenen Quelltext wieder zu verstehen und wünscht sich der hätte bessere Namen.

So etwas wie `liste` sollte in Namen nicht vorkommen. Es ist wichtig einen Namen zu finden der die *Bedeutung* des Wertes wiederspiegelt und nicht dessen konkreten Typ. Typen können sich ändern während man Entwickelt und dann hat man entweder falsche, irreführende Namen, oder man muss alle Namen im Programm ändern die sich auf den Wert beziehen. Beides kann zu Fehlern und damit Mehraufwand führen.

Kommentare die nur das beschreiben was im Code schon offensichtlich da steht wie ``# Leere Liste erstellen`` sind überflüssig. Die bringen dem Leser keinen Mehrwert, das sollten Kommentare aber. Im Idealfall ist der Code so geschrieben und die Namen so gewählt, das der Leser daran erkennen kann was da passiert. Kommentare sind eher dazu da zu erklären *warum* das so gemacht wird wie es im Code steht, sofern das nicht sowieso klar sein sollte. Man muss auch immer aufpassen das die Kommentare zum Code passen, wenn man den also anpasst/ändert, muss danach auch der Kommentar noch stimmen oder auch angepasst werden. Bei dem ``# Leere Liste erstellen`` wäre es zum Beispiel doof wenn man aus der Liste ein `set` macht, aber im Kommentar weiterhin von einer Liste die Rede ist. Der Leser weiss dann erst einmal nicht ob der Code falsch ist oder der Kommentar.

Man muss nicht jedes Zwischenergebnis an einen Namen binden. Manchmal hilft es beim Verständnis einem Zwischenergebnis einen guten Namen zu geben, der Informationen für den Leser enthält, aber `temp` macht hier absolut keinen Sinn.

[pystarter02]

Also in erster Linie Danke für die Mühe BlackJack

Um ganz ehrlich zu sein , ich bin kein ordentlicher Coder. Versuche es aber immer ein wenig zu verbessern. Habe auch sonst nicht viel mit dem Coden zu tun gehabt.
Mein Coding-Style ist sicherlich nicht Barrierefrei und die Kommentare habe ich hinzugefügt ,damit sich derjenige schneller einlesen kann an welchem Schritt er angelangt ist.
ES IST ALLES EINE FRAGE WIE ORDENTLICH MAN VORGEHT UND DA GEHÖRE ICH EHER ZU DEN CHAOTISCHEN CODERN

zur Problemstellung


-ein Objekt bewegt sich durch eine Grid hinweg
-Dazu besitze ich die Koordinaten zu jedem Zeitschritt (Positionen,Winkel usw.)
-nach jedem Schritt müssen die relativen Koordinaten (Position,Geschwindigkeit,Winkel usw.) zu jeder Position in meiner GRID (Weltkoordinatensystem) berechnet werden
-Diese berechneten Koordinaten müssen später weiterverarbeitet werden

GRUNDLEGENDES PROBLEM :

EIN EFFEKTIVES ARRAY ZU ERZEUGEN IN WELCHES ICH DIESE BERECHNETEN WERTE ZUWEISEN/BERECHNEN KANN

Wie kriege ich es also hin, einer Position x,y in meiner Grid die Attribute(Position,Winkel,Geschwindigkeit) zuzuweisen ?

Gerne auch andere Vorschläge erwünscht

[kbr]

Wie kriege ich es also hin, einer Position x,y in meiner Grid die Attribute(Position,Winkel,Geschwindigkeit) zuzuweisen ?

Anbei ein einfaches Beispiel für ein Grid von Objekten, die ihre eigene Position kennen. Lässt sich erweitern. Vielleicht ist es für Deine Zwecke sogar effizient genug.

Code: Alles auswählen

In [1]: class GridworldItem:
   ...:     def __init__(self, x, y):
   ...:         self.x = x
   ...:         self.y = y
   ...:     def __str__(self):
   ...:         return 'x: {}, y: {}'.format(self.x, self.y)
   ...:     

In [3]: grid = [[GridworldItem(x, y) for x in range(800)] for y in range(400)]

In [4]: len(grid)
Out[4]: 400

In [5]: len(grid[0])
Out[5]: 800

In [6]: print(grid[200][400])
x: 400, y: 200

[MagBen]

übrigens , hast ne super Webseite

Danke, mit YAML und php realisiert.

hab aber den ersten Blick keinen indirekten Ansatz gefunden wie ich das Zuweisen der Klassenobjekte berwerkstelligen soll.

Das Tutorial gibt Python-Anfängern einen Schnellstart in Sachen Numpy-Arrays.

-ein Objekt bewegt sich durch eine Grid hinweg
-Dazu besitze ich die Koordinaten zu jedem Zeitschritt (Positionen,Winkel usw.)

Python Klasse, z.B. wie von kbr vorgeschlagen.

-nach jedem Schritt müssen die relativen Koordinaten (Position,Geschwindigkeit,Winkel usw.) zu jeder Position in meiner GRID (Weltkoordinatensystem) berechnet werden

Unbedingt Numpy-Arrays, mit Numpy-Arrays kann das ohne Python-Schleifen implementiert werden. D.h. der Code sieht aus wie die mathematische Formel und ist fast so performant wie eine C++ Implementation.

-Diese berechneten Koordinaten müssen später weiterverarbeitet werden

Wahrscheinlich mit Numpy-Arrays.

[snafu]

Um entsprechende Aussagen von MagBen nochmal zu unterstreichen: Falls Numpy-Arrays eingesetzt werden, dann muss es oberste Priorität sein, anstatt einer Python-Schleife eine äquivalente Numpy-Funktion einzusetzen. Das bedeutet zwar eine gewisse Einarbeitungszeit in Numpy, jedoch können Numpy-Arrays nur auf diesem Wege effizient verarbeitet werden. Denn es ist für Numpy nicht möglich, Python-Schleifen auf magische Weise von selbst zu beschleunigen.

[pystarter02]

kbr !! danke !

@MagBen danke nochmals!

Ich denke auch das es mit numpy effektiver ist für diese Problemstellung

Ich hab immer noch keine Idee wie ich das mit numpy machen soll. Mal schauen ..vielleicht findet sich was aus den hier genannten Vorschlägen und Tipps !

[pystarter02]

okay das werd ich mir merken !! danke snafu

[BlackJack]

@pystarter02: Das wird wahrscheinlich auch auf die Frage hinauslaufen wie Du die Daten organisierst. Du scheinst ja gerade zu versuchen ein Objekt für jeden Punkt zu erstellen mit Zahlwerten für Position, Geschwindigkeit, Winkel und diese Einzelobjekte dann in ein Array zu stecken. Wenn Du aber mit Numpy effizient arbeiten willst, dann würde man wahrscheinlich eher ein Objekt für die Gridwelt erstellen mit einem Array für alle Positionen, einem für alle Geschwindigkeiten, und einem für Winkel. Denn nur so kann man mit Numpy dann Berechnungen mit allen Werten einer Kategorie „auf einen Schlag“ anstellen.

[kbr]

@pystarter02: Auch wenn es alle schon gesagt haben, nur ich noch nicht: Versuche bei sehr vielen zu erwartenden Rechenoperationen möglichst effizient numpy einzusetzen und die Datenstrukturen daran auszurichten. Es ist besser mit einer komplizierten Datenstruktur schnell zu arbeiten, als mit einer einfachen Datenstruktur langsam. Ob Dein Programm einmal 2 oder 20 Sekunden Laufzeit braucht ist egal, aber bei häufigem Einsatz und irgendwann kummulierten 2 oder 20 Stunden sieht das schon anders aus.

[pystarter02]

@ kbr : ja die Laufzeit ist wie du sagst tausendmal schneller

@ BlackJack Ja das ist auch ne gute idee!! Danke