Python Object Oriented Programming
Table of Contents
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.
Wichtigste Punkte zum Merken:
- Die objektorientierte Programmierung macht das Programm sowohl leicht verständlich als auch effizient.
- Da die Klasse gemeinsam nutzbar ist, kann der Code wiederverwendet werden.
- Mit der Datenabstraktion sind die Daten sicher und geschützt.
- Polymorphismus ermöglicht die gleiche Schnittstelle für verschiedene Objekte, so dass Programmierer effizienten Code schreiben können.