Menü mit Klasse?

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.
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

Hallo zusammen,

zuerst mal nur theoretisch:
Wir schreiben in der Schule folgende Programme:
Modul mit Funktionen (Formeln - Umfang Rechteck usw.),
ein weiteres mit Turtlefunktionen usw.

Dann verpassen wir diesen Modulen ein Benutzerinterface, der Sinn dazu wird klar gemacht.

Das Benutzerinterface ist einfach ein Menü - Bsp. Formeln:
=======Menü=======
1. Umfang Rechteck
2. Fläche Rechtek
usw.
e = Ende
==================


Neulich habe ich mir mal gedacht wie es wäre das Menü in einer Klasse zu definieren und bei Bedarf kann man dann in diesem und jenem Modul ein Menü erzeugen.

Das geht natürlich auch mit einer Funktion. Die Frage ist, ob es nicht doch ein nette Möglichkeit wäre die Schüler in OOP einzuführen.

Was mich selbst dran stört ist, dass ich entweder nicht weiss welche Methoden zur Manipulation definiert werden könnten oder, dass ich mir die Umsetzung etwas schwierig vorstelle.

Z. B. Wenn das Menü mehr als 5 Einträge hat per Tasteneingabe, dieses ein- bzw. auszuklappen. Geht sowas überhaupt?

Seit mal so nett und hirnt über die Idee nach und macht mir mal den einen oder anderen Vorschlag.

Vielen Dank im Voraus

LG

rolgal_reloaded
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

Zur Verdeutlichung meines Textes:

Code: Alles auswählen

class Menue:    

    menue_kopf = "----------Menü-----------\n"
    menue_option_a = "a für ausklappen\n"
    menue_option_e = "e für einklappen\n"
    menue_option_E = "E für Ende\n"
    menue_fuss = "-------------------------"
    
    
    def __init__(self, *eintraege):
        self.menue_eintraege = ""
        self.hidden = ""
        for i in xrange(len(eintraege)):
            if i > 2:
                self.hidden = self.hidden + str(i + 1) + ". " + \
                              eintraege[i] + "\n"
                
            else:
                self.menue_eintraege = self.menue_eintraege + \
                str(i + 1) + ". " + eintraege[i] + "\n"

    def __str__(self):
        self.menue = self.menue_kopf + \
                     self.menue_eintraege + \
                     self.menue_option_a + \
                     self.menue_option_e +\
                     self.menue_option_E +\
                     self.menue_fuss 
        return self.menue
    
    def ausklappen(self):
        if self.hidden not in self.menue:
            menue_eintraege_neu = self.menue_eintraege + self.hidden
            self.menue = self.menue.replace(self.menue_eintraege,
                                            menue_eintraege_neu)
            print self.menue
    

if __name__ == "__main__":

    menue = Menue("Umfang Rechteck",
                   "Fläche Rechteck",
                   "Umfang Dreieck",
                  "Fläche rechtwinkliges Dreieck",
                  "Umfang Kreis")
    print menue
Sobald man Methoden definiert die das Menü verändern, wird es schon ganz schön umfangreich, dabei habe ich erst eine definiert.

LG

rolgal_reloaded
Zuletzt geändert von rolgal_reloaded am Mittwoch 18. April 2007, 21:46, insgesamt 1-mal geändert.
Costi
User
Beiträge: 545
Registriert: Donnerstag 17. August 2006, 14:21

nur ein par kurze bemerkung zur implementation:

zeile 37 und 38 kannst du wegglasen
und du kannst zeile 13 loeschen und in zeile 16 das "self.hidden + " auch entfernen (nicht nur einfach machen, ruebe anstrengen ; )

wenn du noch ein paar andere kleine verbesserungen vornimmst ist es sicher einfacher fuer dich mit dem code weiterzuarbeiten


gruesse
costi
cp != mv
BlackJack

So ganz verstehe ich die Klasse nicht.

Es gibt Wiederholungen beim zusammensetzen der Einträge. Und wenn man `ausklappen()` aufruft bevor ein `Menue`-Objekt nicht mindestens einmal in eine Zeichenkette umgewandelt wurde gibt's eine Fehlermeldung.

Wenn in einem ``else``-Zweig nur ein ``pass`` steht, kann man den Zweig ganz weglassen.

