vom Benutzer erstellte Instanzen und wie man damit umgeht ??

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
ippurk
User
Beiträge: 61
Registriert: Mittwoch 8. Juli 2009, 20:40

Hallo Realitätsflüchtlinge,

ich beschäftige mich seit einiger weniger Zeit mit objektorientierter Programmierung und habe da, denke ich, ein grundlegendes Verständnisproblem, welches nach wochenlanger Googlerecherche leider nicht geklärt werden konnte:

Nehmen wir das Beispiel eines Bankkontoprogrammes:

Der Programmbenutzer soll Bankkonten erstellen können, auf die Geld eingezahlt und ausgezahlt werden kann und deren Kontostand man sich anzeigen lassen kann.

Nun will ich natürlich nicht, dass der Nutzer sich mit komplizierten Befehlen herumschlagen muss wie z.B. konto1 = Bankkonto(Startbetrag), was in diesem Fall bei mir eine Instanz der Klasse Bankkonto erstellen würde. Also gibt's eine Eingabemaske per tkinter, wo abgefragt wird, wie das neue Konto heißen soll. Und dann wirds angelegt.

Für alle anderen Funktionen wie einzahlen auszahlen etc gibts natürlich auch ein eigenes Fenster.

Wie muss ich dieses Problem grundsätzlich angehen ?
Kann mir das jemand mal in muttersprachlichen Ausdrücken nahebringen ?

Bin übrigens kein Informatikstudent, der seine Hausaufgabe nicht lösen kann. Ist alles nur Hobby bei mir und ich freu mich schon darauf, meinen Code von euch zerissen zu sehen.

Vielen Dank für eure Mühe im voraus.

Falls es jemanden interessiert, ist hier auch der code, mit dem ich zur Zeit herumprobiere:

Code: Alles auswählen

from tkinter import *
import sys

class Bankkonto:

    def __init__(self, startbetrag):
        self.kontostand = startbetrag

    def einzahlung(self, betrag):
        betrag = float(betrag)
        self.kontostand = self.kontostand + betrag

    def auszahlung(self, betrag):
        betrag = float(betrag)
        self.kontostand = self.kontostand - betrag
        
    def anzeigen(self):
        print (self.kontostand)

    def ueberweise(self, betrag, zielkonto):
        betrag = float(betrag)
        zielkonto.kontostand = zielkonto.kontostand + betrag
        self.kontostand = self.kontostand - betrag

class createWidgets:

    def __init__(self):
        self.hauptfenster = Tk()
        self.hauptfenster.title("Kontomanager")
        Label(self.hauptfenster, text="Hallo", anchor="n").grid(row = 0)
        Button(self.hauptfenster, command=self.einzahlen,
               text="einzahlen").grid(row = 1)
        Button(self.hauptfenster, command=self.kontostandfenster,
               text="Kontostand anzeigen").grid(row=2)
        Button(self.hauptfenster, command=self.kontomachen,
               text="Konto machen").grid(row=3)
        self.hauptfenster.mainloop()

    def einzahlen(self):
        einzahlung01 = Abfragefuereinzahlung()

    def kontostandfenster(self):
        kontostand = Kontostand_abfragen()

    def kontomachen(self):
        machjetzt = Konto_erstellen()

class Abfragefuereinzahlung:

    def __init__(self):
        self.einzbetragentry = DoubleVar()
        self.kontonrentry = StringVar()
        self.fenster_einzahlung = Tk()
        self.fenster_einzahlung.title("Einzahlen")
        Label(self.fenster_einzahlung, text="wie viel ?",
              anchor="w").grid(row = 1)
        self.einzbetragentry = Entry(self.fenster_einzahlung, width=5)
        self.einzbetragentry.grid(row = 2)
        Label(self.fenster_einzahlung, text="auf welches Konto ?",
              anchor="w").grid(row = 3)
        self.kontonrentry = Entry(self.fenster_einzahlung, width = 5)
        self.kontonrentry.grid(row = 4)
        self.buttoneinzahlen = Button(self.fenster_einzahlung,
                                 command=self.einzahlenausmaske,
                                      text="einzahlen")
        self.buttoneinzahlen.grid(row = 5)
          
    def einzahlenausmaske(self):
            
        einzbetrag = self.einzbetragentry.get()
        einzkontonr = self.kontonrentry.get()
        einzbetrag = float(einzbetrag)
        einzkontonr = eval(einzkontonr) # das hier ist nur mal grad
                                        # dass es überhaupt funktioniert
        Bankkonto.einzahlung(einzkontonr, einzbetrag)
        self.fenster_einzahlung.destroy()

