Ebben az oktatóanyagban példák segítségével megismerheti a Python objektumorientált programozását (OOP) és annak alapvető koncepcióját.
Videó: Objektumorientált programozás Pythonban
Objektumorientált programozás
A Python egy több paradigmás programnyelv. Támogatja a különböző programozási megközelítéseket.
A programozási probléma megoldásának egyik népszerű megközelítése az objektumok létrehozása. Ez az objektum-orientált programozás (OOP) néven ismert.
Az objektumnak két jellemzője van:
- attribútumok
- viselkedés
Vegyünk egy példát:
A papagáj lehet objektum, mivel a következő tulajdonságokkal rendelkezik:
- név, életkor, szín mint attribútum
- ének, tánc mint viselkedés
Az OOP fogalma a Pythonban az újrafelhasználható kód létrehozására összpontosít. Ezt a fogalmat DRY (Don't Repeat Yourself) néven is ismerik.
A Pythonban az OOP koncepciója néhány alapelvet követ:
Osztály
Az osztály az objektum tervrajza.
Úgy gondolhatunk az osztályra, mint egy papagáj vázlata címkékkel. Minden részletet tartalmaz a névről, a színekről, a méretről stb. Ezen leírások alapján tanulmányozhatjuk a papagájról. Itt a papagáj egy tárgy.
A papagáj osztályára példa lehet:
osztály Papagáj: bérlet
Itt a classkulcsszóval definiálhatunk egy üres osztályt Papagáj. Osztályból konstruálunk példányokat. A példány egy adott objektum, amelyet egy adott osztály hoz létre.
Tárgy
Az objektum (példány) egy osztály példányosítása. Osztály megadásakor csak az objektum leírása kerül meghatározásra. Ezért nincs memória vagy tárhely kiosztva.
A papagáj osztály objektumára példa lehet:
obj = Papagáj ()
Itt az obj az osztály objektuma Parrot.
Tegyük fel, hogy vannak részleteink a papagájokról. Most megmutatjuk, hogyan kell felépíteni a papagájok osztályát és tárgyait.
1. példa: Osztály és objektum létrehozása Pythonban
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))
Kimenet
Blu madár Woo is madár Blu 10 éves Woo 15 éves
A fenti programban létrehoztunk egy osztályt Papagáj néven. Ezután meghatározzuk az attribútumokat. Az attribútumok az objektum jellemzői.
Ezeket az attribútumokat __init__az osztály metódusán belül határozzuk meg . Ez az inicializáló módszer, amelyet először az objektum létrehozása után futtatnak.
Ezután létrehozzuk a Papagáj osztály példányait. Itt a blu és a woo az új objektumainkra utaló érték (érték).
A class attribútum használatával elérhetjük __class__.species. Az osztály attribútumai megegyeznek az osztály minden példányában. Hasonlóképpen, a blu.nameés használatával érjük el a példányattribútumokat blu.age. A példányattribútumok azonban az osztály minden példányánál eltérőek.
Ha többet szeretne megtudni az osztályokról és az objektumokról, keresse fel a Python osztályok és objektumok oldalt
Mód
A módszerek az osztály testén belül definiált függvények. Egy objektum viselkedésének meghatározására szolgálnak.
2. példa: Módszerek létrehozása a Pythonban
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())
Kimenet
Blu énekli a „Happy” -et. Blu most táncol
A fenti programban két módszert határozunk meg, azaz sing()és dance(). Ezeket azért hívjuk példány metódusoknak, mert egy példány objektumra hívják őket, azaz blu.
Öröklés
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.
A polimorfizmus használatához létrehoztunk egy közös felületet, azaz egy olyan flying_test()függvényt, amely bármely objektumot felveszi és meghívja az objektum fly()metódusát. Így amikor elhaladtunk a blu és peggy objektumok mellett a flying_test()funkcióban, az hatékonyan futott.
Fontos megjegyezni:
- Az objektum-orientált programozás megkönnyíti a program érthetőségét és hatékonyságát.
- Mivel az osztály megosztható, a kód újból felhasználható.
- Az adatok biztonságosak és biztonságosak absztrakcióval.
- A polimorfizmus ugyanazt az interfészt teszi lehetővé a különböző objektumok számára, így a programozók hatékony kódot tudnak írni.