`menue_eintraege_neu` wird nur in `ausklappen()` benutzt, sollte also lokal sein und nicht an das Objekt gebunden werden.
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

Costi hat geschrieben:nur ein par kurze bemerkung zur implementation:

zeile 37 und 38 kannst du wegglasen
Du meinst doch 38,39, also den else - Zweig?
Costi hat geschrieben: und du kannst zeile 13 loeschen und in zeile 16 das "self.hidden + " auch entfernen (nicht nur einfach machen, ruebe anstrengen ; )
Aber da gibts ein seltsames Verhalten dann:

----------Menü-----------
1. Umfang Rechteck
2. Fläche Rechteck
3. Umfang Dreieck
5. Umfang Kreis
a für ausklappen
e für einklappen
E für Ende
-------------------------

Wie du siehst fehlt da Punkt 4, der sonst nicht fehlt.
Vielleicht hast du es im Detail auch etwas anders gemeint bzw. ich falsch verstanden.


LG

rolgal_reloaded
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

BlackJack hat geschrieben:So ganz verstehe ich die Klasse nicht.

Es gibt Wiederholungen beim zusammensetzen der Einträge.
Welche Wiederholungen meinst du? Code bitte.
Und wenn man `ausklappen()` aufruft bevor ein `Menue`-Objekt nicht mindestens einmal in eine Zeichenkette umgewandelt wurde gibt's eine Fehlermeldung.
Versteh ich jetzt nicht, dazu kann es doch gar nicht kommen, dass man ausklappen() aufrufen kann bevor en Menueobjekt erzeugt wurde.
Oder reden wir von was anderem?
Wenn in einem ``else``-Zweig nur ein ``pass`` steht, kann man den Zweig ganz weglassen.
Das ist klar.
`menue_eintraege_neu` wird nur in `ausklappen()` benutzt, sollte also lokal sein und nicht an das Objekt gebunden werden.
Hmpf, genau das passiert mir eigentlich selten, egal, danke für den Hinweis!

LG

rolgal_reloaded
BlackJack

Das mit dem `ausklappen()` war mein Fehler. Ich habe `self.menu` gesehen und dachte das wird dort benutzt und in `__str__()` erzeugt. Also nochmal zwei Fälle von lokalen Variablen die ans Objekt gebunden werden.

Mit Wiederholungen meinte ich die beiden Zweige in `__init__()` wo die Zeichenketten für das Menü zusammengebaut werden. Das könnte man vor die Entscheidung ziehen und dann nur noch entscheiden wo der Eintrag angefügt wird.
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

BlackJack hat geschrieben:Das mit dem `ausklappen()` war mein Fehler. Ich habe `self.menu` gesehen und dachte das wird dort benutzt und in `__str__()` erzeugt. Also nochmal zwei Fälle von lokalen Variablen die ans Objekt gebunden werden.
Du hast self.menue gesehen.
Richtig es wird in '__str__()' erzeugt, oder nicht????
Warum nochmal zwei Fälle von lokalen Variablen????
Ich muss doch in 'ausklappen()' prüfen ob self.hidden bereits in self.menue vorhanden ist, sonst wird es überflüssigerweise nochmal angehängt.
Da ich nicht glaube, dass du zwei Fehler hintereinander machst, gehe ich davon aus, dass ich nicht checke was du meinst.

Mit Wiederholungen meinte ich die beiden Zweige in `__init__()` wo die Zeichenketten für das Menü zusammengebaut werden. Das könnte man vor die Entscheidung ziehen und dann nur noch entscheiden wo der Eintrag angefügt wird.
Werde ich gleich mal ausprobieren!

LG

rolgal_reloaded
BlackJack

Ist schon spät, ich bin verunsichert. Aber dann hatte ich ja am Anfang doch recht.

Wenn Du ein `Menue`-Objekt erzeugst und `auklappen()` aufrufst, dann kommt eine Fehler weil auf `self.menu` zugegriffen wird, was es nur gibt wenn das Objekt vorher mindestens einmal in eine Zeichenkette umgewandelt wurde. Das sollte man vermeiden oder gut dokumentieren.
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

....ahhh, ich glaube ich kann folgen.
Nun. Das Menü wird in jedem Fall beim Start der betreffenden Programmen sofort erzeugt.

Deshalb habe ich folgendes auch so geschrieben:

Code: Alles auswählen


