Python ist eine objektorientierte Programmiersprache. Objekte haben Eigenschaften (engl. states) und Fähigkeiten (engl. behaviors). Eine Klasse beschreibt, welche Eigenschaften und Fähigkeiten ein Objekt haben darf und stellt somit den Bauplan für jedes Objekt.
In diesem Artikel lernst Du den Aufbau von Objekten und Klassen und deren Anwendung kennen.
Stellen wir uns eine Herde vor, die aus vielen Schafen besteht. Dabei unterscheidet sich jedes Schaf in seinen Eigenschaften (Attribute) wie Name, Alter und Gewicht.
Jedes dieser Tiere gehört nun zur Gruppe der Schafe: Wir sprechen von der Klasse Schaf
. Ein Schaf mit dem Namen Emma, 20 Jahre und 40.3 kg ist ein Objekt (Instanz) der Klasse Schaf
. Diesen Bauplan den eine Klasse für Objekte bereitstellt kann man in einer Tabelle darstellen:
Objektnr. | Name | Alter | Gewicht |
0000 |
Emma | 20 | 40.3 |
0001 |
Berta | 12 | 25.0 |
Schaf
Wir definieren nun unsere erste Klasse Schaf. Jede Klasse beginnt mit dem Schlüsselwort class
und dem Klassennamen (hier Schaf
). Dabei ist darauf zu achten, dass der Klassenname mit einem Großbuchstaben beginnt.
Um nun Anfangswerte zu setzten verwendet man die Methode def __init__(self, ...)
. Diese Methode wird immer dann aufgerufen wenn eine neue Instanz angelegt wird. Somit können alle Attributwerte eines Objekts initialisiert werden.
self
ist verpflichtend, da wir diesen als Referenz für die später definierten Objekte benötigen.
#meine erste Klasse class Schaf: def __init__(self, name = "anyname", alter = 1, gewicht = 2.5): self.name = name self.alter = alter self.gewicht = gewicht #meine zweite Klasse class Schafherde: #Erzeuge meine ersten Objekte s1 = Schaf("Emma", 20, 40.3) s2 = Schaf(alter=3) #Zeige meine ersten Objekte an print(f"{s1.name}: ⌛ {s1.alter} Jahre + ⚖ {s1.gewicht} kg") print(f"{s2.name}: ⌛ {s2.alter} Jahre + ⚖ {s2.gewicht} kg")
Wir definieren unsere zweite Klasse Schafherde. In dieser werden einzelne Schafe als Objekte erzeugt, Attribute zugewiesen und die Werte ausgegeben.
Um in dieser Klasse ein Schaf zu erzeugen, wird nun die Klasse Schaf aufgerufen und Parameter aus dem Konstruktor als Startwerte mitgegeben. Das Schaf selbst wird als Variable abgespeichert, hat nun aber drei Eigenschaften: Name, Alter und Gewicht.
Abschließend können wir mit Hilfe des Objektnamens und mit Hilfe des Punktoperators auf die Eigenschaften der Objekte zugreifen (z.B. s1.alter
).
Erstelle die Klasse Schaf und Schafherde.
Schafherde.ipynb
im Ordner "10-Objektorientierung" an.Schaf
und deklariere drei Attribute (Eigenschaften). Achte darauf, dass du drei verschiedene Datentypen verwendest: String
, int
, double
und jedem Wert einem Standardwert (engl. default argument) mitgibst.Schafherde
. Erzeuge drei Schafe als Objekte (Instanzen) und weise jedem Schaf jeden Attributwert zu. Gib eine Liste der Werte für jedes Schaf aus.boolean geschlecht
hinzu. Lass den Benutzer wählen, ob er die Mutterschafe oder Schafböcke gelistet haben möchte.
Wähle weiblich für True
und männlich für False
.
Die Ausgabe sollte bspw. wie folgt aussehen:
Folgende Mutterschafe sind in der Herde:
Emma: ⌛ 20 Jahre + ⚖ 40.3 kg
anyname: ⌛ 3 Jahre + ⚖ 2.5 kg
Folgende Schafböcke sind in der Herde:
Günter: ⌛ 12 Jahre + ⚖ 62.0 kg
Erstelle die Klasse Auto und Fuhrpark.
Auto
und deklariere folgende Attribute (Eigenschaften) mit Standardwert des angegebenen Datentyps:String marke
,String modell
,String farbe
,int leistung
,double LiterPro100km
,double tankstand
,boolean tankwarnung
.Fuhrpark
. Erzeuge zwei Autos als Objekte und weise jedem Auto jeden Attributwert zu. Gib eine Liste der Werte für jedes Auto aus.tankwarnung = True
, empfehle das Tanken und gib in Abhängigkeit des Spritverbrauchs die Reichweite aus.Die Ausgabe sollte wie folgt aussehen:
Marke: VW
Typ: Polo
Verbrauch: 4.7 l/100 km
Tankstand: 3.2 l
Sie sollten tanken. Ihre Reichweite beträgt noch 68 km.
Objekte haben auch Fähigkeiten, welche in der Klasse als Methoden definiert werden. Wir haben bereits die fest verankerte Methode def __init__(self, ...)
, den sogenannten Konstruktor, kennen gelernt.
Wir können auch eigene Methoden schreiben. Damit ein Schaf bspw. einen Laut geben kann, definieren wir folgende Methode in der Klasse Schaf
:
def gebenLaut(self): print("mäh...")
Der Methodenaufruf in der Klasse Schafherde
ist objektgebunden und erfolgt mit dem Punktoperator.
s1.gebenLaut()
def fressenGras(self, menge = 1): self.gewicht += menge*0.5 if(menge >= 1): print("yummy...")
def erhalteGewicht(self): print("Ich gebe was zurück.") return self.gewicht
Möchte man ein Schaf Gras fressen lassen, ist es sinnvoll die Menge als Parameter zu übergeben. In der Methode kann man dann beispielsweise eine Gewichtszunahme in Abhängigkeit von der Grasmenge berechnen.
self
. Mit dem Punktoperator kann man so auf alle Attribute und sogar Methoden einer Klasse zugreifen.
Und noch ein Hinweis: Das Vorgeben von Standardwerten (engl. default arguments) macht das früher verwendete "Überladen von Methoden" hinfällig.
Eine weitere fest verankerte Methode ist die sogenannte to-String-Methode def __str__(self)
. Sie gibt einen String mit allen Eigenschaften des Objekts zurück. Durch den Aufruf des Parameters self.__class__.__name__
wird der Klassenname als String erzeugt.
Der Aufruf der Methode erfolgt einfach über print(s1)
. Ohne die to-String-Methode würden wir durch den Aufruf ldediglich die Adresse des Objekts erhalten.
def __str__(self): return self.__class__.__name__ + f" {self.name}: ⌛ {self.alter} Jahre + ⚖ {self.gewicht} kg"
Ideen: Klasse EFS222
Ordne die korrekte Antwort zu.
Erzeuge ein neues Objekt.
Wähle zwei Antworten.
a1 = Auto()
Auto a1 = new Auto()
a2 = Auto(ps = 120)
a2 = new Auto()
Erkläre den Begriff "Attribut".
Wähle eine Antwort.
Die Klasse Schaf
soll einen Konstruktor mit den beiden Parametern name
und gewicht
erhalten. Finde die Anzahl der Fehler im folgenden Quelltext.
class Schaf: def _init_(name="any",gewicht=2,0): self.name = name self.gewicht = gewicht
Der Konstruktor der Klasse Auto
hat die beiden vordefinierten Parameter marke
und ps
. Finde die Anzahl der korrekten Objekterzeugungen.
a1 = Auto() a2 = Auto("VW",200) a3 = Auto(200,"Audi") a4 = Auto(ps = 200)
Bestimme die zugehörige Methode, zum Methodenaufruf s1.fressenGras(4)
. Wähle eine Antwort.
def fressenGras(self, x, y): ...
class fressenGras def: ...
def fressenGras(self, x = 0): ...
return fressenGras(self, menge)...
Bestimme den Zweck des Schlüsselworts return
in Methoden.
Wähle eine Antwort.
private
Welchen Zweck erfüllt die to-string-Methode def __str__(self): ...
Wähle eine Antwort.
Bestimme den Zweck der Referenzvariable
self
in Python.
Wähle eine Antwort.
Die Schafe sollen mit Fähigkeiten ausgestattet werden.
Schaf
mit den vier folgenden Methoden:def gebenLaut (self):
,def fressen(self, mengeGras=0, mengeKohl=0):
,def erhalteGewicht(self):
,def __str__(self): ...
Schafherde
die neuen Funktionen ausführlich. Lass alle Änderungen der Attribute jeweils anzeigen.Schaf
eine weitere Funktionalität, welche das Niveau Deiner Objekte verbessert.Die Lösung sollte bspw. folgendermaßen aussehen:
Das weiße Schaf Emma sagt: Mäh!Die PKW's sollen mit Fähigkeiten ausgestattet werden.
Auto
mit den folgenden Methoden:def fahrenStrecke (self, km = 0): ..
,def tanken(self, menge = 1): ..
,def erhalteReichweite(self): ..
,def __str__(self):
Fuhrpark
die neuen Funktionen ausführlich. Lass alle Änderungen der Attribute jeweils anzeigen.0
eingibt. Bei einem Tankstand von weniger als 10 l wird eine Tankwarnung angezeigt und die Möglichkeit zum Tanken gegeben.Die Lösung sollte bspw. folgendermaßen aussehen:
Ihnen steht folgendes Autos zur Verfügung:100
j
Da die Objektnamen keinerlei Bedeutung haben, speichert man die verschiedenen Objekte direkt beim Erzeugen in einer Liste. Der große Vorteil der dadurch entsteht: Es können mit Hilfe von Schleifen automatisierte Ausgaben und Auswertungen aller Objekte generiert werden.
Mit der append(..)
-Methode wird ein Element der Liste hinzugefügt.
class Schafherde: schafliste = [] #drei neue Schafe erzeugen schafliste.append(Schaf("Emma", 20, 40.3)) schafliste.append(Schaf(alter = 3)) schafliste.append(Schaf()) #8 neue Schafe mit vorgegebenen Namen erzeugen und in der Schafliste abspeichern schafnamen = ["Emma", "Berta", "Schaun", "Alma", "Elias", "Uwe", "Sven", "Roman"] for i in schafnamen: schafliste.append(Schaf(i))
append(..)
Methode hinzu. So kann die Liste beliebig ergänzt werden.
In der for-each-Schleife werden alle Elemente der Liste abgefragt. for-each-Schleifen iterrieren über alle Datenstrukturen deren Elemente aufzählbar sind. Für die nummerierte Ausgabe, verwendet man die enumerate(..)
Methode.
Für die Berechnung des Mittelwerts addiert man mit Hilfe einer for-each-Schleife alle Werte und teilt diese durch die Anzahl der Werte. Um die Anzahl der Listenelemente zu ermitteln kommt die len(..)
-Methode zum Einsatz.
class Schafherde: ... #Ausgabe aller Schafe for schaf in schafliste: print(schaf) #nummerierte Ausgabe aller Schafe for i, schaf in enumerate(schafliste): print(i+1, schaf) #Berechnung des mittleren Herdenalters gesamt = 0 for schaf in schafliste: gesamt += schaf.alter print(f"Mittleres Herdenalter: {gesamt/len(schafliste)}")
For-each-Schleifen haben eine kürzere und übersichtlichere Syntax, um auf alle Elemente einer Liste zuzugreifen. Sie erlauben allerdings keinen direkten Zugriff auf den Schleifenzähler. Wird dieser benötigt verwendet man die enumerate(..)
-Methode
Realisiere eine Bücherei in der Bücher mit Titel, Autor und Bewertung gespeichert werden sollen.
Book
und Library
.Book
die Attribute title
, author
, rating
hinzu.Library
eine Liste mit Buchobjekten booklist.append(Book("Herr der Ringe", "J.R.R. Tolkien", 4.8));
.das Objekt, -e | Objekte haben Eigenschaften (engl. states) und Fähigkeiten (engl. behaviors). Diese werden in einer zugehörigen Klasse festgelegt. |
die Klasse, -n | Eine Klasse beschreibt, welche Eigenschaften und Fähigkeiten ein Objekt haben darf und stellt somit den Bauplan von Objekten bereit. |
die Fähigkeit, -en | Fähigkeiten von Objekten werden in Methoden beschrieben. |
die Eigenschaft, -en | Eigenschaften von Objekten werden in Attributen/Variablen festgelegt. |
der Standardwert, -e | Parameter einer Methoden können einen Standardwert (engl. default argument) erhalten. Dadurch wird das Überladen von Methoden hinfällig. |
das Überladen einer Methode | Existieren mehrere Methoden gleichen Namens spricht man vom Überladen. Dabei muss die Signatur eindeutig sein. In Python erübrigt sich das Überladen dank des Standardwertes |
die Signatur, -en | Methodenname und Parameter einer Methode. |
die Parameterliste, -n | eine Liste von Variablennamen, welche beim Methodenaufruf übergeben werden |