kleines Rechenprogramm

[numerix]

ja das stimmt wohl, ich begreife das einfach nicht. Hab zwar noch ein schönes Beispiel vorliegen, aber ich steige nicht hinter den Sinn und die Funktion des Ganzen

Nicht aufgeben! Das wird! Wenn man jahrelang rein prozedural/imperativ/linear programmiert hat und diese Art des Denkens verinnerlicht hat, dann kann das eine mühsame Angelegenheit sein. Jedenfalls, wenn man keinen hat, der es einem didaktisch vernünftig erklärt oder ein entsprechend gutes Buch dazu gefunden hat ...

[mathi]

Das Forum hier ist leider meine einzige Anlaufstelle

[BlackJack]

@mathi: Nicht ganz; es gibt auch noch das Wiki. Schau Dir mal die Liste deutschsprachiger (Online-)Literatur in der FAQ an: [wiki]FAQ#DeutschsprachigeLektrenImNetz[/wiki]

Der Text von Alan Gould zum Beispiel. Da gibt's unter fortgeschrittene Themen OOP, ereignisbasierte Programmierung, und GUI-Programmierung.

Das englische Original habe ich jedenfalls in ganz guter Erinnerung als Einsteigerlektüre.

[kaytec]

Hallo mathi !

Evt. hilft dir das:

http://paste.pocoo.org/show/89294/

Ich hoffe meine Namensgebungen entsprechen hoeherer Mathematik .

gruss frank

[yipyip]

Hallo mathi,
ich weiss, dass dieses Thema ein harter Brocken ist,
den man als Einsteiger ziemlich lange verdauen muss.

Ich persönlich bin hier immer an
Snippets interssiert, die über meinem Niveau liegen,
denn nur so lernt man etwas dazu.

Deshalb war ich auch so wagemutig, Dir
mein Verständnis vom sogenannten "Model View Controller Pattern"
zu zeigen, in der Hoffnung, dass Du (nach einiger Zeit)
etwas damit anfangen kannst.

Es geht dabei darum, ein GUI-Programm in möglichst unabhängige
Komponenten aufzuteilen, um einerseits dessen Komplexität bewältigen
zu können und andererseits einen ereignisgesteuerten
Ablauf zu ermöglichen.

Wie die Namen schon sagen:
Der "View" ist fuer die Ausgabe und das Warten auf
Ereignisse(Events) zuständig.
Im "Model" werden die eigentlichen Daten verarbeitet.
Im "Controller" laufen alle Fäden zusammen.

Der View meldet die eingetretenen Ereignisse an den
Controller. Der Controller nimmt die Daten vom View entgegen und
ruft Methoden des Models auf.
Das Model weiss gar nichts von den anderen Komponenten,
es ist nur für die Berechnungen zuständig.
Der Controller sorgt bei einem Event dafür, das der
View mit den Daten des Models aktualisiert wird.
(...bitte jetzt nicht frustriert in die Tischkante beissen...)
Keine Sorge, bald werden die ersten Aha-Momente kommen.


Fange am besten erstmal mit den Links von
Blackjack an, alles weitere ergibt sich dann.


yipyip

[mathi]

Hallo mathi,
ich weiss, dass dieses Thema ein harter Brocken ist,...

Deshalb war ich auch so wagemutig, Dir
mein Verständnis vom sogenannten "Model View Controller Pattern"
zu zeigen, in der Hoffnung, dass Du (nach einiger Zeit)
etwas damit anfangen kannst.
yipyip

Hallo yipyip, auf dein Programm spielte ich an, es wird eine Weile dauern bis ich da durch steige. Vielen Dank für erklärung, damit bringst Du dämmerung ins Schwarz

Hallo mathi !

Evt. hilft dir das:

Hallo kaytec, ich bin begeistert , das ist die Funktionalität, die ich mir vorgestellt habe.

@all:
Mensch, ich muß schon sagen, solch eine Gemeinschaft ist wirklich genial.
Die nächste Zeit habe ich sicher einiges vor mir .... und freue mich drauf.

[abgdf]

@yipyip

"Model View Controller Pattern"

Hey, danke dafür!
Hab' schon lange einen Weg gesucht, GUI und "Engine" sauber zu trennen. So könnte auch das endlich klappen!

Viele Grüße

[Leonidas]