class Kontostand_abfragen:

    def __init__(self):
        self.kontostand_fenster = Tk()
        self.kontostand_fenster.title("Kontostand")
        Label(self.kontostand_fenster, text="welches Konto ?",
              anchor="w").grid(row = 1)
        self.kontonr_entry = Entry(self.kontostand_fenster, width=5)
        self.kontonr_entry.grid(row = 2)
        self.button_anzeigen = Button(self.kontostand_fenster,
                                 command=self.standabfragen, text="anzeigen")
        self.button_anzeigen.grid(row = 5)

    def standabfragen(self):
        kontonr = self.kontonr_entry.get()
        kontonr = eval(kontonr)     # das hier ist nur mal grad
                                    # dass es überhaupt funktioniert
        Bankkonto.anzeigen(kontonr)
        self.kontostand_fenster.destroy()

class Konto_erstellen:

    def __init__(self):
        self.konto_erstellen_fenster = Tk()
        self.konto_erstellen_fenster.title("Konto erstellen")
        Label(self.konto_erstellen_fenster, text="welcher Kontoname ?",
              anchor="w").grid(row = 1)
        self.kontonr_entry = Entry(self.konto_erstellen_fenster, width=5)
        self.kontonr_entry.grid(row = 2)
        self.button_anzeigen = Button(self.konto_erstellen_fenster,
                                 command=self.mache_Konto, text="mach jetzt")
        self.button_anzeigen.grid(row = 5)

    def mache_Konto(self):
        kontonr = self.kontonr_entry.get()

        #kontonr = Bankkonto(15)

        self.konto_erstellen_fenster.destroy()



    
konto1 = Bankkonto(50)
konto2 = Bankkonto(0)
konto1.einzahlung(50)
konto2.einzahlung(100)
konto2.einzahlung(3)



createWidgets()

ms4py
User
Beiträge: 1178
Registriert: Montag 19. Januar 2009, 09:37

