Concepts de POO Python
Dernière mise à jour : 08 avril 2024
La programmation orientée objet est un concept fondamental de Python,
permettant aux développeurs de créer des applications modulaires,
maintenables et évolutives. En comprenant les principes fondamentaux de la
POO (classes, objets, héritage, encapsulation, polymorphisme et abstraction),
les programmeurs peuvent exploiter tout le potentiel des capacités POO de
Python pour concevoir des solutions élégantes et efficaces à des problèmes
complexes.
Qu’est-ce que la programmation orientée objet en
Python ?
En Python, la programmation orientée objet (POO) est un paradigme de
programmation qui utilise des objets et des classes dans la programmation. Il
vise à implémenter des entités du monde réel comme l'héritage, les
polymorphismes, l'encapsulation, etc. dans la programmation. Le concept
principal de la programmation orientée objet (POO) ou des concepts oops en
Python est de lier les données et les fonctions qui fonctionnent ensemble
comme une seule unité afin qu'aucune autre partie du code ne puisse accéder
à ces données.
Concepts de POO en Python
Classe en Python
Objets en Python
Polymorphisme en Python
Encapsulation en Python
Héritage en Python
Abstraction de données en Python
-------------------------------------------------------------------------------------------
Classe Python
Une classe est une collection d'objets. Une classe contient les plans ou le
prototype à partir duquel les objets sont créés. C'est une entité logique qui
contient certains attributs et méthodes.
Pour comprendre la nécessité de créer une classe, prenons un exemple :
disons que vous souhaitez suivre le nombre de chiens pouvant avoir différents
attributs tels que la race et l'âge. Si une liste est utilisée, le premier élément
pourrait être la race du chien tandis que le deuxième élément pourrait
représenter son âge. Supposons qu'il y ait 100 chiens différents, alors
comment savoir quel élément est censé être lequel ? Et si vous vouliez ajouter
d’autres propriétés à ces chiens ? Cela manque d'organisation et c'est
exactement le besoin de cours.
Quelques points sur la classe Python :
Les classes sont créées par classe de mot-clé.
Les attributs sont les variables qui appartiennent à une classe.
Les attributs sont toujours publics et accessibles à l'aide de l'opérateur
point (.). Ex. : [Link]
Syntaxe de définition de classe :
classe Nom de classe :
# Déclaration-1
.
.
.
# Instruction-N
Créer une classe vide en Python
Dans l'exemple ci-dessus, nous avons créé une classe nommée Dog en utilisant
le mot-clé class.
Python
# Python3 program to
# demonstrate defining
# a class
class Dog:
pass
Objets Python
Dans la programmation orientée objet Python, l'objet est une entité à laquelle
est associé un état et un comportement. Il peut s'agir de n'importe quel objet
du monde réel comme une souris, un clavier, une chaise, une table, un stylo,
etc. Les entiers, les chaînes, les nombres à virgule flottante, même les tableaux
et les dictionnaires, sont tous des objets. Plus précisément, tout entier ou toute
chaîne est un objet. Le nombre 12 est un objet, la chaîne « Hello, world » est un
objet, une liste est un objet qui peut contenir d'autres objets, et ainsi de suite.
Vous utilisez des objets depuis le début et vous ne vous en rendez peut-être
même pas compte.
Un objet est constitué de :
Etat : Il est représenté par les attributs d'un objet. Il reflète également les
propriétés d'un objet.
Comportement : Il est représenté par les méthodes d'un objet. Il reflète
également la réponse d'un objet à d'autres objets.
Identité : elle donne un nom unique à un objet et permet à un objet
d'interagir avec d'autres objets.
Pour comprendre l'état, le comportement et l'identité, prenons l'exemple du
chien de classe (expliqué ci-dessus).
L'identité peut être considérée comme le nom du chien.
L'état ou les attributs peuvent être considérés comme la race, l'âge ou la
couleur du chien.
Le comportement peut être considéré selon que le chien mange ou dort.
Création d'un objet
Cela créera un objet nommé obj de la classe Dog définie ci-dessus. Avant de
plonger profondément dans les objets et les classes, comprenons quelques
mots-clés de base qui seront utilisés lorsque vous travaillerez avec des objets
et des classes.
Python3
obj = Dog()
Le Python lui-même
1. Les méthodes de classe doivent avoir un premier paramètre
supplémentaire dans la définition de la méthode. Nous ne donnons pas de
valeur à ce paramètre lorsque nous appelons la méthode, Python la fournit
2. Si nous avons une méthode qui ne prend aucun argument, alors nous
devons quand même avoir un argument.
3. Ceci est similaire à ce pointeur en C++ et à cette référence en Java.
Lorsque nous appelons une méthode de cet objet comme
[Link](arg1, arg2), celle-ci est automatiquement convertie par
Python en [Link](myobject, arg1, arg2) – c'est tout ce qu'est le soi
spécial.
Remarque : Pour plus d'informations, reportez-vous à self dans la classe
Python
La méthode Python __init__
La méthode __init__ est similaire aux constructeurs en C++ et Java. Il est
exécuté dès qu'un objet d'une classe est instancié. La méthode est utile pour
effectuer toute initialisation que vous souhaitez effectuer avec votre objet.
Définissons maintenant une classe et créons des objets en utilisant la méthode
self et __init__.
Création d'une classe et d'un objet avec des attributs de classe et
d'instance
Python3
class Dog:
# class attribute
attr1 = "mammal"
# Instance attribute
def __init__(self, name):
[Link] = name
# Driver code
# Object instantiation
Rodger = Dog("Rodger")
Tommy = Dog("Tommy")
# Accessing class attributes
print("Rodger is a {}".format(Rodger.__class__.attr1))
print("Tommy is also a {}".format(Tommy.__class__.attr1))
# Accessing instance attributes
print("My name is {}".format([Link]))
print("My name is {}".format([Link]))
Sortir
Rodger est un mammifère
Tommy est aussi un mammifère
Je m'appelle Rodger
Je m'appelle Tommy
Création de classes et d'objets avec des méthodes
Ici, la classe The Dog est définie avec deux attributs :
attr1 est un attribut de classe défini sur la valeur « mammifère ». Les
attributs de classe sont partagés par toutes les instances de la classe.
__init__ est une méthode spéciale (constructeur) qui initialise une instance
de la classe Dog. Il prend deux paramètres : self (faisant référence à
l'instance en cours de création) et name (représentant le nom du chien). Le
paramètre name est utilisé pour attribuer un attribut name à chaque
instance de Dog.
La méthode speak est définie dans la classe Dog. Cette méthode imprime
une chaîne qui inclut le nom de l'instance de chien.
Le code du pilote commence par créer deux instances de la classe Dog : Rodger
et Tommy. La méthode __init__ est appelée pour chaque instance pour
initialiser ses attributs de nom avec les noms fournis. La méthode speak est
appelée dans les deux cas ([Link]() et [Link]()), ce qui oblige
chaque chien à imprimer une déclaration avec son nom.
Python3
class Dog:
# class attribute
attr1 = "mammal"
# Instance attribute
def __init__(self, name):
[Link] = name
def speak(self):
print("My name is {}".format([Link]))
# Driver code
# Object instantiation
Rodger = Dog("Rodger")
Tommy = Dog("Tommy")
# Accessing class methods
[Link]()
[Link]()
Sortir
Je m'appelle Rodger
Je m'appelle Tommy
Remarque : Pour plus d'informations, reportez-vous à Classes et objets
Python.
Héritage Python
Dans la programmation orientée objet Python, l'héritage est la capacité d'une
classe à dériver ou à hériter des propriétés d'une autre classe. La classe qui
dérive les propriétés est appelée classe dérivée ou classe enfant et la classe à
partir de laquelle les propriétés sont dérivées est appelée classe de base ou
classe parent. Les avantages de l’héritage sont :
Cela représente bien les relations du monde réel.
Il offre la réutilisabilité d’un code. Nous n'avons pas besoin d'écrire encore
et encore le même code. De plus, cela nous permet d'ajouter plus de
fonctionnalités à une classe sans la modifier.
Elle est de nature transitive, ce qui signifie que si la classe B hérite d’une
autre classe A, alors toutes les sous-classes de B hériteraient
automatiquement de la classe A.
Types d'héritage
Héritage unique : l'héritage à un seul niveau permet à une classe dérivée
d'hériter des caractéristiques d'une classe monoparentale.
Héritage multiniveau : l'héritage multiniveau permet à une classe dérivée
d'hériter des propriétés d'une classe parent immédiate qui à son tour
hérite des propriétés de sa classe parent.
Héritage hiérarchique : l'héritage de niveau hiérarchique permet à
plusieurs classes dérivées d'hériter des propriétés d'une classe parent.
Héritage multiple : l'héritage à plusieurs niveaux permet à une classe
dérivée d'hériter des propriétés de plusieurs classes de base.
Héritage en Python
Dans l'article ci-dessus, nous avons créé deux classes, à savoir Person (classe
parent) et Employee (classe enfant). La classe Employee hérite de la classe
Person. Nous pouvons utiliser les méthodes de la classe personne via la classe
employé comme le montre la fonction d'affichage dans le code ci-dessus. Une
classe enfant peut également modifier le comportement de la classe parent,
comme le montre la méthode details().
Python3
# Python code to demonstrate how parent constructors
# are called.
# parent class
class Person(object):
# __init__ is known as the constructor
def __init__(self, name, idnumber):
[Link] = name
[Link] = idnumber
def display(self):
print([Link])
print([Link])
def details(self):
print("My name is {}".format([Link]))
print("IdNumber: {}".format([Link]))
# child class
class Employee(Person):
def __init__(self, name, idnumber, salary, post):
[Link] = salary
[Link] = post
# invoking the __init__ of the parent class
Person.__init__(self, name, idnumber)
def details(self):
print("My name is {}".format([Link]))
print("IdNumber: {}".format([Link]))
print("Post: {}".format([Link]))
# creation of an object variable or an instance
a = Employee('Rahul', 886012, 200000, "Intern")
# calling a function of the class Person using
# its instance
[Link]()
[Link]()
Sortir
Rahul
886012
Je m'appelle Rahul
Numéro d'identification : 886012
Poste : Stagiaire
Remarque : Pour plus d'informations, reportez-vous à notre
didacticiel Héritage en Python .
Polymorphisme Python
Dans la programmation Python orientée objet, le polymorphisme signifie
simplement avoir plusieurs formes. Par exemple, nous devons déterminer si
une espèce d'oiseau donnée vole ou non, en utilisant le polymorphisme, nous
pouvons le faire en utilisant une seule fonction.
Polymorphisme en Python
Ce code démontre le concept d'héritage Python oops et de remplacement de
méthode dans les classes Python. Il montre comment les sous-classes peuvent
remplacer les méthodes définies dans leur classe parent pour fournir un
comportement spécifique tout en héritant des autres méthodes de la classe
parent.
Python3
class Bird:
def intro(self):
print("There are many types of birds.")
def flight(self):
print("Most of the birds can fly but some cannot.")
class sparrow(Bird):
def flight(self):
print("Sparrows can fly.")
class ostrich(Bird):
def flight(self):
print("Ostriches cannot fly.")
obj_bird = Bird()
obj_spr = sparrow()
obj_ost = ostrich()
obj_bird.intro()
obj_bird.flight()
obj_spr.intro()
obj_spr.flight()
obj_ost.intro()
obj_ost.flight()
Sortir
Il existe de nombreux types d'oiseaux.
La plupart des oiseaux peuvent voler, mais certains ne le peuvent
pas.
Il existe de nombreux types d'oiseaux.
Les moineaux peuvent voler.
Il existe de nombreux types d'oiseaux.
Les autruches ne peuvent pas voler.
Remarque : Pour plus d'informations, reportez-vous à notre
didacticiel Polymorphisme en Python .
Encapsulation Python
En programmation orientée objet Python, l'encapsulation est l'un des concepts
fondamentaux de la programmation orientée objet (POO). Il décrit l'idée
d'encapsuler les données et les méthodes qui fonctionnent sur les données
dans une seule unité. Cela impose des restrictions sur l'accès direct aux
variables et aux méthodes et peut empêcher la modification accidentelle des
données. Pour éviter toute modification accidentelle, la variable d'un objet ne
peut être modifiée que par la méthode d'un objet. Ces types de variables sont
appelés variables privées.
Une classe est un exemple d'encapsulation car elle encapsule toutes les
données qui sont des fonctions membres, des variables, etc.
Encapsulation en Python
Dans l'exemple ci-dessus, nous avons créé la variable c comme attribut privé.
Nous ne pouvons même pas accéder directement à cet attribut et ne pouvons
même pas modifier sa valeur.
Python3
# Python program to
# demonstrate private members
# "__" double underscore represents private attribute.
# Private attributes start with "__".
# Creating a Base class
class Base:
def __init__(self):
self.a = "GeeksforGeeks"
self.__c = "GeeksforGeeks"
# Creating a derived class
class Derived(Base):
def __init__(self):
# Calling constructor of
# Base class
Base.__init__(self)
print("Calling private member of base class: ")
print(self.__c)
# Driver code
obj1 = Base()
print(obj1.a)
# Uncommenting print(obj1.c) will
# raise an AttributeError
# Uncommenting obj2 = Derived() will
# also raise an AtrributeError as
# private member of base class
# is called inside derived class
Sortir
GeekspourGeeks
Remarque : pour plus d'informations, reportez-vous à notre
didacticiel Encapsulation en Python .
Abstraction de données
Il cache les détails de code inutiles à l’utilisateur. De plus, lorsque nous ne
voulons pas divulguer des parties sensibles de l’implémentation de notre code,
c’est là qu’est venue l’abstraction des données.
L'abstraction des données en Python peut être réalisée en créant des classes
abstraites.
Programmation orientée objet en Python | Ensemble 2 (masquage de données
et impression d'objets)
Ne manquez pas votre chance de surfer sur la vague de la révolution des
données ! Chaque secteur atteint de nouveaux sommets en exploitant la
puissance des données. Aiguisez vos compétences et faites partie de la
tendance la plus en vogue du 21e siècle.
