Objektorientiertes Programmieren

[Sconine]

Ok, dann werde ich mir die Probleme gleich nochmal genau anschauen.

Ich habe Python 2.5.

[Sconine]

Jetzt bin ich verwirrt.

Code: Alles auswählen

import turtle

import Quadrat

class Quadrat:
    def __init__(self,seitenlaenge,zentrum):
        self.seitenlaenge = seitenlaenge
        self.zentrum = zentrum
        #return
    
    def anzeigen(self):
        angle = 90
        turtle.color("white")
        turtle.setx(self.zentrum[0]-0.5*self.seitenlaenge)
        turtle.sety(self.zentrum[1]-0.5*self.seitenlaenge)
        turtle.color("black")
        for i in range(4):
            turtle.forward(self.seitenlaenge)
            turtle.left(angle)
        #return
    
    def loeschen(self):
        turtle.color("white")
        angle = 90
        for i in range(4):
            turtle.forward(self.seitenlaenge)
            turtle.left(angle)
        #return
    
    def verschieben(self,neues_zentrum):
        self.loeschen()
        turtle.color("white")
        self.zentrum = neues_zentrum
        self.anzeigen()
        #return
    
    def skalieren(self,faktor):
        self.loeschen()
        self.seitenlaenge *= faktor
        self.anzeigen()
        #return

    def berechne_umfang(self,seitenlaenge):
        #U = 4*self.seitenlaenge
        #print U
        return 4 * self.seitenlänge

        print mein_Quadrat.berechne_umfang()

    def berechne_inhalt(self,seitenlaenge):
        #A = self.seitenlaenge**2
        #print A
        #return
        return self.seitenlänge**2

        print mein_Quadrat_.berechne_inhalt()
    
if __name__=="__main__":
    square = Quadrat(50,(0,0))
    square.anzeigen()
    Umfang = square.umfang(50)
    Inhalt = square.inhalt(50)
    square.verschieben((100,100))
    square.skalieren(4)

Code: Alles auswählen

Traceback (most recent call last):
  File "C:/Python25/Eigene/Quadrat.py", line 3, in <module>
    import Quadrat
  File "C:/Python25/Eigene\Quadrat.py", line 46
SyntaxError: Non-ASCII character '\xe4' in file C:/Python25/Eigene\Quadrat.py on line 46, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details (Quadrat.py, line 46)

Jetzt komme ich mit der Groß- und Kleinschreibung durcheinander.
In der Klasse wird der Name groß geschrieben.
class Quadrat:

In der Methode klein
def anzeigen()
skalieren()
usw


Beim Umfang verstehe ich es mit dem return, aber woher kommt das mein_quadrat? Muss es jetzt auch groß geschrieben werden?

Mit den Testläufen verstehe ich es nicht so ganz? Was bedeutet denn __main__? Ich weiss schonmal, dass es keine Funktion ist.

import Quadrat verstehe ich auch nicht. Wieso sollten da die testläufe nicht durchgehen??? Ich habe das Programm unter Quadrat.py abgespeichert.

Ich sag ja, ich tue mich wirklich schwer mit Python. Wundert mich, dass überhaupt was läuft.

Das mit dem frog kann ich etwas nachvollziehen, aber unser Dozent ist immer sehr skeptisch, wenn er etwas sieht, was er uns noch nicht vorgetragen hat. Deshalb bleibe ich lieber bei turtle.

[Dill]

Code: Alles auswählen

Traceback (most recent call last):
  File "C:/Python25/Eigene/Quadrat.py", line 3, in <module>
    import Quadrat
  File "C:/Python25/Eigene\Quadrat.py", line 46
SyntaxError: Non-ASCII character '\xe4' in file C:/Python25/Eigene\Quadrat.py on line 46, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details (Quadrat.py, line 46)

du hast einen umlaut in "seitenlänge". im code solltest du nur ascii-zeichen verwenden, ändere das also in seitenlaenge. in kommentaren sind umlaute natürlich in ordnung, werden aber auch angemeckert. daher musst du an den anfang des codes folgendes schreiben:

Code: Alles auswählen

#-*- coding: iso-8859-1 -*-

