În acest tutorial, veți afla despre programarea orientată pe obiecte (OOP) în Python și conceptul său fundamental cu ajutorul exemplelor.
Video: Programare orientată pe obiecte în Python
Programare orientată pe obiecte
Python este un limbaj de programare multi-paradigmă. Suportă diferite abordări de programare.
Una dintre abordările populare pentru a rezolva o problemă de programare este prin crearea de obiecte. Aceasta este cunoscută sub numele de Programare Orientată pe Obiecte (OOP).
Un obiect are două caracteristici:
- atribute
- comportament
Să luăm un exemplu:
Un papagal poate fi un obiect, deoarece are următoarele proprietăți:
- numele, vârsta, culoarea ca atribute
- cântând, dansând ca comportament
Conceptul de OOP în Python se concentrează pe crearea unui cod reutilizabil. Acest concept este, de asemenea, cunoscut sub numele de DRY (Don't Repeat Yourself).
În Python, conceptul de OOP urmează câteva principii de bază:
Clasă
O clasă este un plan pentru obiect.
Ne putem gândi la clasă ca la o schiță a unui papagal cu etichete. Conține toate detaliile despre nume, culori, dimensiuni etc. Pe baza acestor descrieri, putem studia despre papagal. Aici, un papagal este un obiect.
Exemplul pentru clasa de papagal poate fi:
clasa Papagal: trece
Aici, folosim classcuvântul cheie pentru a defini o clasă goală Parrot. Din clasă, construim instanțe. O instanță este un obiect specific creat dintr-o anumită clasă.
Obiect
Un obiect (instanță) este o instanțiere a unei clase. Când este definită clasa, este definită doar descrierea obiectului. Prin urmare, nu este alocată memorie sau stocare.
Exemplul pentru obiectul clasei papagal poate fi:
obj = Papagal ()
Aici, obj este un obiect de clasă Parrot.
Să presupunem că avem detalii despre papagali. Acum, vom arăta cum să construim clasa și obiectele de papagali.
Exemplul 1: Crearea clasei și a obiectelor în 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))
Ieșire
Blu este o pasăre Woo este, de asemenea, o pasăre Blu are 10 ani Woo are 15 ani
În programul de mai sus, am creat o clasă cu numele Parrot. Apoi, definim atribute. Atributele sunt o caracteristică a unui obiect.
Aceste atribute sunt definite în cadrul __init__metodei clasei. Este metoda de inițializare care se execută mai întâi imediat ce obiectul este creat.
Apoi, creăm instanțe ale clasei Parrot. Aici, blu și woo sunt referințe (valoare) la noile noastre obiecte.
We can access the class attribute using __class__.species. Class attributes are the same for all instances of a class. Similarly, we access the instance attributes using blu.name and blu.age. However, instance attributes are different for every instance of a class.
To learn more about classes and objects, go to Python Classes and Objects
Methods
Methods are functions defined inside the body of a class. They are used to define the behaviors of an object.
Example 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 "() 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())
Output
Blu sings 'Happy' Blu is now dancing
In the above program, we define two methods i.e sing() and dance(). These are called instance methods because they are called on an instance object i.e blu.
Inheritance
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.
Pentru a utiliza polimorfismul, am creat o interfață comună, adică o flying_test()funcție care ia orice obiect și numește fly()metoda obiectului . Astfel, când am trecut obiectele blu și peggy în flying_test()funcție, aceasta a funcționat eficient.
Puncte cheie de reținut:
- Programarea orientată pe obiecte face ca programul să fie ușor de înțeles și eficient.
- Deoarece clasa este partajabilă, codul poate fi reutilizat.
- Datele sunt sigure și securizate cu extragerea datelor.
- Polimorfismul permite aceeași interfață pentru diferite obiecte, astfel încât programatorii să poată scrie cod eficient.