Hier mal ein paar grobe Stichworte:
- längerer Code in Zukunft auslagern ( http://paste.pocoo.org/ oder http://pastebin.com/ )
- PEP8 beachten, vor allem bei Klassen- und Methodennamen ( http://www.python.org/dev/peps/pep-0008/ ), außerdem solltest du dir einig sein, entweder alles deutsch oder alles englisch
- imports mit * werden nicht gern gesehen, importiere nur das, was du auch wirklich benötigst
- die letzten 3 Klassen sollten von der Logik und vom Namen her eher Funktionen sein
- Kein Modul-Code, verwende statt dessen if __name__ == '__main__'
- Fast keine Kommentare, keine Doc-Strings

Noch zu deinen Fragen:
Im Ansatz hast du doch schon eine ganz passable Lösung. Als weiteres solltest du die angelegten Konten speichern (z.B. in einer list() ) und auswählbar machen, eventuell sogar persistent speichern(pickle).
Barabbas
User
Beiträge: 349
Registriert: Dienstag 4. März 2008, 14:47

Hey, ich bin kein Realitätsflüchtling - nur realitätsflüchtig ;)

Naja, tatsächlich ist bei so einem Entwurf immer die Frage, welche Einheiten man sinnvoll in Klassen gliedert. Ich glaube, in deinem Fall würde ich grundlegend Klassen für

* das Fenster und alles was mit der GUI zu tun hat,
* Kontos und
* Benutzer

erstellen. Mehr ist natürlich schwer zu sagen, da jetzt nicht ganz ersichtlich ist, was dein Konto-Prog genau machen soll. Wenn man damit jetzt beispielsweise das Bankenwesen simulieren wollte, würde man wahrscheinlich noch eine Klasse mit Banken haben, denen die Kontos zugeordnet sind.

Vielleicht kannst du deine Frage ja noch etwas konkretisieren - und natürlich die Tipps von ice2k3 beherzigen.

Gruß,

Daniel
ippurk
User
Beiträge: 61
Registriert: Mittwoch 8. Juli 2009, 20:40

at ice2k3: vielen Dank für deine schnellle Antwort !

Ich geb mir Mühe bezüglich der style-Vorgaben etc.

Zu deiner Antwort:

Die list Funktion ist mir auch schon öfters in diesem Zusammenhang begegnet, doch wie schaffe ich es, aus einem tkinter entry widget eine Instanz der Klasse Bankkonto zu erzeugen und diese dann eben in einer Liste abzulegen ? Meine hier gezeigte Methode (Zeile 115) funktioniert ja eher nicht.

at Barabbas:

Gehen wir mal davon aus, daß es nur einen Benutzer gibt, in diesem Fall jemanden, der eine Miet- und Nebenkostenabrechnung eines Mietshauses machen will und die Konten entsprechen sozusagen den einzelnen Mietern.

OK, also packe ich die letzten drei Classes als def in die Klasse Bankkonto, was für mich logisch auch irgendwie Sinn macht und erzeuge die Abfragefenster als def aus der createWidgets Klasse ? Bis auf die Konto_erstellen Klasse. Die kann ich doch nicht sozusagen in sich selbst legen, oder ? Also, daß ein def in einer Klasse eine Instanz eben dieser eigenen Klasse erzeugt, kommt mir komisch vor.

Und zur Realität: Die ist ja sowieso ein bißchen schwammig definiert...
Barabbas
User
Beiträge: 349
Registriert: Dienstag 4. März 2008, 14:47

Hm, naja, ich könnte mir so einen Aufbau vorstellen:

Code: Alles auswählen

class Konto:
    bezeichnung = ""
    geld = 0

    def __init__(self, name, betrag):
        self.bezeichnung = name
        self.geld = betrag

    def abheben(self, betrag):
        if self.geld -betrag < 0.0:
            return False
        else:
            self.geld -= betrag
            return True

    def einzahlen(self, betrag):
        self.geld += betrag

    
class Hausverwaltung:
    konten = {}
    
    def __init__(self):
        pass

    def konto_erstellen(self, name, betrag=0):
        self.konten[name] = Konto(name, betrag)

    def ueberweisen(self, von_konto, nach_konto, betrag):
        if von_konto.abheben(betrag):
            nach_konto.einzahlen(betrag):
        else:
            print("Nicht genug Kohle auf dem Konto")
        
class Fenster:
    def __init__(self):
        self.hausverwaltung = Hausverwaltung()
        ## was auch immer, Fenster initialisieren
        pass
    
    def konto_erstellen(self):
        ## Kontoname abfragen und entsprechendes Konto erstellen
        self.hausverwaltung.konto_erstellen("neues_konto", 377.70)

    def kontostand_anzeigen(self, konto):
        ## Geldbetrag für Konto anzeigen
        if konto in self.hausverwaltung.konten:
            print(self.hausverwaltung.konten[konto].geld)
        else:
            print("Das Konto '%s' gibbet nicht" % konto)

    def einzahlen(self, konto):
        ## Fenster öffnen und Geldbetrag abfragen
        if konto in self.hausverwaltung.konten:
            self.hausverwaltung.konten[konto].einzahlen(betrag)
        else:
            print("Das Konto '%s' gibbet nicht" % konto)
        
Ich bin selbst kein Profi - aber der Aufbau sollte soweit eigentlich ok sein.

Schönen Gruß,

dsn
Benutzeravatar
Hyperion
Moderator
Beiträge: 7478
Registriert: Freitag 4. August 2006, 14:56
Wohnort: Hamburg
Kontaktdaten:

@Barabbas:

Die Klasse Hausverwaltung ist imho keine. Du kapselst rudimentär ein dict und hast dann noch eine Methode, die man auch einfach als Funktion hätte realisieren können.

Bei der Klasse Konto könnte man mittels property das einzahlen und abbheben ersetzen

Klassen sollten als New-Style Klassen angelegt werden - also von object erben.
BlackJack

@ippurk: Bei den `Bankkonto`-Methoden sollten die Argumente schon im richtigen Format ankommen, d.h. wenn der Benutzer Zeichenketten eingibt, sollten die in Zahlen umgwandelt und überprüft werden, bevor sie das `Bankkonto` erreichen.

Man könnte noch prüfen ob das Konto gedeckt ist, oder zumindest der Dispokredit nicht überzogen wurde und ggf. mit einer Ausnahme reagieren. Dann sollte man beim Überweisen auch nicht direkt auf die Kontostände zugreifen, sondern die Methode über abheben und einzahlen ausdrücken. Auch in dieser Reihenfolge, denn wenn man nichts abheben kann, weil z.B. das Konto überzogen ist, dann darf man auf das Zielkonto natürlich auch nichts einzahlen.

@Hyperion: `einzahlen()` und `auszahlen()` sind Tätigkeiten und keine Eigenschaften und bei einem "echten" Konto machen die mehr als nur den Kontostand zu ändern. IMHO so viel, dass es Methoden bleiben sollten.

In Python 3.x gibt's nur noch new-style Klassen.
Zur Namensgebung: Klassen sollten "Gegenstände" beschreiben, und Funktionen und Methoden Tätigkeiten. Also z.B. `einzahlen()` statt `einzahlung()` für eine Methode, und nicht `createWidgets` für eine Klasse.

GUI und Geschäftslogik sollten auf jeden Fall getrennt bleiben. Also keinen GUI-Code in die `Konto`-Klasse stecken.

Wenn das halbwegs die Realität wiederspiegeln soll, müsste man übrigens einen Verlauf speichern und nicht nur den aktuellen Kontostand. Man möchte ja auch Kontoauszüge ausgeben können.

@Barabbas: Die Klassenattribute machen wenigh Sinn, das bei `Hausverwaltung` ist sogar "gefährlich" weil sich da alle Hausverwaltungen die selben Konten teilen.

Fehlerbehandlung über spezielle Rückgabewerte ist doof. Dafür wurden Ausnahmen erfunden. Die Überweisung gehört IMHO in den Verantwortungsbereich des Kontos, und das raussuchen von Kontos anhand von Namen in die Hausverwaltung und nicht in die GUI. Bei einer Zeile wie ``self.hausverwaltung.konten[konto].einzahlen(betrag)`` greift die GUI IMHO zu tief in die Interna durch. Mindestens das ``konten`` sollte daraus verschwinden.
Benutzeravatar
Hyperion
Moderator
Beiträge: 7478
Registriert: Freitag 4. August 2006, 14:56
Wohnort: Hamburg
Kontaktdaten:

BlackJack hat geschrieben: @Hyperion: `einzahlen()` und `auszahlen()` sind Tätigkeiten und keine Eigenschaften und bei einem "echten" Konto machen die mehr als nur den Kontostand zu ändern. IMHO so viel, dass es Methoden bleiben sollten.
Hm ... ok, sehe ich ein! (Wobei hier dann doch einiges an Funktionalität fehlt wie z.B. eine Historie was Du ja auch schon moniert hattest)
In Python 3.x gibt's nur noch new-style Klassen.
Oops. Man sollte sich doch angewöhnen auf die Art von print zu achten :-D Schade dass es keine py3 / py2 Unterscheidung bei Code-Snippets gibt.
Barabbas
User
Beiträge: 349
Registriert: Dienstag 4. März 2008, 14:47

BlackJack hat geschrieben: @Barabbas: Die Klassenattribute machen wenigh Sinn, das bei `Hausverwaltung` ist sogar "gefährlich" weil sich da alle Hausverwaltungen die selben Konten teilen.
Da hast du recht - wobei im konkreten Fall ja nur eine Hausverwaltung existieren soll - aber wohl wahr.
BlackJack hat geschrieben:Fehlerbehandlung über spezielle Rückgabewerte ist doof. Dafür wurden Ausnahmen erfunden.
Ja? Ich fand das immer recht cool aber beuge mich da natürlich gerne dem Sachverstand (was wahrscheinlich ironisch tönt aber nicht so gemeint ist)
BlackJack hat geschrieben:Die Überweisung gehört IMHO in den Verantwortungsbereich des Kontos, und das raussuchen von Kontos anhand von Namen in die Hausverwaltung und nicht in die GUI.

Jo, habe ich auch erst überlegt; aber irgendwie fand ich es auch komisch, dass ein Konto Zugriff auf ein anderes haben sollte. Aber bei der Hausverwaltung ist die Überweisung sicher auch falsch aufgehoben.
BlackJack hat geschrieben:Bei einer Zeile wie ``self.hausverwaltung.konten[konto].einzahlen(betrag)`` greift die GUI IMHO zu tief in die Interna durch. Mindestens das ``konten`` sollte daraus verschwinden.
Jap!
Hyperion hat geschrieben: Die Klasse Hausverwaltung ist imho keine. Du kapselst rudimentär ein dict und hast dann noch eine Methode, die man auch einfach als Funktion hätte realisieren können.
Naja, klar, ist ja auch nur ein Beispiel: Auf Grund der Fragestellung erschien mir das aber sinnvoll. Die Klasse würde wahrscheinlich noch ein paar Attribute wie "Budget", "Kosten" o.ä. haben. Prinzipiell finde ich es sinnvoll, eine "Main"-Klasse zu haben, die grundlegende Methoden bündelt - und wie gesagt: Die Hausverwaltung würde man ja vermutlich noch ausbauen wollen.
Hyperion hat geschrieben: Bei der Klasse Konto könnte man mittels property das einzahlen und abbheben ersetzen
Warum sollte man das machen? Ich habe auch erst überlegt; aber da man - gerade beim Abheben - ohnehin eine zusätzliche Logik braucht, kann man diese auch gleich implementieren. Außerdem wäre das im konkreten Fall auch reichlich unintuitiv.

Danke für eure Kritik; ich hoffe es nervt nicht zu sehr, wenn man hier Anfängern "halbrichtigte" Hilfestellungen gibt ;)
ippurk
User
Beiträge: 61
Registriert: Mittwoch 8. Juli 2009, 20:40