if __name__ == "__main__":

    menue = Menue("Umfang Rechteck",
                   "Fläche Rechteck",
                   "Umfang Dreieck",
                  "Fläche rechtwinkliges Dreieck",
                  "Umfang Kreis")
    print menue
Ich berufe mich hier auch auf ein Gespräch zu einem Code von mir, das ich mal mit Leonidas hatte. Er meinte im damaligen Fall, man muss das Programm nicht unbedingt so verfassen, dass dem Benutzer jegliches denken abgenommen wird. - Frei zitiert ohne nochmal nachgelesen zu haben, also mit Vorbehalt:-))

Aber freilich ist dein Einwand sinnvoll und ich sollte mir nochmal überlegen, ob man es nicht besser lösen könnte bzw. entsprechend kommentieren sollte.

Also bis bald,

rolgal_reloaded
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

BlackJack hat geschrieben:
Wenn Du ein `Menue`-Objekt erzeugst und `auklappen()` aufrufst, dann kommt eine Fehler weil auf `self.menu` zugegriffen wird, was es nur gibt wenn das Objekt vorher mindestens einmal in eine Zeichenkette umgewandelt wurde. Das sollte man vermeiden oder gut dokumentieren.
Was hältst du davon den AttributeError abzufangen und da auf die falsche Verwendung hinzuweisen?

Code: Alles auswählen

    def ausklappen(self):
        try:
            if self.hidden not in self.menue:
                menue_eintraege_neu = self.menue_eintraege + self.hidden
                self.menue = self.menue.replace(self.menue_eintraege,
                                                menue_eintraege_neu)
                print self.menue
        except AttributeError:
            print "Achtung, Sie müssen zuerst das Menü ausgeben!"

LG

rolgal_reloaded
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

Hi,

so funzt es mit ausklappen und einklappen, einklappen erschien mir zuerst schwierig, aber wenn man nicht self.menue überschreibt, sondern ein neues Objekt erzeugt - menue_a (zunächst mal lokal, später vielleicht für die realisierung ineuer deen doch besser nicht lokal?), dann ist einklappen natürlich easy, weil ich einfach wieder self.menue ausgebe.

Code: Alles auswählen

class Menue:    

    menue_kopf = "----------Menü-----------\n"
    menue_option_a = "a für ausklappen\n"
    menue_option_e = "e für einklappen\n"
    menue_option_E = "E für Ende\n"
    menue_fuss = "-------------------------"
    
    
    def __init__(self, *eintraege):
        self.menue_eintraege = ""
        self.hidden = ""
        for i in xrange(len(eintraege)):
            if i > 2:
                self.hidden = self.hidden + str(i + 1) + ". " + \
                              eintraege[i] + "\n"
                
            else:
                self.menue_eintraege = self.menue_eintraege + \
                str(i + 1) + ". " + eintraege[i] + "\n"

    def __str__(self):
        self.menue = self.menue_kopf + \
                     self.menue_eintraege + \
                     self.menue_option_a + \
                     self.menue_option_e +\
                     self.menue_option_E +\
                     self.menue_fuss 
        return self.menue
    
    def ausklappen(self):
        try:
            if self.hidden not in self.menue:
                menue_eintraege_neu = self.menue_eintraege + self.hidden
                menue_a = self.menue.replace(self.menue_eintraege,
                                                menue_eintraege_neu)
                print menue_a
        except AttributeError:
            print "Achtung, Sie müssen zuerst das Menü ausgeben!"

    def einklappen(self):
        try:
            print self.menue
        except AttributeError:
            print "Achtung, Sie müssen zuerst das Menü ausgeben!"

     

    

if __name__ == "__main__":

    formelrechnermenue = Menue("Umfang Rechteck",
                   "Fläche Rechteck",
                   "Umfang Dreieck",
                  "Fläche rechtwinkliges Dreieck",
                  "Umfang Kreis")
    #print menue
EyDu
User
Beiträge: 4881
Registriert: Donnerstag 20. Juli 2006, 23:06
Wohnort: Berlin

Wenn deine Klasse schon Menue heißt, musst du nicht alle Namen der (Klassen-)Attribute mit "menue_" anfangen lassen, da bereits klar ist, in welchem Kontext sich die Attribute befinden.
BlackJack

Von dem Abfangen des Fehlers halte ich nicht so viel. Warum muss man ein Menü erst in eine Zeichenkette umwandeln bevor man die Methoden benutzen kann. Das ist eine recht willkürliche und künstliche Einschränkung.

