Listenobjekte

Joghurt · Donnerstag 26. Januar 2006, 02:57

Noch ein Hinweis: Was nicht geht, ist

kreise = [Kreis()]*5

Dann hätte zwar kreise 5 Kreis-Instanzen, jedoch sind dies allles Referenzen auf ein und dieselbe Instanz.

Wollte dich nur warnen, falls du dieses Feature von Python entdeckst.

N317V · Donnerstag 26. Januar 2006, 16:09

Alpha-Phonix hat geschrieben:noch was zum programmieren allgemein, ich suche schon länger eine gute ide, hab grad pythonwin drauf, und finde, dass der debugger etc schwer verständlich ist!

Benutze ich auf Windows ebenfalls und hab keine Probleme damit. Was ist Dir denn da unverständlich? Vielleicht kann ich ja helfen?

Alpha-Phonix · Freitag 27. Januar 2006, 08:07

ich weiß nicht, ich kriegs mit dem debugger irgendwie nicht hin!
ich hab noch nicht mal richtig durchgeschalten, wie er funkzt!

N317V · Freitag 27. Januar 2006, 09:54

Hmmm... einfach auf den 'Go'-Button klicken und laufen lassen. Entweder kommt dann in der Statuszeile "SCRIPTNAME returned exit code 0", dann war alles gut, oder es kommt ne Fehlermeldung in der Pythonshell oder mehrere. Dort kannst Du dann draufklicken und kommst sofort in die Zeile, wo der Fehler aufgetreten ist. Der Button 'Step' führt das Script Blockweise aus, 'Step Over' überspringt die nächste Anweisung, 'Step Out' springt zur ersten Anweisung nach dem aktuellen Block. Mit der Hand und der durchgestrichenen Hand kann man Breakpoints setzen und löschen. Es gibt mit der 'Pflaume' eine Liste der Breakpoints und der Stapel, tja, der bringt eine hierachische Liste des Stack. 'Watch' hab ich selber noch nicht rausgefunden, brauch ich aber auch nie.

Unter dem Menüpunkt 'Help' kommt man zur PythonWin Reference. Dort findet man bei einer Suche nach 'debug' ein Debugger-Tutorial und die Doku. Eigentlich geht das fast genauso wie in *shudder* Visual Studio.

Alpha-Phonix · Montag 30. Januar 2006, 11:02

so bin nun gut weiter gekommen, jetzt fehlt mir nur noch eins...

ich will unbeschränkt objekte anlegen können, diese sollen in einer liste gespeichert werden, leider schaff ich des net....

Code: Alles auswählen

z1=Zeichnung()
radius=raw_input("Radius (cm): ")
kreis=Kreis(radius) # soll nicht nur einer sonder viele werden
z1.hinzufuegen_kreis(kreis)
schnittlaenge_kreis=kreis.rechneSchnittlaengeKreis(radius)
flaeche_kreis=kreis.rechneFlaecheKreis(radius)

die Klasse Zeichnung soll praktisch eine Liste verwalten, von Kreisen die angelgt wurden!

Alpha-Phonix · Montag 30. Januar 2006, 11:09

so sieht mein kompletter code aus, wie ihr sehen könnt, wird nur EIN kreis, ein rechteck und ein 5-eck angelegt. das soll jetzt mit listen realisiert werden, aber wie?

Code: Alles auswählen

import msvcrt
from math import*



class GeometrischeFigur:
    
    def __init__(self):
        self.GeometrischeFigur=[]

    def rechneSchnittlaengeGesamt(self,schnittlaenge_kreis,schnittlaenge_rechteck,schnittlaenge_eck):
        seitenlaenge_gesamt=schnittlaenge_kreis+schnittlaenge_rechteck+schnittlaenge_eck
        return seitenlaenge_gesamt

class Zeichnung:

    def hinzufuegen_kreis(self,kreis_1):
        self.kreisobjekt=kreis_1
    def hinzufuegen_rechteck(self,recht_1):
        self.rechteckobjekt=recht_1
    def hinzufuegen_eck(self,eck_1):
        self.ecksobjekt=eck_1

      
    def speichern(self):
        f=file("Daten.txt","w")
        f.write("Kreis:\n")
        f.write("--------\n")
        f.write("Kreisradius (cm): ")
        f.write("%s\n" % radius)
        f.write("Kreisumfang (cm): ")
        f.write("%s\n" % schnittlaenge_kreis)
        f.write("Kreisflaeche (cm2): ")
        f.write("%s\n" % flaeche_kreis)
        f.write("---------------------------------\n")
        
        f.write("Rechteck:\n")
        f.write("-------------\n")
        f.write("Seitenlaenge a (cm): ")
        f.write("%s\n" % seitenlaenge_alpha)
        f.write("Seitenlaenge b (cm): ")
        f.write("%s\n" % seitenlaenge_beta)
        f.write("Rechteckumfang (cm): ")
        f.write("%s\n" % schnittlaenge_rechteck)
        f.write("Rechteckflaeche cm2")
        f.write("%s\n" % flaeche_rechteck)
        f.write("---------------------------------\n")
        
        f.write("5-eck:\n")
        f.write("--------\n")        
        f.write("Seitenlaenge (cm): ")
        f.write("%s\n" % seitenlaenge_eck)
        f.write("Eckumfang (cm): ")
        f.write("%s\n" % schnittlaenge_eck)
        f.write("Eckflaeche (cm): ")
        f.write("%s\n" % flaeche_eck)
        f.write("---------------------------------\n")
        f.write("Schnittlaenge aller Figuren (cm): ")
        f.write("%s\n" % gesamt)
        f.close()
    def laden(self):
        f = file("Daten.txt", "r")
        inhalt = f.read()
        print inhalt
        f.close()
    
    