Jetzt komme ich mit der Groß- und Kleinschreibung durcheinander.
In der Klasse wird der Name groß geschrieben.
class Quadrat:

In der Methode klein
def anzeigen()
skalieren()
usw

Klassennamen schreibst du groß (In CamelCase), den rest klein (mit underscores). also auch eine instanz.

Code: Alles auswählen

class MeineKlasse:
   pass

eine_klasse = MeineKlasse()

Beim Umfang verstehe ich es mit dem return, aber woher kommt das mein_quadrat? Muss es jetzt auch groß geschrieben werden?

das mein_quadrat soll eine instanz von Quadrat sein. hab ich doch geschrieben. du hattest es square genannt, ws nicht schön ist, da du sonst alles in deutsch hast.

habe oben einfach folgendes ausgelassen:

Code: Alles auswählen

mein_quadrat = Quadrat()

Mit den Testläufen verstehe ich es nicht so ganz? Was bedeutet denn __main__? Ich weiss schonmal, dass es keine Funktion ist.

probier es doch einfach. schreib mal ein print __name__ an den anfang des skripts. und schau was passiert wenn du das skript direkt startest und was wenn du es importierst.

import Quadrat verstehe ich auch nicht. Wieso sollten da die testläufe nicht durchgehen??? Ich habe das Programm unter Quadrat.py abgespeichert.

das verstehst du dann wenn du obiges getestet hast.


du hast zwar noch einiges an arbeit vor dir mit dem code, aber das wird schon. ist noch kein kleister vom himmel gefallen.

[Sconine]

Es tut mir echt leid, aber ich bin jetzt total durcheinander.

square habe ich jetzt mein_quadrat genannt, da ich englisch und deutsch nicht mixen soll.

Code: Alles auswählen

import turtle

import Quadrat

class Quadrat:
    def __init__(self,seitenlaenge,zentrum):
        self.seitenlaenge = seitenlaenge
        self.zentrum = zentrum
       
    
    def anzeigen(self):
        angle = 90
        turtle.color("white")
        turtle.setx(self.zentrum[0]-0.5*self.seitenlaenge)
        turtle.sety(self.zentrum[1]-0.5*self.seitenlaenge)
        turtle.color("black")
        for i in range(4):
            turtle.forward(self.seitenlaenge)
            turtle.left(angle)
       
    
    def loeschen(self):
        turtle.color("white")
        angle = 90
        for i in range(4):
            turtle.forward(self.seitenlaenge)
            turtle.left(angle)
       
    
    def verschieben(self,neues_zentrum):
        self.loeschen()
        turtle.color("white")
        self.zentrum = neues_zentrum
        self.anzeigen()
        
    
    def skalieren(self,faktor):
        self.loeschen()
        self.seitenlaenge *= faktor
        self.anzeigen()
        

    def berechne_umfang(self,seitenlaenge):
        return 4 * self.seitenlänge
        print mein_Quadrat.berechne_umfang()

    def berechne_inhalt(self,seitenlaenge):
        return self.seitenlänge**2
        print mein_Quadrat_.berechne_inhalt()
    
if __name__=="__main__":
    mein_quadrat = Quadrat(50,(0,0))
    mein_quadrat.anzeigen()
    umfang = mein_quadrat.umfang(50)
    inhalt = mein_quadrat.inhalt(50)
    mein_quadrat.verschieben((100,100))
    mein_quadrat.skalieren(4)

Da mein Kopf schon völlig raucht, habe ich das mit dem print__name__ noch nicht ausprobiert.

Das erste Quadrat wird gezeichnet, aber dann kommt:

Code: Alles auswählen

Traceback (most recent call last):
  File "C:\Python25\Eigene\Quadrat.py", line 54, in <module>
    umfang = mein_quadrat.umfang(50)
AttributeError: Quadrat instance has no attribute 'umfang'

Habe gedacht, dass ich unten anstatt umfang, berechne_umfang schreiben muss, aber ich habe dann dieselbe Fehrlermeldung bekommen.

