Python dispose d’un excellent support pour la programmation orientée objet. Apprenez ce que cela signifie, pourquoi c’est utile, et comment vous pouvez travailler avec des objets en Python.
La programmation orientée objet (POO) est une forme de programmation centrée sur les objets : de petites unités qui combinent données et code. Simula a été le premier langage POO créé pour la simulation de modèles physiques. En utilisant la POO, vous pouvez définir des classes qui agissent comme des modèles pour des objets de types spécifiques.

Les éléments fondamentaux de la POO sont les classes, les objets, les méthodes et les attributs. La POO utilise ces éléments pour atteindre des objectifs fondamentaux : encapsulation, abstraction, héritage et polymorphisme.

Python offre un excellent support pour la programmation orientée objet. Si vous vous interrogez sur la POO ou sur la manière de l’utiliser en Python, lisez ce qui suit pour en savoir plus.

 

Qu’est-ce que la programmation orientée objet en Python ?

Python est un langage de programmation polyvalent qui prend en charge la programmation orientée objet. Son infrastructure centrale vise les applications ou la conception d’objets et de classes. L’utilisation de la POO rend le code Python plus propre et plus clair. Elle permet également de faciliter la maintenance et la réutilisation du code.

Voici un exemple pour vous montrer pourquoi utiliser la POO en Python.

jeans = [30, true, « Denim », 59]

Dans cet exemple, le jean contient une liste de valeurs représentant le prix, le fait que l’article soit en solde, son matériau et son coût. Il s’agit d’une approche non OPO qui pose quelques problèmes. Par exemple, rien n’explique que jeans[0] fait référence à la taille. C’est très peu intuitif par rapport à une approche POO qui ferait référence à un champ nommé : jeans.size. Cet exemple de code n’est pas très réutilisable puisque le comportement sur lequel il repose n’est pas découvrable. En utilisant la POO, vous pouvez créer une classe pour éviter ce problème.

 

Comment définir une classe en Python ?

Pour créer une classe en Python, utilisez le mot-clé « class » suivi du nom de votre choix. Voici un exemple de définition d’une classe nommée Myclass.

classe MaClasse :
x = 2

p1 = MaClasse()
print(p1.x)

Définissons une classe, Pant, pour représenter différents types de pantalons. Cette classe contiendra la taille, le statut en vente, le matériau et le prix. Par défaut, elle initialise ces valeurs à None.

classe Pant :
# Définissons les propriétés et attribuons la valeur None
taille = None
en vente = Aucun
matériau = Aucun
prix = Aucun

 

Comment créer un objet en Python

Initialisons maintenant un objet de la classe Pant. Tout d’abord, nous allons définir la méthode d’initialisation qui a le nom prédéfini _init_. Une fois que vous l’aurez définie, Python appellera automatiquement cette méthode chaque fois que vous créerez un objet de cette classe.

Deuxièmement, un paramètre self particulier permettra à la méthode initializer de sélectionner un nouvel objet.

Enfin, après avoir défini l’initialisateur, nous allons créer un objet nommé jeans, en utilisant la syntaxe [objectName] = Pant().

classe Pant :
# Définir la méthode de l’initialisateur
def __init__(self, size, onsale, material, price) :
self.size = size
self.onsale = onsale
self.material = material
self.price = prix

# Créez un objet de la classe Pant et définissez chaque propriété à une valeur appropriée.
jeans = Pant(11, False, « Denim », 81)

Utiliser des attributs et des méthodes pour définir des propriétés et des comportements
Les objets en Python peuvent utiliser deux types d’attributs différents : les attributs de classe et les attributs d’instance.

Les attributs de classe sont des variables ou des méthodes que tous les objets de cette classe partagent. En revanche, les attributs d’instance sont des variables qui sont uniques à chaque objet – l’instance d’une classe.

Créons une méthode d’instance pour interagir avec les propriétés de l’objet.

classe Pant :
# Définissons la méthode d’initialisation
def __init__(self, size, onsale, material, price) :
self.size = size
self.onsale = onsale
self.material = material
self.price = prix

