Nachdem wir uns in den vergangenen Beiträgen bereits mit der objektorientierten Programmierung beschäftigt haben, werden wir heute zum Abschluss dieser Tutorial-Reihe die Python Methoden genauer unter die Lupe nehmen.
Sie sehen gerade einen Platzhalterinhalt von Youtube. Um auf den eigentlichen Inhalt zuzugreifen, klicken Sie auf die Schaltfläche unten. Bitte beachten Sie, dass dabei Daten an Drittanbieter weitergegeben werden.
Mehr InformationenInhaltsverzeichnis
1. Rückblick und Zusammenfassung der Objektorientierung
Wie bereits eingangs erwähnt, wird sich dieser Blogartikel um das Thema Python Methoden drehen. Da es zudem der letzte Beitrag dieser aufeinander aufbauenden Tutorial-Reihe ist, werde ich dir am Ende noch eine Option aufzeigen, mit der du noch wesentlich tiefer in die Materie einsteigen kannst.
Fassen wir an dieser Stelle noch einmal zusammen, was wir bisher über die objektorientierte Programmierung gelernt haben. Im 21. Teil dieser Reihe haben wir uns zunächst das Prinzip der objektorientierten Programmierung angesehen. Kurz zusammengefasst lässt sich sagen, dass wir mithilfe der objektorientierten Programmierung versuchen, komplexe Objekte aus der realen Welt innerhalb unserer Programme nachzumodellieren.
Um das technisch innerhalb unserer Programme umsetzen zu können, hast du in Beitrag 22 erfahren, wie man sich sogenannten Klassen definiert und wie man diesen Attribute übergibt. Diese Attribute legen wir innerhalb der init-Methode fest. Sie beschreiben die Eigenschaften unseres zu modellierenden Objekts.
Anschließend haben wir gelernt, dass die Klasse an sich lediglich den Bauplan darstellt. Erst wenn wir von einer Klasse ein oder mehrere Objekte erzeugt haben, können wir mit diesen innerhalb unseres Programms tatsächlich arbeiten. Beim Erzeugen eines Objekts reserviert das Programm intern den erforderlichen Speicher dafür. Alle Daten, die das Objekt betreffen, werden dann im reservierten Speicherbereich festgehalten. Das können zum Beispiel die einzelnen Attribute eines Objekts sein.
Mithilfe des Punkt-Operators haben wir dann eine Schreibweise kennengelernt, mit der wir über die Referenz eines Objekts auf die spezifischen Attribute zugreifen können.
Damit steht uns bisher also schon die Möglichkeit zur Verfügung, mithilfe von Klassen unsere eigenen Datentypen zu bauen. In diesen können wir dann Attribute, die nur Objekte von diesen Typen betreffen sollen, gruppieren.
2. Python Methoden definieren
2.1. Sinn von Python Methoden innerhalb einer Klasse
An dieser Stelle werden wir den Gedanken der Objektorientierung noch etwas weiterspinnen. Bis zum aktuellen Zeitpunkt haben wir innerhalb des Beispiels zwei Car-Objekte erzeugt, die jeweils drei Attribute besitzen. Das Ganze wirkt aktuell allerdings noch etwas starr. Schließlich haben die Car-Objekte derzeit nur Eigenschaften, jedoch noch keine Funktionalität.
Das Auto kann beispielsweise noch nicht einmal fahren, da wir noch keine Funktionalität dafür implementiert haben. Damit sich ein Car-Objekt innerhalb unseres Programms auch fortbewegen kann, müssen wir also noch etwas programmieren. Sinnvolle Funktionalitäten wie das Fahren des Autos setzt man über sogenannte Methoden um.
Dabei sind in Python Methoden, wie bereits in einem vorherigen Artikel beschrieben, Funktionen, die wir innerhalb einer Klasse definieren. Verwenden können sie deshalb auch nur Objekte dieser Klasse.
2.2. Schritt 1: Methodenkopf definieren
Jetzt möchten wir die aktuelle Car-Klasse um eine Funktionalität erweitern, sodass sich das Car-Objekt auch fortbewegen kann. Hierzu definieren wir innerhalb der Klasse Car eine neue Methode.
Das heißt: Wir leiten in Python Methoden durch das Schlüsselwort def ein. Das geschieht auf der Einrückungshöhe der init-Methode, da wir uns so im Klassenblock der Klasse Car befinden.
Anschließend geben wir der Methode den sprechenden Bezeichner drive, da sie schließlich die Fahrfunktionalität ermöglichen soll. Als ersten Parameter übergeben wir dieser dann, wie auch bei der init-Methode, den self-Parameter:
Der self-Parameter ermöglicht uns innerhalb des Methodenkörpers auf das aufrufende Objekt zu referenzieren. Dass dies notwendig sein wird, wirst du in Kürze sehen.
Somit haben wir den Methodenkopf auch schon definiert.
2.3. Schritt 2: Methodenkörper definieren
Innerhalb des Methodenkörpers müssen wir nun noch die Logik implementieren. Diese soll die Fortbewegung des entsprechenden Car-Objekts ermöglichen. Die Logik kannst du auf kreative Art und Weise nach Belieben implementieren.
Für unser Beispiel wählen wir nun eine relativ einfache Variante. Dafür stellen wir die Bewegung eines Car-Objekts über eine Konsolenausgabe über die Koordinaten eines zweidimensionalen Feldes dar.
Es existieren also eine x- und eine y-Koordinate. Mit der x-Koordinate simulieren wird die horizontale Bewegung innerhalb des zweidimensionalen Feldes und mit der y-Koordinate die vertikale Bewegung. Damit jedes Car-Objekt auch eine x- und eine y-Koordinate besitzt, die dessen Standort beschreibt, müssen wir innerhalb der init-Methode noch diese beiden Koordinaten als Attribute definieren:
Durch die beiden zusätzlichen Attribute besitzt nun jedes Car-Objekt einen eindeutigen Positionswert innerhalb eines zweidimensionalen Feldes.
Die folgende Skizze zeigt, wie man sich dieses zweidimensionale Feld vorstellen kann:
Oben sehen wir die x-Achse. Diese startet ganz links oben in der Ecke beim Wert 0. Je weiter man auf der x-Achse nach rechts geht, desto höher wird der x-Wert.
Nach unten verläuft die y-Achse. Auch bei der y-Achse startet man oben links in der Ecke beim Wert 0. Je weiter man auf der y-Achse nach unten geht, desto höher wird der y-Wert.
Aktuell setzen wir in der init-Methode standardmäßig sowohl für x_position, als auch für y_position den Wert 5. Erzeugen wir also ein Car-Objekt, steht es zu Beginn immer an der Stelle, an der das Kreuz eingezeichnet ist:
Mithilfe der drive()-Methode, die wir jetzt implementieren möchten, können wir dank des x- und y-Positionswertes nun auf einfache Art und Weise die Fahrt des Autos simulieren.
Hierzu müssen wir der Methode neben dem self-Parameter noch zwei weitere Parameter übergeben: den Parameter x und den Parameter y.
Mithilfe dieser beiden zusätzlichen Parameter können wir beim Methodenaufruf festlegen, wie weit sich das Car-Objekt sowohl auf der x-Achse als auch auf der y-Achse bewegen soll. Dafür definieren wir die entsprechende Logik nun im Methodenkörper:
3. Allgemeine Funktionsweise der Python Methoden
Unsere eben definierte Python Methode funktioniert also folgendermaßen: Wir rufen sie auf und übergeben den entsprechenden x- und y-Wert, um den sich das Car-Objekt bewegen soll. Durch die Methode wird nun der übergebene x-Wert auf den aktuellen x-Positionswert addiert.
Beim y-Wert geschieht das Gleiche: Der übergebene y-Wert wird auf den aktuellen y-Positionswert addiert.
An dieser Stelle überprüfen wir einfach mal, ob alles so funktioniert, wie wir es uns vorstellen. Wie wir bereits wissen, steht das Car-Objekt bei seiner Erzeugung zu Beginn auf der Position x = 5 und y = 5. So haben wir es schließlich in der init-Methode definiert.
Um zu überprüfen, ob sich das erste erzeugte Car-Objekt tatsächlich auf der definierten Position befindet, lassen wir uns den Inhalt des x_position-Attributs und des y_position-Attributs mithilfe der print-Funktion auf der Konsole ausgeben:
Führen wir das Programm nun aus, können wir sehr gut erkennen, dass das Car-Objekt tatsächlich auf der Position x = 5 und y = 5 steht:
Jetzt testen wir die drive()-Methode, indem wir sie aufrufen:
Wie du sehen kannst, wird uns drive() nun rot unterringelt. Die Methode scheint also nicht wirklich zu existieren. Das ist deshalb der Fall, weil wir diese Methode nicht als allgemeine Funktion definiert haben, sondern innerhalb der Klasse Car.
Das bedeutet: Nur Car-Objekte können diese Methode aufrufen. Und das funktioniert genauso, wie wir auch auf spezifische Attribute eines Car-Objekts zugreifen können.
4. Python Methoden richtig aufrufen
Zunächst benötigen wir also die Referenz auf ein Car-Objekt, die aktuell in der Variable car1 gespeichert ist. Wir schreiben also car1, gefolgt von einem Punkt und dem entsprechenden Methodennamen (drive()).
Jetzt müssen wir noch die Parameter übergeben, die die Methode erwartet. Wenn wir uns die Definition der Methode noch einmal kurz ansehen, stellen wir fest, dass drei Parameter erwartet werden: self, x und y.
Self müssen wir nicht übergeben, da dies automatisch erfolgt. Genau wie im Fall der init-Methode übernimmt diese Aufgabe Python für uns. Python nimmt also die Referenz vom aufrufenden Objekt, in diesem Fall die Referenz, die in car1 gespeichert ist und lädt sie in den Parameter self.
Wir müssen also nur noch x und y übergeben. Geben wir für unser Beispiel also einfach mal vor, dass sich das Auto auf der x-Achse um 5 fortbewegen soll und auf der y-Achse um 10. Anschließend rufen wir die beiden print-Anweisungen nochmals auf, mit denen wir sowohl den aktuellen x- als auch den aktuellen y-Positionswert ausgeben lassen:
Wenn wir das Programm nun ausführen, sollten wir eine Positionsveränderung des Car-Objekts feststellen:
Wie du sehen kannst: Es hat funktioniert!
Der x-Wert war ursprünglich auf 5 und ist nun auf 10, weil wir die 5 übergeben haben. Y war eingangs auf 5 und ist nun auf 15, da wir die 10 als Parameter an die drive()-Methode übergeben haben.
Hier macht sich auch schon ein großer Vorteil der objektorientierten Programmierung erkennbar. Es können nämlich nur Objekte vom Typ Car in unserem aktuellen Fall die Methode drive aufrufen.
Das macht wiederum Sinn, da die Methode drive() so implementiert wurde, dass sie mit den Attributen x_position und y_position arbeitet. Wenn jedes x-beliebige Objekt von anderen Typen auch diese Methode aufrufen könnte, wäre das relativ sinnlos. Letztlich besitzen diese Objekte möglicherweise gar nicht die Attribute x_position bzw. y_position. Folglich würde die Implementierung auch nicht passen.
So wie wir eben die drive()-Methode implementiert haben, könnten wir auch jede beliebige andere Funktionalität für Car-Objekte implementieren. Umsetzen lässt sich das, indem wir weitere Python Methoden zur Klasse Car hinzufügen und dort die gewünschte Logik hinterlegen.
5. Der nächste Schritt: Der Python Masterkurs
An dieser Stelle sind wir tatsächlich auch schon am Ende dieses Crashkurses angelangt. Im Verlauf dieser Reihe hast du schon die wichtigsten Grundlagen der Python Programmierung kennengelernt. Dazu möchte ich dir erst mal gratulieren!
Selbstverständlich ist die Programmiersprache Python noch wesentlich umfangreicher, sodass sie sich nicht vollständig in diesen 24 Tutorials abbilden lässt. Es gibt also zum einen noch zahlreiche fortgeschrittene Themen, die du dir auf deinem weiteren Weg als Python Programmierer noch aneignen musst. Doch auch die gelehrten Grundlagen können noch um viele Feinheiten ergänzt werden.
Nehmen wir beispielsweise das zuletzt angesprochene Thema der objektorientierten Programmierung. Bei den Inhalten, die du hier gelernt hast, handelt es sich wirklich um die gröbsten Grundlagen. Das Thema ist also noch wesentlich umfangreicher und es gibt noch einiges mehr hierzu zu lernen. Angefangen bei den Namenskonventionen bis hin zur Vererbung, dem Überschreiben von Methoden, der super()-Funktion, dem Name Mangling und vielem mehr.
Auch zum Thema Funktionen aus den Blogartikeln 18, 19 und 20 gibt es beispielsweise noch einiges zu erzählen. So gibt es Funktionen mit optionalen Parametern und Schlüsselwort-Parameter. Außerdem besteht die Möglichkeit, Funktionen so zu definieren, dass wir ihnen beliebig viele Parameter übergeben können. Darüber hinaus existieren sogenannte Namensbereiche und vieles mehr.
Genau das ist der Grund, weshalb wir für dieses umfassende Thema der Python Programmierung einen kompletten Masterkurs entwickelt haben. In dieser Tutorial-Reihe hast du bereits einen Vorgeschmack auf den didaktischen Aufbau des Masterkurses erhalten.
In diesem haben wir genau darauf geachtet, das Thema Python Programmieren von 0 an so zu strukturieren, dass es wirklich jeder versteht. Aufgrund der Vielfalt an Themen, die inkludiert werden müssen, war das teilweise ziemlich herausfordernd. Unserer Meinung nach ist daraus aber eine sehr gute Komplettlösung entstanden und auch die bisherigen Kundenfeedbacks, die wir dazu erhalten haben, bestätigen uns das.
Eine ebenfalls äußerst wichtige Komponente des Python Masterkurses ist, dass die gelehrte Theorie mit zahlreichen Übungsaufgaben, Quizfragen und Praxisprojekten vertieft wird. So lernst du, die Theorie auch wirklich in der Praxis bei eigenen Projekten anzuwenden. Für die Übungsaufgaben und Praxisprojekte stellen wir dir selbstverständlich umfassende Lösungsvideos zur Verfügung.
In einem Praxisprojekt lernst du zum Beispiel, wie du das Spiel Space Invaders in einer objektorientierten Variante Schritt für Schritt programmieren kannst. Das zeigen wir dir innerhalb von elf umfassenden Videos.
Zusätzlich stehen dir zu den einzelnen Modulen auch herunterladbare Zusammenfassungen zur Verfügung, die du als Cheat Sheets verwenden kannst. Wenn du also an deinen eigenen Projekten arbeitest, kannst du jederzeit auf die Zusammenfassungen zurückblicken und dir kleine Details dadurch noch mal in Erinnerung rufen.
Wie du vielleicht schon merkst, haben wir in den Python Masterkurs eine Menge Herzblut gesteckt, sodass wir mit diesem eine umfassende All-in-One Komplettlösung geschaffen haben, um das Programmieren in Python sauber zu lernen.
Da es sich um einen Online-Kurs handelt, haben wir sogar den Vorteil, den Kurs zukünftig noch erweitern zu können. Das heißt, dass wir im Laufe der Zeit weitere Module zum Python Masterkurs hinzufügen werden, sodass dieser immer umfassender wird. Wenn du ihn einmal erworben hast, erhältst du natürlich auch diese zusätzlichen Updates in Zukunft automatisch und kostenlos freigeschaltet.
Wenn du es also wirklich ernst mit Python meinst, empfehlen wir dir, auf den jetzt folgenden Button zu klicken, der dich direkt zum Python Masterkurs bringt. Auf der Seite erhältst du dann noch viele weitere Informationen zum Kurs.