Ich bin echt nicht für das Programmieren geschaffen. [
Deshalb VIELEN DANK für eure "Geduld".

[Dill]

also seit weit sind wir nun wirklich noch nicht, dass programmiersprachen natürliche sprache verstehen.
du unterstellst ja, dass python das wort "berechne" versteht und daher aus der existenz der methode "berechne_umfang" folgert, dass es dir per mein_quadrat.umfang() diesen zurückgeben kann. ich hoffe du siehst ein, dass das unfug ist!

python ist das komplett egal wie du die methoden und klassen benennst (solage die namen gültig sind). Du könntest die klasse Quadrat _sogar_ "Kreis" nennen. python wäre das vollkommen egal. nur eben nicht den lesern des codes. beim vergeben von namen geht es allein darum den code lesbar zu machen.

also zu deinem problem:

Code: Alles auswählen

mein_quadrat.berechne_umfang()

wird sicher nicht den gleichen fehler produzieren, sondern einen anderen, nämlich: "self.seitenlänge gibt es nicht"

lösch doch endlich mal die überflüssigen parameter, in berechne_umfang "seitenlaenge". ist dir klar warum der überflüssig ist? (was ist self?)
und die prints hinter den return werden nie ereicht, da ist die funktion ja schon verlassen worden.

ich glaube, du solltest nochmal eine einführung zu python durcharbeiten.

http://docs.python.org/tutorial/
http://abop-german.berlios.de/

lass dich nicht entmutigen, aller anfang ist schwer.
vor allem bei der programmierung, das ist einfach ne andere welt

[Sconine]

Jetzt zeichnet er wieder alles, aber berechnet den Umfang und Inhalt nicht.

Code: Alles auswählen

import turtle

import Quadrat

class Quadrat:
    def __init__(self,seitenlaenge,zentrum):
        self.seitenlaenge = seitenlaenge
        self.zentrum = zentrum
       
    
    def anzeigen(self):
        angle = 90
        turtle.color("white")
        turtle.setx(self.zentrum[0]-0.5*self.seitenlaenge)
        turtle.sety(self.zentrum[1]-0.5*self.seitenlaenge)
        turtle.color("black")
        for i in range(4):
            turtle.forward(self.seitenlaenge)
            turtle.left(angle)
       
    
    def loeschen(self):
        turtle.color("white")
        angle = 90
        for i in range(4):
            turtle.forward(self.seitenlaenge)
            turtle.left(angle)
       
    
    def verschieben(self,neues_zentrum):
        self.loeschen()
        turtle.color("white")
        self.zentrum = neues_zentrum
        self.anzeigen()
        
    
    def skalieren(self,faktor):
        self.loeschen()
        self.seitenlaenge *= faktor
        self.anzeigen()
        

    def berechne_umfang(self,seitenlaenge):
        return 4 * self.seitenlaenge
        print mein_quadrat.berechne_umfang()

    def berechne_inhalt(self,seitenlaenge):
        return self.seitenlaenge**2
        print mein_quadrat_.berechne_inhalt()
    
if __name__=="__main__":
    mein_quadrat = Quadrat(50,(0,0))
    mein_quadrat.anzeigen()
    berechne_umfang = mein_quadrat.berechne_umfang(50)
    berechne_inhalt = mein_quadrat.berechne_inhalt(50)
    mein_quadrat.verschieben((100,100))
    mein_quadrat.skalieren(4)

Der Umfang und Inhalt sind doch definiert, wieso rechnet er jetzt nicht?

[Dill]

was bezweckst du mit dem

Code: Alles auswählen

import Quadrat

das brauchst du nur wenn du deine Quadrat klasse in einem _anderen_skript benutzen willst. hier kannst du das weglassen.

die werden schon berechnet, du gibst sie nur nicht aus.
wie gesagt, die prints in den methoden werden nicht erreicht.
bitte nimm dir die zeit die antworten in ruhe und gründlich zu lesen, das schont meine geduld.

noch ein paar anmerkungen:

Code: Alles auswählen

mein_quadrat = Quadrat(50,(0,0)) 
mein_quadrat.anzeigen() 
#das ist kein schöner name für eine variabel, nenne sie "umfang" oder 
#"berechneter_umfang" wegen mir 
berechne_umfang = mein_quadrat.berechne_umfang(50) 
#und hier ein print hin: 
print umfang #dazu musst du erst die variable umbennen!! dann gehts! 

#siehe oben
berechne_inhalt = mein_quadrat.berechne_inhalt(50) 
mein_quadrat.verschieben((100,100)) 
mein_quadrat.skalieren(4) 

[Sconine]

Ich weiß, ich weiß... Ich will alles immer schnell schnell machen und dann lese ich nicht richtig.

Jetzt läuft zum Glück alles.

Nochmal vielen, vielen, Dank für deine Geduld.

Code: Alles auswählen

import turtle

class Quadrat:
    def __init__(self,seitenlaenge,zentrum):
        self.seitenlaenge = seitenlaenge
        self.zentrum = zentrum
       
    
    def anzeigen(self):
        angle = 90
        turtle.color("white")
        turtle.setx(self.zentrum[0]-0.5*self.seitenlaenge)
        turtle.sety(self.zentrum[1]-0.5*self.seitenlaenge)
        turtle.color("black")
        for i in range(4):
            turtle.forward(self.seitenlaenge)
            turtle.left(angle)
       
    
    def loeschen(self):
        turtle.color("white")
        angle = 90
        for i in range(4):
            turtle.forward(self.seitenlaenge)
            turtle.left(angle)
       
    
    def verschieben(self,neues_zentrum):
        self.loeschen()
        turtle.color("white")
        self.zentrum = neues_zentrum
        self.anzeigen()
        
    
    def skalieren(self,faktor):
        self.loeschen()
        self.seitenlaenge *= faktor
        self.anzeigen()
        

    def umfang(self,seitenlaenge):
        return 4 * self.seitenlaenge
        print mein_quadrat.umfang()

    def inhalt(self,seitenlaenge):
        return self.seitenlaenge**2
        print mein_quadrat.inhalt()
    
if __name__=="__main__":    
    mein_quadrat = Quadrat(60,(0,0))
    mein_quadrat.anzeigen()
    umfang = mein_quadrat.umfang(60)
    print umfang
    inhalt = mein_quadrat.inhalt(60)
    print inhalt
    mein_quadrat.verschieben((100,100))
    mein_quadrat.skalieren(4)

Auch wenn es noch paar Schöheitsfehler gibt, kann ich die Lösung so abgeben. Das Programm läuft ja.

Und nochmal DANKE.

[Dill]

wenn du das so abgibst, wird sicher die frage kommen, was die paramter "seitenlaenge" bei umfang() und inhalt() sollen. entferne die noch, dann ist der code in ordnung.

schau dir mal __init__ an. da hast du seitenlaenge (sinnvollerweise) an die instanz gebunden. ab dann ist es ein attribut der instanz und kann von überall in der klasse erreicht werden über "self". das musst du dir glaub ich nochmal ansehen, was es mit diesem self auf sich hat.

[Sconine]

Wenn ich seitenlaenge wegnehme bei Umfang und Inhalt, bekomme ich schon wieder eine Fehlermeldung:

Code: Alles auswählen

Traceback (most recent call last):
  File "C:\Python25\Eigene\Quadrat.py", line 52, in <module>
    umfang = mein_quadrat.umfang(60)
TypeError: umfang() takes exactly 1 argument (2 given)

Warum ändert sich denn bei umfang etwas? Unten steht doch nichts mit seitenlängen, die ich hätte wegnehmen können.

Und schon wieder wird deine Geduld strapaziert.

Ich verstehe so langsam gar nix mehr.

[derdon]

Lass die 60 beim Aufruf weg. Die solltest du schon beim Aufruf von __init__ übergeben haben.

[Sconine]

Wow, es geht.

Ich glaube ich muss nochmal erklärt bekommen, was genau __init__ bedeutet, da ich nicht weiss, warum da schon die 60 drin steht.


Es wurde schon öfer probiert, aber irgendwie bleibt es nicht in mein Gehirn haften.

[Dill]

das sind ganz elementare dinge. wenn dir diese grundlagen nicht klar sind, machst du dir nur das leben schwer. arbeite lieber _in_ _ruhe_ nochmal ein tutorial durch. dann ordnet sich das alles etwas in deinem kopf.