Hab' schon lange einen Weg gesucht, GUI und "Engine" sauber zu trennen. So könnte auch das endlich klappen!

pygtkmvc könnte für dich dann interessant sein; wenn ich Lunars Talk richtig in Erinnerung habe, bietet Qt da auch etwas von Haus aus an.

[kaytec]

Hallo mathi !

Ich bin froh, wenn ich dir helfen konnte. Diese fachlichen Diskussionen sind sehr hilfreich, doch oft verstehe ich nur einen Bruchteil davon.

wer, wie, was - wer nicht postet der bleibt dumm .

gruss frank

[abgdf]

Hallo mathi,

ich hab' Deinen eigenen Code von oben nochmal so umgeformt, daß er objektorientiert und Tkinter-mäßig etwas mehr Sinn ergibt. Ist für Dich zum Vergleichen und Lernen, die Programmfunktion ist nicht implementiert (wie in Deinem Code ja auch nicht). Das hatte kaytec ja auch schon gemacht.

Code: Alles auswählen

#!/usr/bin/env python
#-*- coding: iso-8859-1 -*-

import Tkinter
import Tkconstants 

class Main:
      
    def __init__(self):

        self.root = Tkinter.Tk()
        self.root.title("Bemessung")

        self.menuobj = Tkinter.Menu(self.root)
        self.root.config(menu = self.menuobj)
        self.progmenu = Tkinter.Menu(self.menuobj)

        self.menuobj.add_cascade(label = "Programm", menu = self.progmenu)
        self.progmenu.add_command(label = "Interpolation", command = self.interpolation)
        self.progmenu.add_separator()

        self.textfenster = Tkinter.Text(self.root)
        self.textfenster.pack()

        self.labeltext = Tkinter.Label(self.root, text = "Programmhinweise")
        self.labeltext.pack()

        self.lab=Tkinter.Label(self.root, text = '   ')
        self.lab.pack(side = Tkconstants.LEFT)
       
        self.eingabe = Tkinter.Entry(self.root, width = 60)
        self.eingabe.pack(side = Tkconstants.LEFT)
        self.eingabe.bind("<Return>", self.Ok)
        self.eingabe.focus()

        self.but = Tkinter.Button(self.root,
                                  text = "Ok",
                                  command = self.Ok)
        self.but.pack(side = Tkconstants.LEFT)     

        self.root.mainloop()

    def Ok(self, *events):

        xGet = self.eingabe.get()
        self.textfenster.insert(Tkconstants.END, xGet)
 
    def interpolation(self):

        self.textfenster.insert(Tkconstants.END, "\ngegeben: x | gesucht: y ")
        self.eingabe.focus()
        self.labeltext.config(text = "Gib den Wert ein")
        self.lab.config(text = "Wert X1 mit X1 < x: ")

myapp = Main()

HTH

@Leonidas: Auch Dir danke für den Link!

Viele Grüße

[mathi]

@ abgdf
Vielen Dank

@kaytec

ich habe auf der Grundlage Deines Codes mal versucht, einfach mal meine "Iteration" auszuprobieren:

Code: Alles auswählen

class Interpolation(object):
    
        
    def __init__(self):
        self.variablen = {"X1" : 0, "X2" : 0,"Y1" : 0, "Y2" : 0,"x" : 0}
        
    def __iter__(self):
        return iter(self.variablen.items())
        
    def __len__(self):
        return len(self.variablen)
        
    def set_variablen(self, key, value):
        self.variablen[key] = value
        
    def evaluate(self):
        x=self.variablen["x"]
        Y2=self.variablen["Y2"]
        X1=self.variablen["X1"]
        Y1=self.variablen["Y1"]
        X2=self.variablen["X2"]
        
        y=(x-X1)*(Y2-Y1)/(X2-X1)+Y1
        return y

bis auf eine ungeordnete Abfrage der einzelnen Variablen funktioniert es zumindest erst einmal.

jetzt meine Fragen:
1.) warum würfelt __iter__ alles durcheinander?:

Code: Alles auswählen

IDLE 2.6      
>>> variablen = {"X1" : 0, "X2" : 0,"Y1" : 0, "Y2" : 0,"x" : 0}
>>> variablen.items()
[('X2', 0), ('Y1', 0), ('X1', 0), ('x', 0), ('Y2', 0)]
>>> 