Also erst mal vielen Dank für die vielen Vorschläge und Hinweise, werde die alle der Reihe nach abarbeiten.

Nur irgendwie hat glaub ich keiner mein Hauptproblem erkannt:

Der Nutzer soll Instanzen der Klasse Bankkonto erstellen können, nämlich dann, wenn er ein neues Konto anlegt. Die Variable, der die neue Instanz zugewiesen werden soll, ist aber eben der Text, den der Benutzer im Entryfeld des Dialogs eingibt. Verstanden ?

Er soll also nicht eingeben müssen " konto345 = Bankkonto() ", sondern er gibt im Entry Feld nur "konto345" ein und drückt dann auf den Button 'los jetzt' und erhält als Ergebnis ein neues Konto, auf das er auch was einzahlen kann.

Genau, ich hoffe ich versteh das gleich, wenn ichs nochmal lese, auch noch selber.
Barabbas
User
Beiträge: 349
Registriert: Dienstag 4. März 2008, 14:47

Ich glaube, dir ist nicht ganz klar, wie das Ganze funktioniert, fürchte ich. Aber macht ja nix: Meine Methode "Konto erstellen" würde genau das machen. Im Beispiel heißt das Konto "neues_konto", das kannst du einfach durch den Namen ersetzen, den der Benutzer angegeben hat.

