Python Objektorientierte Programmierung

Python Object Oriented Programming

In diesem Tutorial lernen Sie die objektorientierte Programmierung (OOP) in Python und deren grundlegendes Konzept anhand von Beispielen kennen.

 

Object Oriented Programming

 

Python ist eine Multi-Paradigma-Programmiersprache. Sie unterstützt verschiedene Programmieransätze.

Einer der beliebtesten Ansätze zur Lösung eines Programmierproblems ist die Erstellung von Objekten. Dies wird als objektorientierte Programmierung (OOP) bezeichnet.

Ein Objekt hat zwei Eigenschaften:

• attributes
• Verhalten

Lassen Sie uns ein Beispiel nehmen:

Ein Papagei ist ein Objekt, da er die folgenden Eigenschaften hat:

 

• Name, Alter, Farbe als Attribute
• Singen, Tanzen als Verhalten

 

Das Konzept von OOP in Python konzentriert sich auf die Erstellung von wiederverwendbarem Code. Dieses Konzept ist auch als DRY (Wiederhole dich nicht) bekannt.

In Python folgt das Konzept von OOP einigen grundlegenden Prinzipien:

 

---

 

 

Class

Eine Klasse ist eine Blaupause für das Objekt.

Wir können uns die Klasse als eine Skizze eines Papageis mit Beschriftungen vorstellen. Sie enthält alle Details über den Namen, die Farben, die Größe usw. Anhand dieser Beschreibungen können wir etwas über den Papagei lernen. Hier ist ein Papagei ein Objekt.

Das Beispiel für die Klasse des Papageis kann sein:

class Parrot:
    pass

 

Hier verwenden wir die class Schlüsselwort, um eine leere Klasse zu definieren Parrot. Aus einer Klasse konstruieren wir Instanzen. Eine Instanz ist ein bestimmtes Objekt, das aus einer bestimmten Klasse erzeugt wird.

 

---

 

 

Object

Ein Objekt (Instanz) ist eine Instanziierung einer Klasse. Bei der Definition einer Klasse wird nur die Beschreibung für das Objekt festgelegt. Daher wird kein Speicher oder Speicherplatz zugewiesen.

Das Beispiel für ein Objekt der Papageienklasse kann sein:

obj = Parrot()

 

 

Hier, obj ist ein Objekt der Klasse Parrot.

Angenommen, wir haben Details von Papageien. Jetzt werden wir zeigen, wie man die Klasse und die Objekte von Papageien erstellt.

 

Beispiel 1: Klasse und Objekt in Python anlegen

 

class Parrot:

    # class attribute
    species = "vogel"

    # instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age

# instantiate the Parrot class
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)

# access the class attributes
print("Blu ist eine {}".format(blu.__class__.species))
print("Woo ist auch ein {}".format(woo.__class__.species))

# access the instance attributes
print("{} ist {} jahre alt".format( blu.name, blu.age))
print("{} ist {} jahre alt".format( woo.name, woo.age))

 

 

Output

Blu ist ein Vogel
Woo ist auch ein Vogel
Blu ist 10 jahre alt
Woo ist 15 jahre alt

 

Im obigen Programm haben wir eine Klasse mit dem Namen Parrot. Dann definieren wir Attribute. Die Attribute sind eine Eigenschaft eines Objekts.

 

Diese Attribute werden innerhalb der __init__ methode der Klasse. Es ist die Initialisierungsmethode, die als erstes ausgeführt wird, sobald das Objekt erstellt wird.

 

Dann erzeugen wir Instanzen der Parrot Klasse. Hier, blu und woo sind Referenzen (Wert) auf unsere neuen Objekte.

 

Wir können auf das Klassenattribut mit __class__.species. Die Klassenattribute sind für alle Instanzen einer Klasse gleich. Entsprechend greifen wir auf die Instanzattribute mit blu.name und blu.age. Die Instanzattribute sind jedoch für jede Instanz einer Klasse unterschiedlich.

Um mehr über Klassen und Objekte zu erfahren, gehen Sie zu Python Classes and Objects.

 

---

 

 

Methods

Methoden sind Funktionen, die innerhalb des Körpers einer Klasse definiert sind. Sie werden verwendet, um das Verhalten eines Objekts zu definieren.

 

Beispiel 2 : Creating Methods in Python

 

class Parrot:
    
    # instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # instance method
    def sing(self, song):
        return "{} singt {}".format(self.name, song)

    def dance(self):
        return "{} tanzt jetzt".format(self.name)

# instantiate the object
blu = Parrot("Blu", 10)

# call our instance methods
print(blu.sing("'Glücklich'"))
print(blu.dance())

 

Output

Blu singt 'Glücklich'
Blu tanzt jetzt

 