Und das alles auf einer Zeichenkette gemacht wird, ist auch nicht so schön und nicht besonders übersichtlich. Ein Menü besteht abstrakt gesehen ja nicht aus einer Zeichenkette, sondern aus Einzelteilen wie Menüpunkten, Kopfzeile usw.

Andere Methoden die man auf einem Menü erwartet sind zum Beispiel hinzufügen und entfernen von Menüpunkten. Spätestens dann wird es mit der Zeichenkette richtig kompliziert.

Ich würde die Menüpunkte im Objekt speichern und ein Flag ob das Menü gerade ausgeklappt ist oder nicht. Und in der `__str__()`-Methode dann jedesmal entsprechend eine Zeichenkette zusammenbauen. Da kann man dann auch gleich dafür sorgen das nur einer der beiden Punkte für's ein- oder ausklappen angezeigt wird, weil es verwirrend ist den Punkt ausklappen bei einem schon ausgeklappten Menü zu haben und umgekehrt.

Aus dem `*eintraege`-Argument in der `__init__()` würde ich `eintraege` machen. Dann kann man die Einträge in einer Datenstruktur halten und als *ein* Argument übergeben. Ausserdem verbaut man sich nicht die Möglichkeit der Klasse oder Unterklassen weitere Argumente hinzuzufügen.

Und man könnte noch eine Möglichkeit schaffen den Einträgen Objekte zuzuordnen, zum Beispiel indem Einträge Tupel aus (Menütext, Objekt) sind.
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

BlackJack hat geschrieben:Von dem Abfangen des Fehlers halte ich nicht so viel. Warum muss man ein Menü erst in eine Zeichenkette umwandeln bevor man die Methoden benutzen kann. Das ist eine recht willkürliche und künstliche Einschränkung.

Und das alles auf einer Zeichenkette gemacht wird, ist auch nicht so schön und nicht besonders übersichtlich. Ein Menü besteht abstrakt gesehen ja nicht aus einer Zeichenkette, sondern aus Einzelteilen wie Menüpunkten, Kopfzeile usw.

Andere Methoden die man auf einem Menü erwartet sind zum Beispiel hinzufügen und entfernen von Menüpunkten. Spätestens dann wird es mit der Zeichenkette richtig kompliziert.

Ich würde die Menüpunkte im Objekt speichern und ein Flag ob das Menü gerade ausgeklappt ist oder nicht. Und in der `__str__()`-Methode dann jedesmal entsprechend eine Zeichenkette zusammenbauen. Da kann man dann auch gleich dafür sorgen das nur einer der beiden Punkte für's ein- oder ausklappen angezeigt wird, weil es verwirrend ist den Punkt ausklappen bei einem schon ausgeklappten Menü zu haben und umgekehrt.

Aus dem `*eintraege`-Argument in der `__init__()` würde ich `eintraege` machen. Dann kann man die Einträge in einer Datenstruktur halten und als *ein* Argument übergeben. Ausserdem verbaut man sich nicht die Möglichkeit der Klasse oder Unterklassen weitere Argumente hinzuzufügen.

Und man könnte noch eine Möglichkeit schaffen den Einträgen Objekte zuzuordnen, zum Beispiel indem Einträge Tupel aus (Menütext, Objekt) sind.
Hab mal versucht in die Richtung zu gehen. Mir kommt es jetzt schon besser vor, obwohl noch viele Details wie auch die Nummern zu den Menüpunkten fehlen.
Aber ich denke du hast dir in dieser Art der Anlage vorgestellt?

Code: Alles auswählen

class Menue:    

    menue_kopf = "----------Menü-----------\n"
    menue_option_a = "a für ausklappen\n"
    menue_option_e = "e für einklappen\n"
    menue_option_E = "E für Ende\n"
    menue_fuss = "-------------------------"    
    
    def __init__(self, eintraege):
        self.menue = ""
        self.eintraege = eintraege
        self.klappbar = False
        if len(self.eintraege) > 2:

            self.menue_eintraege = "".join(self.eintraege[:3])
            self.klappbar = True
            
        else:
            self.menue_eintraege = "".join(self.eintraege)
 
        self.__str__()
        print self.menue
        
        
    def __str__(self):        
        if self.klappbar:
            self.menue = self.menue_kopf + \
                         self.menue_eintraege + \
                         self.menue_option_a + \
                         self.menue_option_e +  \
                         self.menue_option_E +\
                         self.menue_fuss
        else:
            self.menue = self.menue_kopf + \
                     self.menue_eintraege + \
                     self.menue_option_E + \
                     self.menue_fuss
        return self.menue
    
    def ausklappen(self):
        self.menue_eintraege = "".join(self.eintraege)
        
    def einklappen(self):
        self.menue_eintraege = "".join(self.eintraege[:3])
   