class Kreis(GeometrischeFigur):
    
    def __init__(self,radius):
        self.Kreis=[radius]

    def rechneSchnittlaengeKreis(self,radius):
        flaeche=0
        schnittlaenge_kreis=0
        pie=3.14
        schnittlaenge_kreis=(float(pie))*float(radius)*2
        return schnittlaenge_kreis
    
    def rechneFlaecheKreis(self,radius):
        flaeche=0
        pie=3.14
        flaeche=((float(pie))*float(radius)*2)*float(radius)
        return flaeche

class Rechteck(GeometrischeFigur):
    
    def __init__(self,seitenlaenge_alpha,seitenlaenge_beta):
        self.Rechteck=[seitenlaenge_alpha,seitenlaenge_beta]

    def rechneSchnittlaengeRechteck(self,seitenlaenge_alpha,seitenlaenge_beta):
        schnittlaenge_rechteck=0
        schnittlaenge_rechteck=float(seitenlaenge_alpha)*2+float(seitenlaenge_beta)*2
        return schnittlaenge_rechteck
    def rechneFlaecheRechteck(self,seitenlaenge_alpha,seitenlaenge_beta):
        flaeche=0
        flaeche=float(seitenlaenge_alpha)*float(seitenlaenge_beta)
        return flaeche

class Eck(GeometrischeFigur):
    
    def __init__(self,seitenlaenge_eck):
        self.Eck=[seitenlaenge_eck]

    def rechneSchnittlaengeEck(self,seitenlaenge_eck):
        schnittlaenge_eck=0
        schnittlaenge_eck=float(seitenlaenge_eck)*5
        return schnittlaenge_eck
    def rechneFlaecheEck(self,seitenlaenge_eck):
        tan=1.37638
        flaeche_eck=0
        flaeche_eck=((1.25*float(seitenlaenge_eck))*float(seitenlaenge_eck))*float(tan)
        return flaeche_eck


def ausgabe():
    print "________________________________"
            
    print "Kreis:"
    print "------"
    print "Radius: ",radius,"cm"
    print "Schnittlaenge: ",schnittlaenge_kreis,"cm"
    print "Flaeche: ",flaeche_kreis,"cm2"
    print "________________________________"

    
    print "Rechteck:"
    print "---------"
    print "Seitenlaenge a: ",seitenlaenge_alpha,"cm"
    print "Seitenlaenge b: ",seitenlaenge_beta,"cm"
    print "Schnittlaenge: ",schnittlaenge_rechteck,"cm"
    print "Flaeche: ",flaeche_rechteck,"cm2"
    print "________________________________"

    
    print "5-Eck:"
    print "------"

    print "Seitenlaenge: ",seitenlaenge_eck,"cm"
    print "Schnittlaenge: ",schnittlaenge_eck,"cm"
    print "Flaeche: ",flaeche_eck,"cm2"
    print "________________________________\n\n"

    print "Schnittlaenge aller Figuren: ",gesamt,"cm"
   
       

def menue():
    print "_________________________________\n"
    print "         Zeichnungstool          "
    print "_________________________________\n"

    print "0   --> Neue Zeichnung"
    print "1   --> Neue Figur anlegen"
    print "2   --> Schnittlaenge berechnen"
    print "3   --> Umfang berechnen"
    print "4   --> Flaeche berechnen"
    print "5   --> Zeichnung laden"
    print "6   --> Zeichnung speichern"
    print "ESC --> Programm beenden"

def loeschen(kreis1,recht1,eck1):
    pass


radius=0
schnittlaenge_kreis=0
flaeche_kreis=0
schnittlaenge_rechteck=0
seitenlaenge_alpha=0
seitenlaenge_beta=0
flaeche_rechteck=0
schnittlaenge_eck=0
seitenlaenge_eck=0
flaeche_eck=0
gesamt=0
seitenlaenge_gesamt=0
esc = '\x1b'
menue()
geo=GeometrischeFigur()
test=Zeichnung()