Wenn du nun etwas einzahlen möchtest, machst du das mit der Methode einzahlen() der Klasse Fenster(). Dort wird jetzt das Konto, auf das eingezahlt werden soll, als zweiter Parameter übergeben - das kannst du einfach so umwandeln, dass der Name des Kontos ("neues_konto") ebenfalls durch die GUI abgefragt wird.

Kurz: Der Benutzer hat *nie* direkten Zugriff auf die Klassen und muss auch nie direkt irgendwelche Klassen laden. Der Benutzer weiß normalerweise gar nicht, ob er gerade eine neue Instanz von irgendwas lädt oder nicht - und genau das macht mein Beispiel - sobald du den entsprechenden Code eingefügt hast *hust*

Schönen Gruß,

brb
ippurk
User
Beiträge: 61
Registriert: Mittwoch 8. Juli 2009, 20:40

Ok, also eure Tipps haben auf jeden Fall dazu geführt, das meine Anwendung jetzt funktioniert. Falls es jemanden interessiert, hier sollte der Code zu finden sein, wenn ich das so richtig eingestellt habe: http://paste.pocoo.org/show/127587/

Soweit ich das verstanden habe, ist es also möglich, mit dem Befehl "liste[instanzname] = Class()" eine Instanz instanzname der Klasse Class zu erzeugen, welche dann in der "liste" gespeichert wird.
Und der "instanzname" kann in diesem Fall ein str oder auch ein int sein. So kann ich also auch eine Instanz mit dem Namen "1234" erzeugen, was ja einer Kontonummer recht nahe kommt.
Zugriff auf diese Instanz und deren Attribute bekommt man über liste[instanzname].attr und Zugriff auf dort abgelegte Werte mit dem Befehl liste[instanzname].wert.

