Tässä opetusohjelmassa opit Object-Oriented Programming (OOP) -pythonista ja sen peruskäsitteestä esimerkkien avulla.
Video: olio-ohjelmointi Pythonissa
Olio-ohjelmointi
Python on moniparadigmainen ohjelmointikieli. Se tukee erilaisia ohjelmointitapoja.
Yksi suosituimmista lähestymistavoista ohjelmointiongelman ratkaisemiseen on esineiden luominen. Tätä kutsutaan olio-ohjelmoinniksi (OOP).
Kohteella on kaksi ominaisuutta:
- määritteet
- käyttäytymistä
Otetaan esimerkki:
Papukaija on voi olla objekti, koska sillä on seuraavat ominaisuudet:
- nimi, ikä, väri määritteinä
- laulaminen, tanssi käyttäytymisenä
Pythonin OOP-käsite keskittyy uudelleenkäytettävän koodin luomiseen. Tämä käsite tunnetaan myös nimellä DRY (Älä toista itseäsi).
Pythonissa OOP: n käsite noudattaa joitain perusperiaatteita:
Luokka
Luokka on objektin suunnitelma.
Voimme ajatella luokkaa luonnoksena papukaijasta, jossa on tarroja. Se sisältää kaikki yksityiskohdat nimestä, väreistä, koosta jne. Näiden kuvausten perusteella voimme tutkia papukaijaa. Tässä papukaija on esine.
Papukaijaluokan esimerkki voi olla:
luokka Papukaija: pass
Tässä käytämme classavainsanaa määritelläksesi tyhjän luokan Parrot. Luokasta rakennamme instansseja. Esimerkki on tietty objekti, joka on luotu tietystä luokasta.
Esine
Objekti (instanssi) on luokan instanssia. Kun luokka on määritelty, määritetään vain objektin kuvaus. Siksi muistia tai tallennustilaa ei ole varattu.
Papukaijaluokan objektin esimerkki voi olla:
obj = Papukaija ()
Tässä obj on luokan kohde Parrot.
Oletetaan, että meillä on papukaijojen yksityiskohtia. Nyt aiomme näyttää, kuinka rakentaa papukaijojen luokka ja esineet.
Esimerkki 1: Luokan ja objektin luominen Pythonissa
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))
Tuotos
Blu on lintu Woo on myös lintu Blu on 10-vuotias Woo on 15-vuotias
Yllä olevassa ohjelmassa loimme luokan nimeltä Papukaija. Sitten määritellään määritteet. Attribuutit ovat objektin ominaisuus.
Nämä määritteet määritellään __init__luokan menetelmän sisällä . Alustusmenetelmä suoritetaan ensin heti, kun objekti on luotu.
Sitten luomme Papukaija-luokan esiintymiä. Tässä blu ja woo ovat viittauksia (arvo) uusiin kohteisiimme.
Voimme käyttää luokan attribuuttia __class__.species. Luokan määritteet ovat samat kaikille luokan esiintymille. Samoin käytämme ilmentymämääritteitä käyttämällä blu.nameja blu.age. Ilmentymämääritteet ovat kuitenkin erilaiset luokan jokaisessa esiintymässä.
Jos haluat lisätietoja luokista ja objekteista, siirry kohtaan Pythonin luokat ja objektit
Menetelmät
Menetelmät ovat luokan rungossa määriteltyjä toimintoja. Niitä käytetään kohteen käyttäytymisen määrittelemiseen.
Esimerkki 2: Menetelmien luominen Pythonissa
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())
Tuotos
Blu laulaa 'Happy' Blu tanssii nyt
Edellä olevassa ohjelmassa määritellään kaksi menetelmää eli sing()ja dance(). Näitä kutsutaan ilmentymämenetelmiksi, koska ne kutsutaan ilmentymäobjektiin eli blu.
Perintö
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.
Polymorfismin käyttämiseksi loimme yhteisen käyttöliittymän eli flying_test()funktion, joka ottaa minkä tahansa objektin ja kutsuu objektin fly()menetelmää. Joten kun ohitimme blu ja peggy-objektit flying_test()toiminnossa, se juoksi tehokkaasti.
Tärkeimmät muistettavat asiat:
- Kohdekeskeinen ohjelmointi tekee ohjelmasta helpon ymmärrettävän ja tehokkaan.
- Koska luokka on jaettavissa, koodia voidaan käyttää uudelleen.
- Tiedot ovat turvallisia tietojen ottamisen avulla.
- Polymorfismi sallii saman käyttöliittymän eri kohteille, joten ohjelmoijat voivat kirjoittaa tehokkaan koodin.