ch = msvcrt.getch()
while ch != esc:

        if (ch=='0'):
            print "------------------------------"
            print "--  Neue Zeichnung anlegen  --"
            print "------------------------------"
            print "Wollen Sie alle Zeichnungen loeschen?"
            frage=raw_input("y/n: ")
            if (frage=='n'):
                print "Zeichnung(en) wird(werden) nicht geloescht"
                print "Zurueck zum Hauptmenu"
                menue()
            else:
                print "Zeichnung(en) wird(werden)geloescht"
                radius=0
                schnittlaenge_kreis=0
                flaeche_kreis=0
                schnittlaenge_rechteck=0
                seitenlaenge_alpha=0
                seitenlaenge_beta=0
                flaeche_rechteck=0
                schnittlaenge_eck=0
                seitenlaenge_eck=0
                gesamt=0
                flaeche_eck=0
                seitenlaenge_gesamt=0
        
                menue()
                
        elif (ch=='1'):
            print "------------------------------"
            print "--  Neue Figur(en) anlegen  --"
            print "------------------------------"
            
            print "1  -->  Kreis"
            print "2  -->  Rechteck"
            print "3  -->  5eck"
            eingabe=raw_input()
            if(eingabe=='1'):
                z1=Zeichnung()
                
                radius=raw_input("Radius (cm): ")
                kreis=Kreis(radius)
                z1.hinzufuegen_kreis(kreis)
                schnittlaenge_kreis=kreis.rechneSchnittlaengeKreis(radius)
                flaeche_kreis=kreis.rechneFlaecheKreis(radius)
                
                gesamt=geo.rechneSchnittlaengeGesamt(schnittlaenge_kreis,schnittlaenge_rechteck,schnittlaenge_eck)
            elif(eingabe=='2'): 
                seitenlaenge_alpha=raw_input("Seitenlaenge a (cm): ")
                seitenlaenge_beta=raw_input("Seitenlaenge b (cm): ")
                recht=Rechteck(seitenlaenge_alpha,seitenlaenge_beta)
                z1.hinzufuegen_rechteck(recht)
                
                schnittlaenge_rechteck=recht.rechneSchnittlaengeRechteck(seitenlaenge_alpha,seitenlaenge_beta)
                flaeche_rechteck=recht.rechneFlaecheRechteck(seitenlaenge_alpha,seitenlaenge_beta)
                gesamt=geo.rechneSchnittlaengeGesamt(schnittlaenge_kreis,schnittlaenge_rechteck,schnittlaenge_eck)
            elif(eingabe=='3'):
                seitenlaenge_eck=raw_input("Seitenlaenge(cm): ")
                eck=Eck(seitenlaenge_eck)
                z1.hinzufuegen_eck(eck)
                
                schnittlaenge_eck=eck.rechneSchnittlaengeEck(seitenlaenge_eck)
                flaeche_eck=eck.rechneFlaecheEck(seitenlaenge_eck)
                gesamt=geo.rechneSchnittlaengeGesamt(schnittlaenge_kreis,schnittlaenge_rechteck,schnittlaenge_eck)
            menue()
        elif (ch=='2'):
            geo=GeometrischeFigur()
            gesamt=geo.rechneSchnittlaengeGesamt(schnittlaenge_kreis,schnittlaenge_rechteck,schnittlaenge_eck)
            print "--------------------------------"
            print "--Schnittlaenge aller Figuren---"
            print "--------------------------------"
            print gesamt,"cm"
            menue()
        elif (ch=='3'):
            print "--------------------------------"
            print "--------Umfangberechnung--------"
            print "--------------------------------"
            print "Schnittlaenge Kreis   : ",schnittlaenge_kreis,"cm"
            print "Schnittlaenge Rechteck: ",schnittlaenge_rechteck,"cm"
            print "Schnittlaenge 5-Eck   : ",schnittlaenge_eck,"cm"
        elif (ch=='4'):
            print "--------------------------------"
            print "-------Flaechenberechnung-------"
            print "--------------------------------"
            print "Flaeche Kreis   : ",flaeche_kreis,"cm2"
            print "Flaeche Rechteck: ",flaeche_rechteck,"cm2"
            print "Flaeche 5-Eck   : ",flaeche_eck,"cm2"
            menue()
        elif (ch=='5'):
             lade=Zeichnung()
             print "Programm wurde geladen"
             lade.laden()
             menue()
        elif (ch=='6'):
            ausgabe()
            speicher=Zeichnung()
            speicher.speichern()
            print "Programm gespeichert"
            menue()

        ch = msvcrt.getch()

BlackJack · Montag 30. Januar 2006, 23:46