2.) an welcher Stelle werden __iter__ und __len__ verarbeitet?
dort werden zwar Werte zurückgegeben: len(self.variablen) ergibt 5
aber ich verstehe nicht wo die Werte gebraucht werden, da sie keiner variablen oder Funktion zugeordnet scheinen.

[Leonidas]

1.) warum würfelt __iter__ alles durcheinander?:

Weil ``self.variablen.items()`` die Items ungeordnet ausgibt, weil ``self.variablen`` ein Dict ist und dies per Definition ungeordnet ist.

[wuf]

Hallo mathi

Antwort zu deiner 2. Frage. So wie ich es gecheckt habe:

Code: Alles auswählen

# Skriptname kleines_rechenprogramm_01_01.py (wuf)

class Interpolation(object):


    def __init__(self):
        self.variablen = {"X1" : 0, "X2" : 0,"Y1" : 0, "Y2" : 0,"x" : 0}

    def __iter__(self):
        return iter(self.variablen.items())

    def __len__(self):
        return len(self.variablen)

    def set_variablen(self, key, value):
        self.variablen[key] = value

    def evaluate(self):
        x=self.variablen["x"]
        Y2=self.variablen["Y2"]
        X1=self.variablen["X1"]
        Y1=self.variablen["Y1"]
        X2=self.variablen["X2"]

        y=(x-X1)*(Y2-Y1)/(X2-X1)+Y1
        return y

#`~~ Instanz der Klasse Interpolation
interpolation = Interpolation()

print
print "Instanz =", interpolation
print

#~~ 1. Variante: Iteration ueber das Klassen-Attribut 'variablen'
for variable in interpolation.variablen.iteritems():
    print "1.", variable
print

#~~ 2. Variante: Iteration ueber das Klassen-Attribut 'variablen'
#      Die def __iter__ befaehigt, dass die Instanz 'interpolation'
#      der Klasse 'Interpolation' iterierbar wird
for variable in interpolation:
    print "2.",variable
print

#~~ 1. Variante: Ermittlung der Anzahl Elemente im Attribut 'variablen'
#
print "1. Anzahl Elemente im Dictionary 'variable'", len(interpolation.variablen)
print

#~~ 2. Variante: Ermittlung der Anzahl Elemente im Attribut 'variablen'
#      Die def __len__ ermoeglicht es die Instanz 'interpolation' der
#      Klasse direkt auf die Anzahl Elemente im Attribut (Dictionary)
#      'variablen' zu ermitteln
print "2. Anzahl Elemente im Dictionary 'variable'", len(interpolation)
print

Näheres siehe Kommentar im Code-Snippet.

Gruss wuf

[kaytec]

Hallo mathi !

Versuche mal das:

Code: Alles auswählen

for variablen in sorted(self.operation):
            self.variablen.append(variablen[0])

gruss frank

[Konrad Wenzel]

Die Standardfunktion eval() würde ich in Verbindung mit tk.Entry() verwenden,
<kann z.B. x*x +2*x direkt auswerten> um den Dialog zu straffen

[numerix]

Die Standardfunktion eval() würde ich in Verbindung mit tk.Entry() verwenden,
<kann z.B. x*x +2*x direkt auswerten> um den Dialog zu straffen

Wenn man der alleinige Anwender ist und weiß, was man tut: Ja.
Ansonsten sollte man eval() eher mit Vorsicht genießen, weil dadurch ggf. auch nicht gewollter Python-Code ausgeführt wird.

[mathi]

Die Numpad-Eingabe und Anzeige aller Eingabefelder schliessen sich ja nicht gegenseitig aus. Du kannst die Eingabetaste ja an die `Entry`-Exemplare binden und mit "gehe zum nächsten `Entry`" belegen.

Wenn da 16 einzelne Berechnungsprogramme unter einer GUI zusammen gefasst werden sollen, spricht das übrigens auch für OOP.

Hallo, ich habe mich entschlossen Deinem Rat zu folgen und genau das zu tun.

Habe mich die letzten Tage mit der erstellung der Masken beschäftigt.
Da ich mit wxPython arbeiten möchte, denke ich ein neuer Thread im entspr. Forum wäre angebracht.

http://www.python-forum.de/viewtopic.ph ... 115067[url]
[/url]