Selles õpetuses saate näidete abil teada Pythoni objektipõhise programmeerimise (OOP) ja selle põhimõiste kohta.
Video: Objektorienteeritud programmeerimine Pythonis
Objektorienteeritud programmeerimine
Python on mitme paradigmaga programmeerimiskeel. See toetab erinevaid programmeerimisviise.
Üks populaarsemaid lähenemisviise programmeerimisprobleemi lahendamiseks on objektide loomine. Seda tuntakse kui objekti orienteeritud programmeerimist (OOP).
Objektil on kaks omadust:
- atribuudid
- käitumine
Võtame näite:
Papagoi võib olla objekt, kuna sellel on järgmised omadused:
- nimi, vanus, värv atribuutidena
- laulmine, tantsimine kui käitumine
OOP-i kontseptsioon Pythonis keskendub korduvkasutatava koodi loomisele. Seda kontseptsiooni tuntakse ka kui DRY (ära korrata ennast).
Pythonis järgib OOP mõiste mõningaid põhiprintsiipe:
Klass
Klass on objekti kavand.
Klassist võime mõelda papagoi visandit koos siltidega. See sisaldab kõiki üksikasju nime, värvide, suuruse jne kohta. Nende kirjelduste põhjal saame uurida papagoi kohta. Siin on papagoi objekt.
Papagoi klassi näide võib olla:
klass Papagoi: pass
Siin kasutame classmärksõna tühja klassi Parrot määratlemiseks. Tunnis konstrueerime eksemplare. Eksemplar on konkreetne klass, mis on loodud kindlast klassist.
Objekt
Objekt (eksemplar) on klassi eksemplar. Kui klass on määratletud, on määratletud ainult objekti kirjeldus. Seetõttu pole mälu ega salvestusruumi eraldatud.
Papagoi klassi objekti näide võib olla:
obj = Papagoi ()
Siin on obj klassi objekt Parrot.
Oletame, et meil on papagoidega seotud üksikasju. Nüüd näitame, kuidas ehitada papagoide klass ja objektid.
Näide 1: klassi ja objekti loomine Pythonis
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))
Väljund
Blu on lind Woo on ka lind Blu on 10-aastane Woo on 15-aastane
Ülalolevas programmis lõime klassi nimega Parrot. Seejärel määratleme atribuudid. Atribuudid on objektile iseloomulikud tunnused.
Need atribuudid on määratletud __init__klassi meetodi sees . Initsialiseerimismeetod käivitatakse esmakordselt kohe pärast objekti loomist.
Seejärel loome papagoi klassi eksemplarid. Siin on blu ja woo viited (väärtus) meie uutele objektidele.
Saame klassi atribuudile juurde pääseda __class__.species. Klassi atribuudid on kõigi klassi eksemplaride jaoks ühesugused. Samamoodi pääseme eksemplari atribuutidele juurde, kasutades blu.nameja blu.age. Ent eksemplari atribuudid on klassi igas eksemplaris erinevad.
Klasside ja objektide kohta lisateabe saamiseks minge saidile Pythoni klassid ja objektid
Meetodid
Meetodid on klassi kehas määratletud funktsioonid. Neid kasutatakse objekti käitumise määratlemiseks.
Näide 2: meetodite loomine Pythonis
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())
Väljund
Blu laulab 'Happy' Blu nüüd tantsib
Eespool programmi me defineerime kaks meetodit ehk sing()ja dance(). Neid nimetatakse eksemplarimeetoditeks, kuna neid kutsutakse eksemplari objektile, st blu.
Pärand
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.
Polümorfismi kasutamiseks lõime ühise liidese, st flying_test()funktsiooni, mis võtab mis tahes objekti ja kutsub objekti fly()meetodi. Seega, kui me blu ja peggy objektidest mööda läksime flying_test(), jooksis see tõhusalt.
Peamised meeldejäävad punktid:
- Objektorienteeritud programmeerimine muudab programmi nii arusaadavaks kui ka tõhusaks.
- Kuna klass on jagatav, saab koodi uuesti kasutada.
- Andmed on abstraheerimisel ohutud.
- Polümorfism võimaldab erinevatel objektidel sama liidest, nii et programmeerijad saavad kirjutada tõhusat koodi.