Alpha-Phonix hat geschrieben:so sieht mein kompletter code aus, wie ihr sehen könnt, wird nur EIN kreis, ein rechteck und ein 5-eck angelegt. das soll jetzt mit listen realisiert werden, aber wie?

Na indem Du halt eine Liste anlegst in die Du die Kreise und Rechtecke speicherst.

Code: Alles auswählen

class GeometrischeFigur:
    
    def __init__(self):
        self.GeometrischeFigur=[]

Wird `self.GeometrischeFigur` irgendwann einmal benutzt? Die Klasse sieht mir aus wie eine abstrakte Basisklasse. Benötigt man in Python eigentlich nicht, wenn sie komplett abstract ist.

Code: Alles auswählen

class Zeichnung:

    def hinzufuegen_kreis(self,kreis_1):
        self.kreisobjekt=kreis_1
    def hinzufuegen_rechteck(self,recht_1):
        self.rechteckobjekt=recht_1
    def hinzufuegen_eck(self,eck_1):
        self.ecksobjekt=eck_1

Der Klasse `Zeichnung` fehlt eine `__init__()`-Methode in der eine Liste angelegt wird und anstelle der drei `hinzufuegen_*()` Methoden kannst Du dann eine nehmen, die irgendein (geometrisches) Objekt an diese Liste anhängt.

Code: Alles auswählen

    def speichern(self):
        f=file("Daten.txt","w")
        f.write("Kreis:\n")
        f.write("--------\n")
        f.write("Kreisradius (cm): ")
        f.write("%s\n" % radius)
        f.write("Kreisumfang (cm): ")
        f.write("%s\n" % schnittlaenge_kreis)
        f.write("Kreisflaeche (cm2): ")
        f.write("%s\n" % flaeche_kreis)
        f.write("---------------------------------\n")
        
        f.write("Rechteck:\n")
        f.write("-------------\n")
        f.write("Seitenlaenge a (cm): ")
        f.write("%s\n" % seitenlaenge_alpha)
        f.write("Seitenlaenge b (cm): ")
        f.write("%s\n" % seitenlaenge_beta)
        f.write("Rechteckumfang (cm): ")
        f.write("%s\n" % schnittlaenge_rechteck)
        f.write("Rechteckflaeche cm2")
        f.write("%s\n" % flaeche_rechteck)
        f.write("---------------------------------\n")
        
        f.write("5-eck:\n")
        f.write("--------\n")        
        f.write("Seitenlaenge (cm): ")
        f.write("%s\n" % seitenlaenge_eck)
        f.write("Eckumfang (cm): ")
        f.write("%s\n" % schnittlaenge_eck)
        f.write("Eckflaeche (cm): ")
        f.write("%s\n" % flaeche_eck)
        f.write("---------------------------------\n")
        f.write("Schnittlaenge aller Figuren (cm): ")
        f.write("%s\n" % gesamt)
        f.close()

Wie eine konkrete Figur gespeichert wird, solltest Du lieber den Figur-Objekten überlassen. Sonst muss die `Zeichnung` über jedes konkrete Objekt bescheid wissen. Das ist nicht besonders einfach erweiterbar.

Code: Alles auswählen

class Kreis(GeometrischeFigur):
    
    def __init__(self,radius):
        self.Kreis=[radius]

Warum ist der Radius in einer Liste gespeichert?

Code: Alles auswählen

    def rechneSchnittlaengeKreis(self,radius):
        flaeche=0
        schnittlaenge_kreis=0
        pie=3.14
        schnittlaenge_kreis=(float(pie))*float(radius)*2
        return schnittlaenge_kreis

Du musst die Namen nicht vorher an eine 0 binden und es gibt `math.pi`. Sowohl `math.pi` als auch Dein `pie` sind schon Fliesskommazahlen, also ist das `float()` überflüssig. Und warum muss der `radius` als Parameter übergeben werden? Das Objekt hat doch einen `self.radius`. (Bzw. den Radius in der Liste)

Code: Alles auswählen

def schnittlaenge(self):
    return math.pi * self.radius * 2

Das sollte eigentlich reichen. Es ist auch nicht nötig im Methodennamen nochmal zu erwähnen das es sich um einen Kreis handelt, das sollte klar sein wenn man ein Objekt vom Typ `Kreis` vor sich hat. Vor allem wenn jedes geometrische Objekt eine Methode hat, die nur `schnittlaenge` heisst, dann kann man die Aufrufen ohne das der benutztende Quelltext wissen muss um welches Objekt es sich genau handelt. Analog gilt das für `flaeche()` und ähnliche Methoden die auf allen geometrischen Objekten Sinn machen. Das nennt sich Polymorphie.

Du solltest vielleicht nochmal einen Schritt zurück machen und Dir die grundlegenden Datenstrukturen von Python und Klassen/Objekte anschauen. Mir scheint Du hast die noch nicht ganz verinnerlicht.