at Barabbas:
Ich habe mir mal erlaubt, deine zusätzliche Klasse Hausverwaltung wegzulassen. Jetzt ist meine Kontenliste natürlich ein Objekt ohne Klassenzugehörigkeit oder so, weiß nicht, ob man das so macht. Das Attribut "bezeichnung" der Klasse Konto habe ich auch weggelassen, welches ja eigentlich nur eine zusätzliche Variable für den Kontoinhalt bereitstellt, die man in dem Fall vielleicht als weiterführende Beschreibung des Kontonamens nutzen könnte, welcher ja eigentlich schon in der Liste gespeichert ist. Ich weiß zwar noch nicht, wie ich auf diesen Namen zugreifen kann, aber das müsste ja auch gehen.

Also, schönen Abend noch und danke nochmal für die vielen Antworten.
ippurk
User
Beiträge: 61
Registriert: Mittwoch 8. Juli 2009, 20:40

achso, wegen diesem import *, wenn ich da schreibe "import tkinter" oder "from tkinter import tkinter", wie muss ich dann das erste Fenster starten ?
Mit "fenster = Tk()" geht's auf jeden Fall nicht so.
BlackJack

@ippurk: `liste` ist ein schlechter Name für ein Dictionary. Du erzeugst damit auch keine Instanz mit dem Namen `instanzname`, sondern eine Instanz *ohne* Namen, die dann in einem Dictionary unter dem Schlüssel gespeichert wird, der an `instanzname` gebunden ist. Das kann jedes beliebige Objekt sein, dass Vergleiche und die `__hash__()`-Methode entsprechend implementiert.

Ganze Zahlen als Kontonummer zu verwenden ist keine gute Idee, weil Kontonummern keine Zahlen in dem Sinne sind, als das man mit ihnen rechnen könnte oder wollte, sondern eher eindeutige Bezeichner. Die könnten zum Beispiel auch führende Nullen enthalten, die signifikant sind, so dass Konto '007' etwas anderes ist als Konto '7'. Das liesse sich mit `int` nicht ausdrücken.

