Dans ce didacticiel, vous découvrirez la programmation orientée objet (POO) en Python et son concept fondamental à l'aide d'exemples.
Vidéo: programmation orientée objet en Python
Programmation orientée objet
Python est un langage de programmation multi-paradigme. Il prend en charge différentes approches de programmation.
L'une des approches les plus courantes pour résoudre un problème de programmation consiste à créer des objets. Ceci est connu sous le nom de programmation orientée objet (POO).
Un objet a deux caractéristiques:
- les attributs
- comportement
Prenons un exemple:
Un perroquet peut être un objet, car il possède les propriétés suivantes:
- nom, âge, couleur comme attributs
- chanter, danser comme comportement
Le concept de POO en Python se concentre sur la création de code réutilisable. Ce concept est également connu sous le nom de DRY (Don't Repeat Yourself).
En Python, le concept de POO suit quelques principes de base:
Classe
Une classe est un plan pour l'objet.
Nous pouvons considérer la classe comme une esquisse d'un perroquet avec des étiquettes. Il contient tous les détails sur le nom, les couleurs, la taille, etc. Sur la base de ces descriptions, nous pouvons étudier le perroquet. Ici, un perroquet est un objet.
L'exemple de classe de perroquet peut être:
classe Parrot: pass
Ici, nous utilisons le classmot - clé pour définir une classe Parrot vide. À partir de la classe, nous construisons des instances. Une instance est un objet spécifique créé à partir d'une classe particulière.
Objet
Un objet (instance) est une instanciation d'une classe. Lorsque la classe est définie, seule la description de l'objet est définie. Par conséquent, aucune mémoire ou stockage n'est alloué.
L'exemple d'objet de la classe parrot peut être:
obj = Perroquet ()
Ici, obj est un objet de classe Parrot.
Supposons que nous ayons des détails sur les perroquets. Maintenant, nous allons montrer comment construire la classe et les objets des perroquets.
Exemple 1: création d'une classe et d'un objet en 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))
Production
Blu est un oiseau Woo est aussi un oiseau Blu a 10 ans Woo a 15 ans
Dans le programme ci-dessus, nous avons créé une classe avec le nom Parrot. Ensuite, nous définissons les attributs. Les attributs sont une caractéristique d'un objet.
Ces attributs sont définis dans la __init__méthode de la classe. C'est la méthode d'initialisation qui est exécutée pour la première fois dès la création de l'objet.
Ensuite, nous créons des instances de la classe Parrot. Ici, blu et woo sont des références (valeur) à nos nouveaux objets.
Nous pouvons accéder à l'attribut de classe en utilisant __class__.species. Les attributs de classe sont les mêmes pour toutes les instances d'une classe. De même, nous accédons aux attributs d'instance en utilisant blu.nameet blu.age. Cependant, les attributs d'instance sont différents pour chaque instance d'une classe.
Pour en savoir plus sur les classes et les objets, accédez à Classes et objets Python
Méthodes
Les méthodes sont des fonctions définies dans le corps d'une classe. Ils sont utilisés pour définir les comportements d'un objet.
Exemple 2: création de méthodes en 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())
Production
Blu chante 'Happy' Blu danse maintenant
Dans le programme ci-dessus, nous définissons deux méthodes à savoir sing()et dance(). Celles-ci sont appelées méthodes d'instance car elles sont appelées sur un objet d'instance ie blu.
Héritage
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.
Pour utiliser le polymorphisme, nous avons créé une interface commune, c'est-à-dire une flying_test()fonction qui prend n'importe quel objet et appelle la fly()méthode de l'objet . Ainsi, lorsque nous avons passé les objets blu et peggy dans la flying_test()fonction, cela a fonctionné efficacement.
Points clés à retenir:
- La programmation orientée objet rend le programme facile à comprendre et efficace.
- Puisque la classe est partageable, le code peut être réutilisé.
- Les données sont sûres et sécurisées grâce à l'abstraction des données.
- Le polymorphisme permet la même interface pour différents objets, de sorte que les programmeurs peuvent écrire du code efficace.
