Python objektorientierte Programmierung

Objektorientierte Python-Programmierung

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

Video:Objektorientierte Programmierung in Python

Objektorientierte Programmierung

Python ist eine Programmiersprache mit mehreren Paradigmen. Es unterstützt verschiedene Programmieransätze.

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

Ein Objekt hat zwei Eigenschaften:

Attribute
Verhalten

Nehmen wir ein Beispiel:

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 (Don't Repeat Yourself) bekannt.

In Python folgt das Konzept von OOP einigen Grundprinzipien:

Klasse

Eine Klasse ist eine Blaupause für das Objekt.

Wir können uns den Unterricht als Skizze eines Papageis mit Etiketten vorstellen. Es enthält alle Details über den Namen, die Farben, die Größe usw. Basierend auf diesen Beschreibungen können wir etwas über den Papagei studieren. Hier ist ein Papagei ein Objekt.

Das Beispiel für eine Papageienklasse kann sein:

class Parrot:
    pass

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

Objekt

Ein Objekt (Instanz) ist eine Instanziierung einer Klasse. Wenn die Klasse definiert ist, wird nur die Beschreibung für das Objekt definiert. Daher wird kein Arbeits- oder Speicher zugewiesen.

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

obj = Parrot()

Hier, obj ist ein Objekt der Klasse Parrot .

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

Beispiel 1:Klasse und Objekt in Python erstellen

class Parrot:

    # class attribute
    species = "bird"

    # 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 is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))

# access the instance attributes
print("{} is {} years old".format( blu.name, blu.age))
print("{} is {} years old".format( woo.name, woo.age))

Ausgabe

Blu is a bird
Woo is also a bird
Blu is 10 years old
Woo is 15 years old

Im obigen Programm haben wir eine Klasse mit dem Namen Papagei erstellt . Dann definieren wir Attribute. Die Attribute sind ein Merkmal eines Objekts.

Diese Attribute werden innerhalb von __init__ definiert Methode der Klasse. Es ist die Initialisierungsmethode, die zuerst ausgeführt wird, sobald das Objekt erstellt wird.

Dann erstellen wir Instanzen von Parrot Klasse. Hier, blu und woo sind Verweise (Wert) auf unsere neuen Objekte.

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

Um mehr über Klassen und Objekte zu erfahren, gehen Sie zu Python-Klassen und -Objekte

Methoden

Methoden sind Funktionen, die im Hauptteil einer Klasse definiert sind. Sie werden verwendet, um das Verhalten eines Objekts zu definieren.

Beispiel 2:Methoden in Python erstellen

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

    def dance(self):
        return "{} is now dancing".format(self.name)

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

# call our instance methods
print(blu.sing("'Happy'"))
print(blu.dance())

Ausgabe

Blu sings 'Happy'
Blu is now dancing

Im obigen Programm definieren wir zwei Methoden, dh sing() und dance() . Diese werden Instanzmethoden genannt, weil sie für ein Instanzobjekt aufgerufen werden, z. B. blu .

Vererbung

Vererbung ist eine Möglichkeit, eine neue Klasse zu erstellen, um Details einer vorhandenen Klasse zu verwenden, ohne sie zu ändern. Die neu gebildete Klasse ist eine abgeleitete Klasse (oder Kindklasse). Ebenso ist die vorhandene Klasse eine Basisklasse (oder Elternklasse).

Beispiel 3:Verwendung von Vererbung in Python

# parent class
class Bird:
    
    def __init__(self):
        print("Bird is ready")

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

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

# child class
class Penguin(Bird):

    def __init__(self):
        # call super() function
        super().__init__()
        print("Penguin is ready")

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

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

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

Ausgabe

Bird is ready
Penguin is ready
Penguin
Swim faster
Run faster

Im obigen Programm haben wir zwei Klassen erstellt, nämlich Bird (Elternklasse) und Pinguin (Kinderklasse). Die untergeordnete Klasse erbt die Funktionen der übergeordneten Klasse. Wir können dies anhand der swim() sehen Methode.

Auch hier hat die untergeordnete Klasse das Verhalten der übergeordneten Klasse geändert. Wir können dies aus dem whoisThis() ersehen Methode. Außerdem erweitern wir die Funktionen der übergeordneten Klasse, indem wir einen neuen run() erstellen Methode.

Zusätzlich verwenden wir den super() Funktion innerhalb des __init__() Methode. Dadurch können wir __init__() ausführen Methode der Elternklasse innerhalb der Kindklasse.

Kapselung

Mit OOP in Python können wir den Zugriff auf Methoden und Variablen einschränken. Dies verhindert, dass Daten direkt geändert werden, was als Kapselung bezeichnet wird. In Python bezeichnen wir private Attribute mit einem Unterstrich als Präfix, d. h. mit einem einzelnen _ oder doppelt __ .

Beispiel 4:Datenkapselung in Python

class Computer:

    def __init__(self):
        self.__maxprice = 900

    def sell(self):
        print("Selling Price: {}".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()

Ausgabe

Selling Price: 900
Selling Price: 900
Selling Price: 1000

Im obigen Programm haben wir einen Computer definiert Klasse.

Wir haben __init__() verwendet Methode zum Speichern des maximalen Verkaufspreises von Computer . Beachten Sie hier den Code

c.__maxprice = 1000

Hier haben wir versucht, den Wert von __maxprice zu ändern außerhalb der Klasse. Da jedoch __maxprice eine private Variable ist, wird diese Änderung in der Ausgabe nicht angezeigt.

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

Polymorphismus

Polymorphismus ist eine Fähigkeit (in OOP), eine gemeinsame Schnittstelle für mehrere Formulare (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 Form einzufärben. Dieses Konzept wird Polymorphismus genannt.

Beispiel 5:Verwendung von Polymorphismus in Python

class Parrot:

    def fly(self):
        print("Parrot can fly")
    
    def swim(self):
        print("Parrot can't swim")

class Penguin:

    def fly(self):
        print("Penguin can't fly")
    
    def swim(self):
        print("Penguin can swim")

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

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

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

Ausgabe

Parrot can fly
Penguin can't fly

Im obigen Programm haben wir zwei Klassen Parrot definiert und Pinguin . Jeder von ihnen hat einen gemeinsamen fly() Methode. Ihre Funktionen sind jedoch unterschiedlich.

Um Polymorphismus zu verwenden, haben wir eine gemeinsame Schnittstelle erstellt, z. B. flying_test() Funktion, die ein beliebiges Objekt nimmt und den fly() des Objekts aufruft Methode. Als wir also am blu vorbeikamen und peggy Objekte im flying_test() Funktion, es lief effektiv.

Wichtige Punkte, die Sie sich merken sollten:

Objektorientierte Programmierung macht das Programm leicht verständlich und effizient.
Da die Klasse teilbar ist, kann der Code wiederverwendet werden.
Daten sind dank Datenabstraktion sicher und geschützt.
Polymorphismus ermöglicht die gleiche Schnittstelle für verschiedene Objekte, sodass Programmierer effizienten Code schreiben können.

Benutzerdefinierte Python-Ausnahmen Python-Objekte und -Klassen

Python