In deze tutorial leer je met behulp van voorbeelden over Object-Oriented Programming (OOP) in Python en het fundamentele concept ervan.
Video: Objectgeoriënteerd programmeren in Python
Object georiënteerd programmeren
Python is een programmeertaal met meerdere paradigma's. Het ondersteunt verschillende programmeerbenaderingen.
Een van de populaire benaderingen om een programmeerprobleem op te lossen, is door objecten te maken. Dit staat bekend als Object-Oriented Programming (OOP).
Een object heeft twee kenmerken:
- attributen
- gedrag
Laten we een voorbeeld nemen:
Een papegaai kan een object zijn, aangezien het de volgende eigenschappen heeft:
- naam, leeftijd, kleur als attributen
- zingen, dansen als gedrag
Het concept van OOP in Python is gericht op het maken van herbruikbare code. Dit concept staat ook bekend als DRY (Don't Repeat Yourself).
In Python volgt het concept van OOP enkele basisprincipes:
Klasse
Een klasse is een blauwdruk voor het object.
We kunnen klasse zien als een schets van een papegaai met labels. Het bevat alle details over de naam, kleuren, maat etc. Op basis van deze beschrijvingen kunnen we bestuderen over de papegaai. Hier is een papegaai een object.
Het voorbeeld voor een papegaaiklasse kan zijn:
klasse Papegaai: geslaagd
Hier gebruiken we het classsleutelwoord om een lege klasse Parrot te definiëren. Vanuit klasse construeren we instanties. Een instantie is een specifiek object dat is gemaakt op basis van een bepaalde klasse.
Voorwerp
Een object (instantie) is een instantie van een klasse. Als klasse is gedefinieerd, wordt alleen de beschrijving voor het object gedefinieerd. Daarom wordt er geen geheugen of opslag toegewezen.
Het voorbeeld voor het object van de papegaaienklasse kan zijn:
obj = Papegaai ()
Hier is obj een klasseobject Parrot.
Stel dat we details van papegaaien hebben. Nu gaan we laten zien hoe we de klasse en objecten van papegaaien kunnen bouwen.
Voorbeeld 1: Klasse en object maken in Python
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))
Uitvoer
Blu is een vogel Woo is ook een vogel Blu is 10 jaar oud Woo is 15 jaar oud
In het bovenstaande programma hebben we een klas gemaakt met de naam Parrot. Vervolgens definiëren we attributen. De attributen zijn een kenmerk van een object.
Deze attributen worden gedefinieerd binnen de __init__methode van de klasse. Het is de initialisatiemethode die voor het eerst wordt uitgevoerd zodra het object is gemaakt.
Vervolgens maken we exemplaren van de Parrot-klasse. Hier zijn blu en woo verwijzingen (waarde) naar onze nieuwe objecten.
We hebben toegang tot het class-attribuut met __class__.species. Klasseattributen zijn hetzelfde voor alle instanties van een klasse. Evenzo openen we de instantiekenmerken met blu.nameen blu.age. Instantiekenmerken zijn echter verschillend voor elke instantie van een klasse.
Ga naar Python-klassen en -objecten voor meer informatie over klassen en objecten
Methoden
Methoden zijn functies die zijn gedefinieerd in de hoofdtekst van een klasse. Ze worden gebruikt om het gedrag van een object te definiëren.
Voorbeeld 2: methoden maken in Python
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())
Uitvoer
Blu zingt 'Happy' Blu danst nu
In het bovenstaande programma definiëren we twee methoden, namelijk sing()en dance(). Dit worden instantiemethoden genoemd omdat ze worden aangeroepen op een instantieobject, dwz blu.
Erfenis
Inheritance is a way of creating a new class for using details of an existing class without modifying it. The newly formed class is a derived class (or child class). Similarly, the existing class is a base class (or parent class).
Example 3: Use of Inheritance 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()
Output
Bird is ready Penguin is ready Penguin Swim faster Run faster
In the above program, we created two classes i.e. Bird (parent class) and Penguin (child class). The child class inherits the functions of parent class. We can see this from the swim() method.
Again, the child class modified the behavior of the parent class. We can see this from the whoisThis() method. Furthermore, we extend the functions of the parent class, by creating a new run() method.
Additionally, we use the super() function inside the __init__() method. This allows us to run the __init__() method of the parent class inside the child class.
Encapsulation
Using OOP in Python, we can restrict access to methods and variables. This prevents data from direct modification which is called encapsulation. In Python, we denote private attributes using underscore as the prefix i.e single _ or double __.
Example 4: Data Encapsulation 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()
Output
Selling Price: 900 Selling Price: 900 Selling Price: 1000
In the above program, we defined a Computer class.
We used __init__() method to store the maximum selling price of Computer. We tried to modify the price. However, we can't change it because Python treats the __maxprice as private attributes.
As shown, to change the value, we have to use a setter function i.e setMaxPrice() which takes price as a parameter.
Polymorphism
Polymorphism is an ability (in OOP) to use a common interface for multiple forms (data types).
Suppose, we need to color a shape, there are multiple shape options (rectangle, square, circle). However we could use the same method to color any shape. This concept is called Polymorphism.
Example 5: Using Polymorphism 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)
Output
Parrot can fly Penguin can't fly
In the above program, we defined two classes Parrot and Penguin. Each of them have a common fly() method. However, their functions are different.
Om polymorfisme te gebruiken, hebben we een gemeenschappelijke interface gemaakt, dwz een flying_test()functie die elk object accepteert en de fly()methode van het object aanroept. Dus toen we de blu- en peggy-objecten in de flying_test()functie passeerden , werkte deze effectief.
Belangrijke punten om te onthouden:
- Objectgeoriënteerd programmeren maakt het programma zowel gemakkelijk te begrijpen als efficiënt.
- Omdat de klasse deelbaar is, kan de code worden hergebruikt.
- Gegevens zijn veilig en beveiligd met gegevensonttrekking.
- Polymorfisme maakt dezelfde interface mogelijk voor verschillende objecten, zodat programmeurs efficiënte code kunnen schrijven.