# Méthode d’instance
def printinfo (self) :
return f « Ce pantalon est de taille {taille}, fait de {matière}, et coûte {prix} ».

# Méthode d’instance
def putonsale (self) :
self.onsale = True

jeans = Pant(11, False, « Denim », 81)
print(jeans.printinfo())
jeans.putonsale()
print(jeans.onsale)

Ici, la première méthode, printinfo(), utilise toutes les propriétés sauf onsale. La deuxième méthode, putonsale(), définit la valeur de la propriété onsale. Notez comment ces deux méthodes d’instance utilisent le mot-clé self. Cela fait référence à l’objet particulier (ou instance) utilisé pour invoquer la méthode.

Lorsque nous appelons putonsale(), cette méthode utilise le paramètre self pour modifier la valeur de cet objet spécifique. Si vous aviez créé une autre instance de Pant legging, par exemple, cet appel ne l’affecterait pas. Une propriété d’instance d’un objet est indépendante de toutes les autres.

Comment utiliser l’héritage en Python ?

Vous pouvez développer l’exemple ci-dessus en ajoutant une sous-catégorie de la classe Pant. Dans la programmation orientée objet, cela s’appelle l’héritage. L’expansion de la classe définira des propriétés ou des méthodes supplémentaires qui ne se trouvent pas dans la classe parente.

Définissons Leggings comme une sous-classe et héritons-la de Pant.

# Leggings est la classe enfant de la classe parent Pant.
classe Leggings(Pant) :
def __init__(self, size, onsale, material, price, elasticity) :
# Hérite des propriétés self, size, onsale, material, et price.
Pant.__init__(self, size, onsale, material, price)

# Étendre les jambières pour contenir une propriété supplémentaire, l’élasticité
self.elasticity = elasticity

# Surchargez printinfo pour faire référence à la « paire de leggings » plutôt qu’au « pantalon ».
def printinfo(self) :
return f « Cette paire de leggings est de taille {self.size}, faite de {self.material}, et coûte {self.price} ».

leggings = Leggings(11, False, « Leather », 42, True)
print(leggings.printinfo())

La nouvelle méthode d’initialisation prend toutes les mêmes propriétés que la classe Pant et ajoute une propriété d’élasticité unique. Vous pouvez étendre une classe pour réutiliser la fonctionnalité existante et réduire la longueur du code. Si votre classe Leggings n’avait pas hérité de la classe Pant, vous auriez dû reproduire le code existant, juste pour une petite modification. Vous remarquerez ces avantages davantage lorsque vous travaillerez avec des classes plus grandes et plus compliquées.
Vérifier si un objet hérite d’une classe avec isinstance()

La fonction isinstance() vérifie si un objet est une instance d’une classe spécifique ou de l’une de ses classes ancêtres. Si l’objet est du type donné, ou d’un type qui en hérite, alors la fonction renvoie True. Sinon, elle retournera False.

# Classe de base fictive
classe Pant :
None

# Sous-classe fictive qui hérite de Pant
classe Leggings(Pant) :
None

pantalon = Pant()
leggings = Leggings()

print(isinstance(leggings, Pant))
print(isinstance(pants, Leggings))

Notez que Python considère l’objet leggings, de type Leggings, comme une instance de Pant, la classe parente de Leggings. Mais un objet pants n’est pas une instance de la classe Leggings.

 

Python est la parfaite introduction à la POO

Python a gagné en popularité grâce à sa syntaxe simple et facile à comprendre par rapport aux autres langages de programmation. Le langage a été conçu autour de la programmation orientée objet, c’est donc un outil idéal pour apprendre ce paradigme. La plupart des grandes entreprises technologiques utilisent Python à un moment donné dans leur pile technologique, et les perspectives sont bonnes pour les programmeurs Python.
Si vous souhaitez faire carrière dans le secteur du développement, Python est un excellent point de départ. Assurez-vous d’avoir une solide compréhension des principes de base – la programmation orientée objet n’est qu’un début !