In dem obigen Programm definieren wir zwei Methoden, d. h. sing() und dance(). Diese werden Instanzmethoden genannt, weil sie auf einem Instanzobjekt aufgerufen werden, d.h. blu.

 

---

 

 

Inheritance

Vererbung ist eine Möglichkeit, eine neue Klasse zu erstellen, um Details einer bestehenden Klasse zu verwenden, ohne diese zu verändern. Die neu gebildete Klasse ist eine abgeleitete Klasse (oder Kindklasse). Analog dazu ist die vorhandene Klasse eine Basisklasse (oder Elternklasse).

 

Beispiel 3: Use of Inheritance in Python

 

# parent class
class Bird:
    
    def __init__(self):
        print("Bird ist bereit")

    def whoisThis(self):
        print("Bird")

    def swim(self):
        print("Swim schneller")

# child class
class Penguin(Bird):

    def __init__(self):
        # call super() function
        super().__init__()
        print("Penguin ist bereit")

    def whoisThis(self):
        print("Penguin")

    def run(self):
        print("Run schneller")

peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

 

Output

Bird ist bereit
Penguin ist bereit
Penguin
Swim schneller
Run schneller

 

In dem obigen Programm haben wir zwei Klassen erstellt, d. h. Bird (parent class) und Penguin (Kindklasse). Die Kindklasse erbt die Funktionen der Elternklasse. Wir sehen dies an der swim() method.

 

Auch hier hat die untergeordnete Klasse das Verhalten der übergeordneten Klasse geändert. Dies können wir aus dem whoisThis() Methode. Außerdem erweitern wir die Funktionen der Elternklasse, indem wir eine neue run() method.

 

Zusätzlich verwenden wir die super() Funktion innerhalb der __init__() Methode. Dies erlaubt uns, die __init__() Methode der Elternklasse innerhalb der Kindklasse.

 

---

 

 

Encapsulation

Mit OOP in Python können wir den Zugriff auf Methoden und Variablen einschränken. Dadurch werden Daten vor direkter Veränderung geschützt, was als Kapselung bezeichnet wird. In Python bezeichnen wir private Attribute mit einem Unterstrich als Präfix, d. h. einfach _ or doppelt __.

 

Beispiel 4: Data Encapsulation in Python

 

class Computer:

    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print("Verkaufspreis: {}".format(self.__maxprice))

    def setMaxPrice(self, price):
        self.__maxprice = price

c = Computer()
c.sell()

# change the price
c.__maxprice = 1000
c.sell()

# using setter function
c.setMaxPrice(1000)
c.sell()

 

Output

Verkaufspreis: 900
Verkaufspreis: 900
Verkaufspreis: 1000

 

Im obigen Programm haben wir eine Computer Klasse.

 

Wir verwendeten __init__() Methode zum Speichern des maximalen Verkaufspreises von Computer. Wir haben versucht, den Preis zu ändern. Wir können ihn jedoch nicht ändern, weil Python den __maxprice als private Attribute.

 

Wie gezeigt, müssen wir, um den Wert zu ändern, eine Setter-Funktion verwenden, d. h. setMaxPrice() die den Preis als Parameter annimmt.

 

---

 

 

Polymorphism

Polymorphismus ist eine Fähigkeit (in OOP), eine gemeinsame Schnittstelle für mehrere Formen (Datentypen) zu verwenden.

Angenommen, wir müssen eine Form einfärben, es gibt mehrere Formoptionen (Rechteck, Quadrat, Kreis). Wir könnten jedoch dieselbe Methode verwenden, um jede beliebige Form einzufärben. Dieses Konzept wird als Polymorphismus bezeichnet.

 

Beispiel 5: Using Polymorphism in Python

 

class Parrot:

    def fly(self):
        print("Parrot kann fliegen")
    
    def swim(self):
        print("Parrot kann nicht schwimmen")

class Penguin:

    def fly(self):
        print("Penguin kann nicht fliegen")
    
    def swim(self):
        print("Penguin kann schwimmen")

# common interface
def flying_test(bird):
    bird.fly()

#instantiate objects
blu = Parrot()
peggy = Penguin()

# passing the object
flying_test(blu)
flying_test(peggy)

 

Output

Parrot kann fliegen
Penguin kann nicht fliegen

 

 

In dem obigen Programm haben wir zwei Klassen definiert Parrot und Penguin. Jede von ihnen hat eine gemeinsame fly() method. However, their functions are different.

 

Um den Polymorphismus zu nutzen, haben wir eine gemeinsame Schnittstelle geschaffen, d. h. flying_test() Funktion, die ein beliebiges Objekt annimmt und die fly() Methode des Objekts aufruft. Wenn wir also die blu und peggy Objekte in der flying_test() Funktion, lief es effektiv.

 

---