if __name__ == "__main__":

    menue = Menue(["Umfang Rechteck\n",
                   "Fläche Rechteck\n",
                   "Umfang Dreieck\n",
                  "Fläche rechtwinkliges Dreieck\n",
                  "Umfang Kreis\n"])
BlackJack

Naja, ein bisschen besser ist es schon, aber noch nicht perfekt.

Es wird wieder Code wiederholt und zwar die `join()`-Aufrufe mit den Einträgen. `self.menue_eintraege` ist ein Attribut das meiner Meinung nach zuviel ist. Das gehört nicht zum Zustand eines Menüs. Der ist mit `eingeklappt` und den Menütexten ausreichend definiert. Und `self.menue` ist auch nicht notwendig. Mal davon abgesehen, das ich in der `__init__()` das Menü nicht ausgeben würde, hätte ein ``print self`` völlig gereicht.

Also mal von vorne. Ein "klappbares" Menü braucht Daten und zwar die Menüpunkte und die Information ob es gerade ein- oder ausgeklappt ist. Die notwendigen Daten werden in der `__init__()`-Methode gesetzt.

Dann braucht ein Objekt noch "Verhalten" in Form von Methoden. Das Menü soll man ein- und ausgeklappen können, also je eine Methode dafür. Was man dabei nur ändern muss ist `self.eingeklappt` damit man jederzeit abfragen kann in welchem Zustand sich das Menü gerade befindet.

Und weil man das Menü auch ausgeben möchte, gibt's eine Funktion die aus den Informationen die den Zustand beschreiben eine Zeichenkette zusammenbaut. Das ist der einzige Teil wo wirklich etwas interessantes passiert.

Die Zeichenkette besteht aus der Kopfzeile an die die numerierten Menüpunkte angehängt werden. Wenn das Menü eingeklappt ist, dann wird dieser Vorgang nach dem dritten Punkt abgebrochen.

Wenn das Menü lang genug ist, um ein- oder ausgeklappt zu werden muss man jetzt entscheiden welcher der beiden Menüpunkte zum klappen angezeigt werden muss.

Zum Schluss noch der Beenden-Menüpunkt und die Fusszeile. Ergebnis:

Code: Alles auswählen

# -*- coding: utf-8 -*-

class Menue(object):
    kopfzeile = '----------Menü-----------'
    option_a = 'a für ausklappen'
    option_e = 'e für einklappen'
    option_E = 'E für Ende'
    fusszeile = '-------------------------'
    
    def __init__(self, eintraege, eingeklappt=True):
        self.eintraege = eintraege
        self.eingeklappt = eingeklappt
    
    def __str__(self):
        result = [self.kopfzeile]
        for i, eintrag in enumerate(self.eintraege):
            if self.eingeklappt and i > 2:
                break
            result.append('%d. %s' % (i + 1, eintrag))
        if len(self.eintraege) > 2:
            if self.eingeklappt:
                result.append(self.option_a)
            else:
                result.append(self.option_e)
        result.extend((self.option_E, self.fusszeile))
        return '\n'.join(result)
    
    def ausklappen(self):
        self.eingeklappt = False
        
    def einklappen(self): 
        self.eingeklappt = True


if __name__ == '__main__':
    menue = Menue(('Umfang Rechteck',
                   'Fläche Rechteck',
                   'Umfang Dreieck',
                   'Fläche rechtwinkliges Dreieck',
                   'Umfang Kreis'))
    print menue
    menue.ausklappen()
    print menue
    menue.einklappen()
    print menue
EyDu
User
Beiträge: 4881
Registriert: Donnerstag 20. Juli 2006, 23:06
Wohnort: Berlin

