Programmation orientée objet Python
Programmation orientée objet Python
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-paradigmes. Il prend en charge différentes approches de programmation.
L'une des approches populaires pour résoudre un problème de programmation consiste à créer des objets. C'est ce qu'on appelle la programmation orientée objet (POO).
Un objet a deux caractéristiques :
- attributs
- comportement
Prenons un exemple :
Un perroquet est 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 (Ne vous répétez pas).
En Python, le concept de POO suit quelques principes de base :
Classe
Une classe est un plan pour l'objet.
Nous pouvons penser à la classe comme un croquis 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 pour la classe de perroquet peut être :
class Parrot:
pass
Ici, nous utilisons le class mot clé pour définir une classe vide Parrot . A 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 perroquet peut être :
obj = Parrot()
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)) Sortie
Blu is a bird Woo is also a bird Blu is 10 years old Woo is 15 years old
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 le __init__ méthode de la classe. C'est la méthode d'initialisation qui est exécutée en premier dès que l'objet est créé.
Ensuite, nous créons des instances du Parrot classer. Ici, bleu et woo sont des références (valeur) à nos nouveaux objets.
Nous pouvons accéder à l'attribut class 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.name et 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()) Sortie
Blu sings 'Happy' Blu is now dancing
Dans le programme ci-dessus, nous définissons deux méthodes, c'est-à-dire sing() et dance() . Celles-ci sont appelées méthodes d'instance car elles sont appelées sur un objet d'instance, c'est-à-dire blu .
Héritage
L'héritage est un moyen de créer une nouvelle classe pour utiliser les détails d'une classe existante sans la modifier. La classe nouvellement formée est une classe dérivée (ou classe enfant). De même, la classe existante est une classe de base (ou classe parent).
Exemple 3 :Utilisation de l'héritage en 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() Sortie
Bird is ready Penguin is ready Penguin Swim faster Run faster
Dans le programme ci-dessus, nous avons créé deux classes, à savoir Bird (classe parent) et Pingouin (classe enfant). La classe enfant hérite des fonctions de la classe parent. Nous pouvons le voir à partir du swim() méthode.
Encore une fois, la classe enfant a modifié le comportement de la classe parent. Nous pouvons le voir à partir du whoisThis() méthode. De plus, nous étendons les fonctions de la classe parent, en créant un nouveau run() méthode.
De plus, nous utilisons le super() fonction à l'intérieur du __init__() méthode. Cela nous permet d'exécuter le __init__() méthode de la classe parent à l'intérieur de la classe enfant.
Encapsulation
En utilisant la POO en Python, nous pouvons restreindre l'accès aux méthodes et aux variables. Cela empêche les données d'être modifiées directement, ce qui s'appelle l'encapsulation. En Python, nous désignons les attributs privés en utilisant un trait de soulignement comme préfixe, c'est-à-dire un seul _ ou double __ .
Exemple 4 :Encapsulation de données en 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() Sortie
Selling Price: 900 Selling Price: 900 Selling Price: 1000
Dans le programme ci-dessus, nous avons défini un Ordinateur classe.
Nous avons utilisé __init__() méthode pour stocker le prix de vente maximum de Computer . Ici, notez le code
c.__maxprice = 1000 Ici, nous avons essayé de modifier la valeur de __maxprice en dehors de la classe. Cependant, depuis __maxprice est une variable privée, cette modification n'est pas visible sur la sortie.
Comme indiqué, pour modifier la valeur, nous devons utiliser une fonction de définition, c'est-à-dire setMaxPrice() qui prend le prix comme paramètre.
Polymorphisme
Le polymorphisme est une capacité (en POO) à utiliser une interface commune pour plusieurs formulaires (types de données).
Supposons que nous ayons besoin de colorer une forme, il existe plusieurs options de forme (rectangle, carré, cercle). Cependant, nous pourrions utiliser la même méthode pour colorer n'importe quelle forme. Ce concept s'appelle Polymorphisme.
Exemple 5 :Utilisation du polymorphisme en 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) Sortie
Parrot can fly Penguin can't fly
Dans le programme ci-dessus, nous avons défini deux classes Parrot et Pingouin . Chacun d'eux a un fly() commun méthode. Cependant, leurs fonctions sont différentes.
Pour utiliser le polymorphisme, nous avons créé une interface commune, c'est-à-dire flying_test() fonction qui prend n'importe quel objet et appelle le fly() de l'objet méthode. Ainsi, lorsque nous avons passé le blu et peggy objets dans le flying_test() fonction, il 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 de données.
- Le polymorphisme permet la même interface pour différents objets, afin que les programmeurs puissent écrire du code efficace.
Python