Die globale `kontenliste` ist unschön, und das `Bankkonto` die kennt und benutzt ist noch unschöner.

In `Fenster` scheint ja einfach *alles* an das Exemplar gebunden zu werden. Das sollte man auf die Sachen beschränken, die wirklich nötig sind, und die sollten auch alle in der `__init__()` auftauchen, damit man einen besseren Überblick darüber hat, welche Attribute `Fenster`-Exemplare haben.
ippurk
User
Beiträge: 61
Registriert: Mittwoch 8. Juli 2009, 20:40

@ Blackjack: Gut zu wissen, daß ich hier ein dictionary und keine Liste benutze. Danke für die Klarstellung.
Deinen letzten Kommentar habe ich mal so interpretiert, alle Fenster, die vom Hauptfenster erstellt werden, in neue Klassen auszulagern. Ich hoffe, du hast da sowas in der Art gemeint, sieht zumindest so einigermaßen logisch aus und funktioniert ja auch.

Und nun die Sache mit der Kontenliste: Barabbas hat das ja so gelöst, daß er eine Überklasse erstellt hat, sozusagen die Bank oder das Mietshaus. Darin wird die Kontenliste dann erstellt. Macht ja auch in dem Fall von mehreren Häusern oder Banken durchaus Sinn, doch die wiederum müssen ja auch irgendwo herkommen, was dann eigentlich ja wieder die gleiche Situation schafft, wie jetzt, nämlich verschiedene Konten. Muss man für sowas eine Art Applikationsklasse erstellen, die sozusagen das Programm ansich darstellt und der man dann eben die Kontenliste zuteilen kann ? Oder wie macht man sowas ?

Hier der aktuelle Code: http://paste.pocoo.org/show/127649/
Barabbas
User
Beiträge: 349
Registriert: Dienstag 4. März 2008, 14:47

Hallo ippurk,

ich fürchte, dass BJ das so nicht meinte: Wenn du Fenster anzeigst, in die der Benutzer irgendwelche Eingaben machen soll, dann sieht das bei dir zur Zeit so aus (zugespitztes doofes Beispiel):

Code: Alles auswählen

self.fenster = Fenster()
self.fenster.anzeigen()
self.fenster.schliessen()
Durch dieses self bindest du das Fenster an die Klasse. Aber das ist eigentlich unnötig, da du das Fenster eh immer wieder neu erstellst.

Code: Alles auswählen

fenster = Fenster()
fenster.anzeigen()
fenster.schliessen()
würde also völlig reichen.

Für deinen Zweck finde ich die vielen einzelnen Fensterklassen gerade etwas übertrieben. Ich denke, es reicht eigentlich wirklich, wenn das Methoden der Hauptfensterklasse sind.


Was deine andere Frage angeht:
Stell dir vor, diese Überklasse ist sowas wie eine Profilverwaltung: Sie hat eine Funktion, mit der man eine Kontoliste speichern und laden kann. Am Anfang deines Programmes würde ein Fenster den Benutzer fragen, welches Profil er öffnen möchte. Er kann dann zwischen den verschiedenen Kontolisten wählen und diese laden.

Das ist doch, was du meinst, oder?
ippurk
User
Beiträge: 61
Registriert: Mittwoch 8. Juli 2009, 20:40

Also, ich hab in den letzten Tagen versucht, soviel wie möglich von euren Bemerkungen und Vorschlägen umzusetzen, was hier auch zu sehen ist: http://paste.pocoo.org/show/128536/. Neu ist vor allem die Speicherung der Daten, etwas sehr rudimentär wahrscheinlich, aber es geht.

Was ich noch nicht so ganz kapiert habe, ist sozusagen diese "Haupt"-Klasse.

Eigentlich ist dieser thread ja thematisch erschöpft, aber wegen der ganzen Hinweise mach ich hier einfach mal weiter. Also, wer Lust hat, kann gern was sagen,

schönen Gruß, Stephan
Antworten