Namensräume sind doch beispielsweise innerhalb einer Klasse. Also die Namen die ich den Variablen innerhalb einer Klasse gebe, haben auf das restliche Programm keinen Einfluss. Also ich kann den Variablen innerhalb der verschiedenen Klassen immer die gleichen Namen geben, obwohl sie unterschiedliche Werte haben. Bei globalen Variablen geht das aber ja nicht. Ich habe z.B. jetzt je 22 Eingabefelder für X und Y - Koordinaten. Also 44 Eingabefelder. Die muss ich ja irgendwie benennen. Also bspw. HP_X_1 für H-Punkt_X-Koordinate_Nummer1. Die GUI habe ich jetzt einfach so runtergeschrieben. Wahrscheinlich wäre es besser, wenn ich die GUI auch in einer Klasse definiere und dann in der main Funktion erstelle? Aber dann habe ich ja das selbe Problem. Oder sollte ich die GUI auf mehrere Klassen aufteilen?__blackjack__ hat geschrieben: ↑Dienstag 24. Juli 2018, 14:33 @Marvin75854: Zu lang sollten Namen auch nicht werden. Ich hoffe da einfach mal das die so lang sind weil Du Namenspräfixe als ”Namensräume” verwendest. Was man eigentlich nicht machen muss weil Python ja Objekte hat, die Namensräume darstellen.
Richtig Methoden. Ich kenne ehrlich gesagt den Unterschied nicht genau. Ich dachte Methoden wären einfach nur Funktionen einer Klasse.__blackjack__ hat geschrieben: ↑Dienstag 24. Juli 2018, 14:33 Deine Klassen klingen immer noch nicht so wirklich überzeugend. Weil Du beispielsweise von Funktionen sprichst und nicht von Methoden. Irgendetwas muss diese Funktionen doch mit dem Objekt verbinden das durch die Klasse modelliert wird. Damit es eben nicht einfach nur Funktionen sind. Wird denn das `self`-Argument für irgend etwas anderes verwendet als andere Funktionen auf dem Objekt aufzurufen? Und haben die Unterklassen wirklich nur eine Methode? Verwendet die `self` sinnvoll? Falls nicht wären das ja eigentlich auch nur drei Funktionen von denen man der Basisklasse eine als Argument hätte mitgeben können.
Also meine Klassen sehen so aus:
Innerhalb einer If-Funktion und an anderen Stellen erstelle ich dann ein Objekt einer bestimmten Klasse und rufe einige Methoden auf.class Dummy(object):
def COG_ausgabe(self, i, SR):
if i == 1:
VM_Label = Label (SR, text=round(self.HX_neu,2)).grid(row=20, column=17)
......
def __init__(self, HX, HZ, TW,y,w):
self.HX = float(HX)
self.HZ = float(HZ)
self.TW = float(TW)
self.y = float(y)
self.w = float(w)
def COG_nach_Crash(self):
self.y_neu = (90 - self.w) * ((2*math.pi)/360)
.....
def write(self,i, L):
f = open(GUI.filename,"a")
.........
class EuroSID_2_RE(Dummy):
def calc(self):
dTW = self.TW - 19
.....
pass
Und diese Funktion wiederum wird in einer anderen Funktion mehrfach mit unterschiedlichen Koordinaten, die eben auf der GUI eingegeben werden, durch einen Button aufgerufen. Die Namen der Variablen die der Funktion oder den Klassen übergeben werden, habe ich hier noch nicht geändert. Ich probiere viel rum und tipper da einfach immer irgendwas rein.def COG_1SR_Export(L,D,a,b,c,d,i,y,w):
if a == 1:
if L == "Barriere - FMVSS 214 / CMVSS 214" or L == "Barriere - UR R95" or ...........
try:
....
x = EuroSID_2_RE(HX,HZ,d,y,W)
x.calc()
x.COG_nach_Crash()
x.write(i, L)
....
Der Code ist wahrscheinlich ein noch größerer Pfusch, als sowieso schon erwartet. Aber ich hab halt wirklich keine Ahnung was ich hier eigentlich tue und solange es funktioniert, mache ich einfach immer weiter...
Dumme frage noch: Wie kann ich denn Teile des Codes einrücken? Leerzeichen werden ja nicht übernommen.
Dann sind das keine Docstings. Habe das Wort vorhin das erste mal gelesen und einfach bei google geguckt was das ist. Habe die Erklärung wohl falsch verstanden. Ich habe mir einfach überall sowas eingefügt:__blackjack__ hat geschrieben: ↑Dienstag 24. Juli 2018, 14:33 Wenn man Kommentare die eigentlich Docstring-Material enthalten leicht zu Docstrings machen kann, dann sollte man das machen. Nur noch mal zur Sicherheit: Eine literale Zeichenkette ist nur an bestimmten Stellen ein Docstring. Also normalerweise nur am Modulanfang und direkt nach ``class`` und ``def``. Einige Werkzeuge, wie Sphinx, behandeln Zeichenketten direkt *unter* Zuweisungen auch als Docstring. Irgendwo mitten im Code sind es keine Docstrings.
Docstrings bekommt man in der Python-Shell bei `help()` angezeigt, oder auch in IPython und Jupyter-Notebooks, und IDEs können die in der Regel auch (auf Wunsch) als Tooltips o.ä. anzeigen. Und man kann die mit der `autodoc`-Erweiterung mit Sphinx aus dem Quelltext direkt in die generierte Dokumentation übernehmen.
Wird wahrscheinlich kein Programmierer so machen. Ich finds aber ganz übersichtlich.##################################################
#
#
#
#
# COG Berechnung Funktion
#
#
#
#
##################################################
Es ist halt teilweise so, dass ein Eingabefeld für mehrere Funktionen verwendet wird und durch verschiedene Buttons aufgerufen wird, also an verschiedenen Stellen des Programms genutzt wird.__blackjack__ hat geschrieben: ↑Dienstag 24. Juli 2018, 14:33 Von wo willst Du denn überall auf die `get()`-Methode von Eingabeelementen zugreifen? Es ist ja üblicherweise so, dass man eine Schaltfläche drückt oder irgendwie anders eine Berechnung anstösst. Und die Behandlung dafür sammelt dann alle Werte ein und ruft damit dann irgendwas von der Programmlogik auf.
Ich habe die GUI wie gesagt ja nicht in einer Klasse definiert, sondern einfach alles so runtergeschrieben. Ich verstehe teilweise immer noch nicht was genau mir die Klassen für einen Vorteil bringen.Das kommt hoffentlich noch, wenn ich das ein bisschen mehr anwende.__blackjack__ hat geschrieben: ↑Dienstag 24. Juli 2018, 14:33 Eventuell kann es sein das man innerhalb der GUI noch einmal Unterteilungen in eigene Widgetklassen hat, aber da braucht man ja auch keine globalen Werte, denn Widgets die solche Widgets enthalten, kennen/merken sich diese enthaltenen Widgets ja in der Klasse die sie beschreibt.
Mein Plan ist da jetzt erstmal das Programm so wie es ist fertig zu schreiben und wenn alles funktioniert, kann ich die einzelnen Funktionen und GUI Elemente ja auch noch in Klassen definieren und auf verschiedene Module aufteilen. Also nochmal ein neues Programm schreiben, nur eben in Klassen und verschiedenen Modulen. Müsste dann ja zum großteil nur copy & paste mit kleinen Anpassungen sein oder ist das das falsche vorgehen?
Ich habe halt diese ganzen Hello World und Taschenrechner Programme irgendwie alle übersprungen und bin direkt mit meinem etwas komplexeren Programm eingestiegen ohne das Programmieren überhaupt richtig verstanden zu haben. Denke ich habe schon viel gelernt und es funktioniert ja auch, sieht aber jetzt halt alles andere als professionell aus.