BlackJack hat geschrieben:Naja, ein bisschen besser ist es schon, aber noch nicht perfekt.
Möchtest du damit etwa andeuten, dass du mit deiner Korrektur die perfekte Lösung abgeliefert hast ;-) ?

Je nach dem, ob beim Öffnen oder Schließen des Menüs noch etwas getan werden muss, würde ich die beiden dazugehörigen Methoden entfallen lassen (sonst führen wir hier als nächstes noch Setter- und Getter-Methoden ein :-) ):

Code: Alles auswählen

    def ausklappen(self):
        self.eingeklappt = False
        
    def einklappen(self): 
        self.eingeklappt = True
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

@blackjack

gefällt mir schon gut. Momentan bastel ich an einer Lösung mit 2 Klassen. Menue und KlappMenue. Erstens hätte man zuerst ein ganz super einfaches Beispiel für OOP, kann es schön ausbauen und das Prinzip der Vererbung auch noch gut zeigen.

Bin noch nicht fertig, stell es dann mal rein

@EyDu

Und wie würde es dann konkret aussehen ohne den entsprechenden Methoden?

LG

rolgal_reloaded
EyDu
User
Beiträge: 4881
Registriert: Donnerstag 20. Juli 2006, 23:06
Wohnort: Berlin

rolgal_reloaded hat geschrieben:Und wie würde es dann konkret aussehen ohne den entsprechenden Methoden?
Naja, das ist gar nicht so kompliziert. Dazu verwende ich einfach mal das letzte Beispiel von BlackJack:

Code: Alles auswählen

if __name__ == '__main__':
    menue = Menue(('Umfang Rechteck',
                   'Fläche Rechteck',
                   'Umfang Dreieck',
                   'Fläche rechtwinkliges Dreieck',
                   'Umfang Kreis'))
    print menue
    menue.eingeklappt = False
    print menue
    menue.eingeklappt = True
    print menue
Wenn du natürlich nach dem Einklappen oder Aufklappen zeichnen willst, würde ich die Methoden etwas abgeändert beibehalten:

Code: Alles auswählen

class Menue(object):
    ...
    
    def ausklappen(self):
        self.eingeklappt = False
        print self
        
    def einklappen(self): 
        self.eingeklappt = True
        print self
    
    ...

if __name__ == '__main__':
    menue = Menue(('Umfang Rechteck',
                   'Fläche Rechteck',
                   'Umfang Dreieck',
                   'Fläche rechtwinkliges Dreieck',
                   'Umfang Kreis'))
    menue.ausklappen()
    menue.einklappen()
Das Beispiel ist jetzt zwar nicht mehr 100%-ig identisch, aber meine Intention sollte deutlich werden.
rolgal_reloaded
User
Beiträge: 312
Registriert: Dienstag 24. Oktober 2006, 19:31

EyDu hat geschrieben:
rolgal_reloaded hat geschrieben:Und wie würde es dann konkret aussehen ohne den entsprechenden Methoden?
Naja, das ist gar nicht so kompliziert. Dazu verwende ich einfach mal das letzte Beispiel von BlackJack:

Code: Alles auswählen

if __name__ == '__main__':
    menue = Menue(('Umfang Rechteck',
                   'Fläche Rechteck',
                   'Umfang Dreieck',
                   'Fläche rechtwinkliges Dreieck',
                   'Umfang Kreis'))
    print menue
    menue.eingeklappt = False
    print menue
    menue.eingeklappt = True
    print menue
Wenn du natürlich nach dem Einklappen oder Aufklappen zeichnen willst, würde ich die Methoden etwas abgeändert beibehalten:

Code: Alles auswählen

class Menue(object):
    ...
    
    def ausklappen(self):
        self.eingeklappt = False
        print self
        
    def einklappen(self): 
        self.eingeklappt = True
        print self
    
    ...

if __name__ == '__main__':
    menue = Menue(('Umfang Rechteck',
                   'Fläche Rechteck',
                   'Umfang Dreieck',
                   'Fläche rechtwinkliges Dreieck',
                   'Umfang Kreis'))
    menue.ausklappen()
    menue.einklappen()
Das Beispiel ist jetzt zwar nicht mehr 100%-ig identisch, aber meine Intention sollte deutlich werden.
Sorry, nicht wirklich. Was das bringt bleibt mir noch ein Geheimnis.
Aber das mag durchaus auch an mir liegen:-)

Liebe Grüße

rolgal_reloaded
Antworten