Objektorientiertes Programmieren in Python (OOP): Tutorial
Objektorientierte Programmierung ist ein weit verbreitetes Konzept, um leistungsfähige Anwendungen zu schreiben. Als Datenwissenschaftler/in musst du unter anderem Anwendungen schreiben, um deine Daten zu verarbeiten. In diesem Lernprogramm lernst du die Grundlagen der objektorientierten Programmierung in Python kennen. Du wirst Folgendes lernen:
- Wie man eine Klasse erstellt
- Objekte instanziieren
- Hinzufügen von Attributen zu einer Klasse
- Definieren von Methoden innerhalb einer Klasse
- Übergabe von Argumenten an Methoden
- Wie OOP in Python für das Finanzwesen genutzt werden kann
OOP: Einführung
Die objektorientierte Programmierung hat einige Vorteile gegenüber anderen Entwurfsmustern. Die Entwicklung ist schneller und billiger, und die Software lässt sich besser warten. Das wiederum führt zu einer qualitativ hochwertigeren Software, die auch mit neuen Methoden und Eigenschaften erweiterbar ist. Die Lernkurve ist jedoch steiler. Das Konzept kann für Anfänger zu komplex sein. OOP-Software ist rechnerisch langsamer und verbraucht mehr Speicher, da mehr Codezeilen geschrieben werden müssen.
Die objektorientierte Programmierung basiert auf dem imperativen Programmierparadigma, das Anweisungen verwendet, um den Zustand eines Programms zu verändern. Der Schwerpunkt liegt auf der Beschreibung, wie ein Programm funktionieren sollte. Beispiele für imperative Programmiersprachen sind C, C++, Java, Go, Ruby und Python. Dies steht im Gegensatz zur deklarativen Programmierung, die sich darauf konzentriert, was das Computerprogramm erreichen soll, ohne das Wie festzulegen. Beispiele dafür sind Datenbankabfragesprachen wie SQL und XQuery, bei denen man dem Computer nur sagt, welche Daten er wo abfragen soll, aber nicht, wie er das tun soll.
OOP verwendet das Konzept der Objekte und Klassen. Eine Klasse kann man sich als "Blaupause" für Objekte vorstellen. Diese können ihre eigenen Attribute (Eigenschaften, die sie besitzen) und Methoden (Aktionen, die sie ausführen) haben.
OOP Beispiel
Ein Beispiel für eine Klasse ist die Klasse Dog
. Denke nicht an einen bestimmten Hund oder an deinen eigenen Hund. Wir beschreiben, was ein Hund im Allgemeinen ist und tun kann. Hunde haben normalerweise eine name
und age
; dies sind Instanz-Attribute. Hunde können auch bark
; das ist eine Methode.
Wenn du über einen bestimmten Hund sprichst, würdest du in der Programmierung von einem Objekt sprechen: Ein Objekt ist eine Instanziierung einer Klasse. Das ist das Grundprinzip, auf dem die objektorientierte Programmierung beruht. So gehört mein Hund Ozzy zum Beispiel zur Klasse Dog
. Seine Attribute sind name = 'Ozzy'
und age = '2'
. Ein anderer Hund wird andere Eigenschaften haben.
Objektorientiertes Programmieren in Python
Ist Python objektorientiert?
Python ist eine großartige Programmiersprache, die OOP unterstützt. Du wirst sie benutzen, um eine Klasse mit Attributen und Methoden zu definieren, die du dann aufrufen wirst. Python bietet eine Reihe von Vorteilen im Vergleich zu anderen Programmiersprachen wie Java, C++ oder R. Es ist eine dynamische Sprache mit High-Level-Datentypen. Das bedeutet, dass die Entwicklung viel schneller geht als mit Java oder C++. Der Programmierer muss keine Typen von Variablen und Argumenten deklarieren. Dadurch ist Python auch für Anfänger leichter zu verstehen und zu erlernen, da der Code besser lesbar und intuitiv ist.
Wenn du neu in Python bist, solltest du dir den Kurs "Einführung in Python für Data Science " von DataCamp ansehen.
Wie man eine Klasse erstellt
Um eine Klasse in Python zu definieren, kannst du das Schlüsselwort class
verwenden, gefolgt von dem Klassennamen und einem Doppelpunkt. Innerhalb der Klasse muss eine __init__
Methode mit def
definiert werden. Dies ist der Initialisierer, den du später zum Instanziieren von Objekten verwenden kannst. Es ist ähnlich wie ein Konstruktor in Java. __init__
muss immer vorhanden sein! Sie benötigt ein Argument: self
, das sich auf das Objekt selbst bezieht. Innerhalb der Methode wird ab jetzt das Schlüsselwort pass
verwendet, weil Python erwartet, dass du dort etwas eingibst. Denke daran, die korrekte Einrückung zu verwenden!
class Dog:
def __init__(self):
pass
Hinweis: self
in Python ist gleichwertig mit this
in C++ oder Java.
In diesem Fall hast du eine (meist leere) Dog
Klasse, aber noch kein Objekt. Lass uns eine schaffen!
Python kostenlos lernen
Intermediate Python
Objekte instanziieren
Um ein Objekt zu instanziieren, gibst du den Klassennamen ein, gefolgt von zwei Klammern. Du kannst dies einer Variablen zuweisen, um das Objekt im Auge zu behalten.
ozzy = Dog()
print(ozzy)
<__main__.Dog object at 0x111f47278>
Hinzufügen von Attributen zu einer Klasse
Nach dem Ausdrucken von ozzy
ist klar, dass dieses Objekt ein Hund ist. Aber du hast noch keine Attribute hinzugefügt. Geben wir der Klasse Dog
einen Namen und ein Alter, indem wir sie umschreiben:
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
Du kannst sehen, dass die Funktion jetzt zwei Argumente nach self
benötigt: name
und age
. Diese werden dann self.name
bzw. self.age
zugewiesen. Du kannst jetzt ein neues ozzy
Objekt mit einem Namen und einem Alter erstellen:
ozzy = Dog("Ozzy", 2)
Um auf die Attribute eines Objekts in Python zuzugreifen, kannst du die Punktschreibweise verwenden. Dazu gibst du den Namen des Objekts ein, gefolgt von einem Punkt und dem Namen des Attributs
print(ozzy.name)
print(ozzy.age)
Ozzy
2
Dies kann auch in einem ausführlicheren Satz kombiniert werden:
print(ozzy.name + " is " + str(ozzy.age) + " year(s) old.")
Ozzy is 2 year(s) old.
Die Funktion str()
wird hier verwendet, um das Attribut age
, das eine ganze Zahl ist, in einen String umzuwandeln, damit du es in der Funktion print()
verwenden kannst.
Definiere Methoden in einer Klasse
Jetzt, wo du eine Klasse Dog
hast, hat sie zwar einen Namen und ein Alter, das du im Auge behalten kannst, aber sie tut eigentlich nichts. Hier kommen die Instanzmethoden ins Spiel. Du kannst die Klasse so umschreiben, dass sie jetzt eine bark()
Methode enthält. Beachte, dass das Schlüsselwort def
wieder verwendet wird, ebenso wie das Argument self
.
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print("bark bark!")
Die Methode bark
kann nun mit der Punktnotation aufgerufen werden, nachdem ein neues ozzy
Objekt instanziiert wurde. Die Methode sollte "bark bark!" auf dem Bildschirm ausgeben. Beachte die Klammern (geschweifte Klammern) in .bark()
. Diese werden immer beim Aufruf einer Methode verwendet. Sie sind in diesem Fall leer, da die Methode bark()
keine Argumente annimmt.
ozzy = Dog("Ozzy", 2)
ozzy.bark()
bark bark!
Weißt du noch, wie du vorhin ozzy
gedruckt hast? Der folgende Code implementiert diese Funktion in der Klasse Dog
mit der Methode doginfo()
. Dann instanziierst du einige Objekte mit verschiedenen Eigenschaften und rufst die Methode für sie auf.
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print("bark bark!")
def doginfo(self):
print(self.name + " is " + str(self.age) + " year(s) old.")
ozzy = Dog("Ozzy", 2)
skippy = Dog("Skippy", 12)
filou = Dog("Filou", 8)
ozzy.doginfo()
skippy.doginfo()
filou.doginfo()
Ozzy is 2 year(s) old.
Skippy is 12 year(s) old.
Filou is 8 year(s) old.
Wie du siehst, kannst du die Methode doginfo()
für Objekte mit der Punktschreibweise aufrufen. Die Antwort hängt nun davon ab, für welches Dog
Objekt du die Methode aufrufst.
Da Hunde älter werden, wäre es schön, wenn du ihr Alter entsprechend anpassen könntest. Ozzy ist gerade 3 Jahre alt geworden, also lass uns sein Alter ändern.
ozzy.age = 3
print(ozzy.age)
3
Es ist so einfach, wie dem Attribut einen neuen Wert zuzuweisen. Du könntest dies auch als birthday()
Methode in der Hundeklasse implementieren:
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print("bark bark!")
def doginfo(self):
print(self.name + " is " + str(self.age) + " year(s) old.")
def birthday(self):
self.age +=1
ozzy = Dog("Ozzy", 2)
print(ozzy.age)
2
ozzy.birthday()
print(ozzy.age)
3
Jetzt musst du das Alter des Hundes nicht mehr manuell ändern. Wann immer er Geburtstag hat, kannst du einfach die Methode birthday()
aufrufen.
Übergabe von Argumenten an Methoden
Du möchtest, dass unsere Hunde einen Kumpel haben. Dies sollte optional sein, da nicht alle Hunde so gesellig sind. Sieh dir die Methode setBuddy()
unten an. Sie nimmt wie üblich self
und buddy
als Argumente. In diesem Fall wird buddy
ein weiteres Dog
Objekt sein. Setze das Attribut self.buddy
auf buddy
, und das Attribut buddy.buddy
auf self
. Das bedeutet, dass die Beziehung auf Gegenseitigkeit beruht; du bist der Kumpel deines Kumpels. In diesem Fall wird Filou Ozzys Kumpel sein, was bedeutet, dass Ozzy automatisch Filous Kumpel wird. Du könntest diese Attribute auch manuell setzen, anstatt eine Methode zu definieren, aber das würde jedes Mal mehr Arbeit bedeuten (zwei Zeilen Code statt einer), wenn du einen Buddy setzen willst. Beachte, dass du in Python nicht angeben musst, welchen Typ das Argument hat. Wenn das Java wäre, wäre es Pflicht.
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
print("bark bark!")
def doginfo(self):
print(self.name + " is " + str(self.age) + " year(s) old.")
def birthday(self):
self.age +=1
def setBuddy(self, buddy):
self.buddy = buddy
buddy.buddy = self
Du kannst die Methode jetzt mit der Punktschreibweise aufrufen und ihr ein anderes Dog
Objekt übergeben. In diesem Fall wird Ozzys Kumpel Filou sein:
ozzy = Dog("Ozzy", 2)
filou = Dog("Filou", 8)
ozzy.setBuddy(filou)
Wenn du jetzt etwas über Ozzys Kumpel erfahren willst, kannst du die Punktschreibweise zweimal verwenden: Erstens, um sich auf Ozzys Kumpel zu beziehen, und ein zweites Mal, um sich auf sein Attribut zu beziehen.
print(ozzy.buddy.name)
print(ozzy.buddy.age)
Filou
8
Beachte, dass dies auch für Filou möglich ist.
print(filou.buddy.name)
print(filou.buddy.age)
Ozzy
2
Die Methoden des Buddys können auch aufgerufen werden. Das Argument self
, das an doginfo()
weitergegeben wird, ist jetzt ozzy.buddy
, das wiederum filou
ist.
ozzy.buddy.doginfo()
Filou is 8 year(s) old.
Python OOP Beispiel
Ein Beispiel dafür, wie nützlich die objektorientierte Programmierung in Python sein kann, ist unser Python For Finance: Algorithmischer Handel tutorial. Darin erklären wir, wie man eine Handelsstrategie für ein Aktienportfolio aufbaut. Die Handelsstrategie basiert auf dem gleitenden Durchschnitt eines Aktienkurses. Wenn signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:]
erfüllt ist, wird ein Signal erzeugt. Dieses Signal ist eine Vorhersage für die zukünftige Kursentwicklung der Aktie. Im folgenden Code siehst du, dass zuerst eine Initialisierung erfolgt, gefolgt von der Berechnung des gleitenden Durchschnitts und der Signalerzeugung. Da es sich nicht um objektorientierten Code handelt, ist es nur ein großer Brocken, der auf einmal ausgeführt wird. Beachte, dass wir in unserem Beispiel aapl
verwenden, den Börsenticker von Apple. Wenn du dies für einen anderen Bestand tun möchtest, müsstest du den Code neu schreiben.
# Initialize
short_window = 40
long_window = 100
signals = pd.DataFrame(index=aapl.index)
signals['signal'] = 0.0
# Create short simple moving average over the short window
signals['short_mavg'] = aapl['Close'].rolling(window=short_window, min_periods=1, center=False).mean()
# Create long simple moving average over the long window
signals['long_mavg'] = aapl['Close'].rolling(window=long_window, min_periods=1, center=False).mean()
# Create signals
signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:], 1.0, 0.0)
# Generate trading orders
signals['positions'] = signals['signal'].diff()
# Print `signals`
print(signals)
Bei einem objektorientierten Ansatz musst du den Code für die Initialisierung und die Signalerzeugung nur einmal schreiben. Du kannst dann für jede Aktie, für die du eine Strategie berechnen willst, ein neues Objekt erstellen und die Methode generate_signals()
aufrufen. Beachte, dass der OOP-Code dem obigen Code sehr ähnlich ist, mit dem Zusatz von self
.
class MovingAverage():
def __init__(self, symbol, bars, short_window, long_window):
self.symbol = symbol
self.bars = bars
self.short_window = short_window
self.long_window = long_window
def generate_signals(self):
signals = pd.DataFrame(index=self.bars.index)
signals['signal'] = 0.0
signals['short_mavg'] = bars['Close'].rolling(window=self.short_window, min_periods=1, center=False).mean()
signals['long_mavg'] = bars['Close'].rolling(window=self.long_window, min_periods=1, center=False).mean()
signals['signal'][self.short_window:] = np.where(signals['short_mavg'][self.short_window:] > signals['long_mavg'][self.short_window:], 1.0, 0.0)
signals['positions'] = signals['signal'].diff()
return signals
Du kannst jetzt einfach ein Objekt mit den gewünschten Parametern instanziieren und Signale für es erzeugen.
apple = MovingAverage('aapl', aapl, 40, 100)
print(apple.generate_signals())
Dies für eine andere Aktie zu tun, ist sehr einfach. Es geht nur darum, ein neues Objekt mit einem anderen Börsensymbol zu instanziieren.
microsoft = MovingAverage('msft', msft, 40, 100)
print(microsoft.generate_signals())
Objektorientiertes Programmieren in Python: Nachbereitung
Wir haben einige der wichtigsten OOPs-Konzepte in Python behandelt. Du weißt jetzt, wie man Klassen und Methoden deklariert, Objekte instanziiert, ihre Attribute setzt und Instanzmethoden aufruft. Diese Fähigkeiten werden dir in deiner zukünftigen Karriere als Datenwissenschaftler/in sehr nützlich sein. Wenn du die Schlüsselkonzepte, die du für deine Arbeit mit Python brauchst, vertiefen möchtest, solltest du dir unseren Kurs Python für Datenwissenschaftler/innen für Fortgeschrittene ansehen.
Mit OOP wird dein Code immer komplexer, je größer dein Programm wird. Du wirst verschiedene Klassen, Unterklassen, Objekte, Vererbung, Instanzmethoden und mehr haben. Du willst deinen Code gut strukturiert und lesbar halten. Dazu ist es ratsam, Entwurfsmustern zu folgen. Das sind Gestaltungsprinzipien, die eine Reihe von Richtlinien darstellen, um schlechtes Design zu vermeiden. Sie stehen jeweils für ein bestimmtes Problem, das in der Python OOP häufig auftritt, und beschreiben die Lösung für dieses Problem, die dann wiederholt verwendet werden kann. Diese OOP-Entwurfsmuster können in verschiedene Kategorien eingeteilt werden: Gestaltungsmuster, Strukturmuster und Verhaltensmuster. Ein Beispiel für ein Erstellungsmuster ist das Singleton, das verwendet werden sollte, wenn du sicherstellen willst, dass nur eine Instanz einer Klasse erstellt werden kann. Ein Python-Iterator, der verwendet wird, um eine Schleife über alle Objekte in einer Sammlung zu ziehen, ist ein Beispiel für ein Verhaltensmuster.
Python OOP FAQs
Was ist objektorientierte Programmierung (OOP)?
Die objektorientierte Programmierung ist ein Programmierparadigma, das auf dem Konzept der "Objekte" basiert, die Daten und Code enthalten können, der diese Daten manipuliert. In der OOP werden Objekte aus Vorlagen erstellt, die "Klassen" genannt werden und die Eigenschaften und das Verhalten der Objekte definieren, die sie erstellen. Mit OOP kannst du wiederverwendbaren Code erstellen und Konzepte aus der realen Welt genauer modellieren, was sie zu einer beliebten Wahl für viele Softwareprojekte macht.
Was sind Klassen und Objekte in Python?
In Python ist eine Klasse eine Vorlage für die Erstellung von Objekten. Sie legt die Eigenschaften und das Verhalten der Objekte fest, die daraus erstellt werden. Ein Objekt ist eine Instanz einer Klasse, die durch den Aufruf der Klasse wie eine Funktion erstellt wird. Das Objekt enthält die Daten und das Verhalten, die durch die Klasse definiert sind, sowie eine eindeutige Identität.
Wie kann ich eine Klasse in Python definieren?
Um eine Klasse in Python zu definieren, verwendest du das Schlüsselwort class
, gefolgt von dem Namen der Klasse und einem Doppelpunkt. Die Klassendefinition ist eingerückt, und der eingerückte Block enthält die Eigenschaften und Methoden (Funktionen), die zur Klasse gehören.
Wie erstelle ich in Python ein Objekt aus einer Klasse?
Um ein Objekt aus einer Klasse in Python zu erstellen, rufst du die Klasse wie eine Funktion auf und übergibst alle notwendigen Argumente an den Konstruktor der Klasse (die __init__-Methode).
Erfahre mehr über Python
Kurs
Objektorientierte Programmierung in Python
Kurs
Einführung in Python für Finanzen
Kurs