Programmation orientée objet en Python

Dans cet article, vous découvrirez le programmation orientée objet (OOP) en Python et ses concepts de base à travers des exemples.

Introduction à l'OOP Python

Python est un langage de programmation par paradigme multiple. Cela signifie qu'il supporte différentes méthodes de programmation.

Une méthode populaire pour résoudre des problèmes de programmation consiste à créer des objets. C'est ce que l'on appelle la programmation orientée objet (OOP).

Un objet a deux caractéristiques :

• Attribut

• Comportement

Laissons nous donner un exemple :

Un perroquet est un objet,

• Nom, âge, couleur sont des attributs

• Chant, danse sont des comportements

Le concept d'OOP en Python se concentre sur la création de code réutilisable. Ce concept est également appelé DRY (Don't Repeat Yourself) - Ne pas répéter soi-même.

En Python, le concept d'OOP suit certains principes fondamentaux :

Classe (class)

Une classe est un plan d'objet.

Nous pouvons considérer une classe comme un croquis de perroquet avec une étiquette. Il contient toutes les informations sur le nom, la couleur, la taille, etc. Sur la base de ces descriptions, nous pouvons étudier le perroquet. Ici, le perroquet est un objet.

Un exemple de classe de perroquet peut être :

class Parrot:
　　　　pass

Ici, nous utilisons la clé de mot class pour définir une classe vide Parrot. Nous construisons des exemples à partir de la classe. Un exemple est un objet spécifique créé par une classe spécifique.

Objet (Object)

Un objet (exemple) est un exemple de classe. Lors de la définition d'une classe, seule la description de l'objet est définie. Par conséquent, aucune mémoire ou stockage n'est alloué.

Un exemple d'objet de classe de perroquet peut être :

obj = Parrot()

Ici, obj est un objet de la classe Parrot.

Supposons que nous ayons des détails sur un perroquet. Ci-dessous, nous allons montrer comment construire la classe et l'objet du perroquet.

Example1：En Python, création de classes et d'objets

class Parrot:
　　　　# Propriétés de la classe
　　　　species = "oiseau"
　　　　# Propriétés d'exemple
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
# Création d'instances de la classe Parrot
blu = Parrot("麻雀",　10)
woo = Parrot("鹦鹉",　15)
# Accès aux propriétés de classe
print("Le moineau est {}".format(blu.__class__.species))
print("Le parrot est aussi {}".format(woo.__class__.species))
# Accès aux propriétés d'instance
print("{} a {} ans".format(blu.name, blu.age))
print("{} a {} ans".format(woo.name, woo.age))

Lorsque nous exécutons le programme, la sortie sera :

Le moineau est un oiseau
Le parrot est aussi un oiseau
Le moineau a　10　ans
L'oiseau parrot a　15　ans

Dans le programme ci-dessus, nous créons un objet nomméParrotde la classe. Ensuite, nous définissons les attributs. Les attributs sont les caractéristiques de l'objet.

ensuite, nous créonsParrotExemple de classe. Ici,bluandwooest une référence (valeur) à notre nouvel objet.

Ensuite, nous utilisons class .species pour accéder aux propriétés de la classe. Les propriétés de classe de toutes les instances de la classe sont les mêmes. De même, nous utilisons blu.name et blu.age pour accéder aux propriétés d'instance. Cependant, pour chaque instance de la classe, les propriétés d'instance sont différentes.

Pour en savoir plus sur les classes et les objets, veuillez consulterClasse et objet Python.

Méthode

Les méthodes sont des fonctions définies dans le corps de la classe. Elles sont utilisées pour définir le comportement des objets.

Example2：Dans Python, créer des méthodes

class Parrot:
　　　　
　　　　# Propriétés d'exemple
　　　　def __init__(self, name, age):
　　　　　　　　self.name = name
　　　　　　　　self.age = age
　　　　
　　　　# Méthodes d'exemple
　　　　def sing(self, song):
　　　　　　　　return "{} chante {}".format(self.name, song)
　　　　def dance(self):
　　　　　　　　return "{} est maintenant danse".format(self.name)
# Création d'un objet d'exemple
blu = Parrot("Blu",　10)
# Appel de nos méthodes d'exemple
print(blu.sing("'Happy'"))
print(blu.dance())

Lorsque nous exécutons le programme, la sortie sera :

Blu chante 'Happy'
Blu danse maintenant

Dans le programme ci-dessus, nous avons définie deux méthodes, à savoir sing() et dance(). Celles-ci sont appelées méthodes d'exemple parce qu'elles sont appelées sur l'objet d'exemple (c'est-à-dire blu).

Héritabilité

L'héritage est une méthode pour créer une nouvelle classe, utilisant ainsi une classe existante sans modifier les détails de cette dernière. La nouvelle classe formée est une classe dérivée (ou classe fille). De même, la classe existante est une classe de base (ou classe mère).

Example3Encapsulation de l'héritage en Python

# Clase mère
class Bird:
　　　　
　　　　def __init__(self):
　　　　　　　　print("L'oiseau est prêt")
　　　　def whoisThis(self):
　　　　　　　　print("Oiseau")
　　　　def swim(self):
　　　　　　　　print("Nager plus vite")
# Classe fille
class Penguin(Bird):
　　　　def __init__(self):
　　　　　　　　# Appeler la fonction super()
　　　　　　　　super().__init__()
　　　　　　　　print("Le penguin est prêt")
　　　　def whoisThis(self):
　　　　　　　　print("Penguin")
　　　　def run(self):
　　　　　　　　print("Courir plus vite")
peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

Lorsque nous exécutons ce programme, la sortie sera :

L'oiseau est prêt
Le penguin est prêt
Penguin
Nager plus vite
Courir plus vite

Dans le programme ci-dessus, nous avons créé deux classes, à savoirBird(Classe mère) etPenguin(Classe fille). La classe fille hérite des fonctionnalités de la classe mère. Nous pouvons le voir dans la méthode swim(). La classe fille modifie à nouveau le comportement de la classe mère. Nous pouvons le voir dans la méthode whoisThis(). De plus, nous étendons les fonctionnalités de la classe mère en créant une nouvelle méthode run().

De plus, nous utilisons la fonction super() avant la méthode init(). Cela est dû au fait que nous voulons que le contenu de la méthode init() soit appelé dans la classe fille.

Encapsulation

En utilisant l'encapsulation orientée objet (OOP) en Python, nous pouvons limiter l'accès aux méthodes et aux variables. Cela permet de prévenir les modifications directes des données (ce qui est appelé encapsulation). En Python, nous utilisons les traits de soulignement comme préfixe pour indiquer les attributs privés, c'est-à-dire une simple '_' ou deux '__'.

Example4Encapsulation des données en Python

class Computer:
　　　　def __init__(self):
　　　　　　　　self.__maxprice =　900
　　　　def sell(self):
　　　　　　　　print("Prix de vente : {}".format(self.__maxprice))
　　　　def setMaxPrice(self, price):
　　　　　　　　self.__maxprice = price
c = Computer()
c.sell()
# Changer le prix
c.__maxprice =　1000
c.sell()
# Utiliser la fonction setter
c.setMaxPrice(1000)
c.sell()

Lorsque nous exécutons ce programme, la sortie sera :

Selling price:　900
Selling price:　900
Selling price:　1000

In the above program, we definedComputerClass. We use the __init__() method to store the highest selling price of the computer. We try to change the price. But we can't change it because Python will__maxpriceConsidered as private attributes. To change the value, we use the setter function, that is, setMaxPrice(), which takes price as a parameter.

Polymorphism

Polymorphism is a feature (in OOP) that can 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 can use the same method to color any shape. This concept is called polymorphism.

Example5：Using polymorphism in Python

class Parrot:
　　　　def fly(self):
　　　　　　　　print("Parrots can fly")
　　　　
　　　　def swim(self):
　　　　　　　　print("Parrots cannot swim")
class Penguin:
　　　　def fly(self):
　　　　　　　　print("Penguins cannot fly")
　　　　
　　　　def swim(self):
　　　　　　　　print("Penguins can swim")
# General interface
def flying_test(bird):
　　　　bird.fly()
# Example object
blu = Parrot()
peggy = Penguin()
# Pass the object
flying_test(blu)
flying_test(peggy)

When we run the above program, the output will be:

Parrots can fly
Penguins cannot fly

In the above program, we defined two classesParrotandPenguin. Each of them has a general fly() method. However, they have different functions. To allow polymorphism, we created a general interface, that is, the flying_test() function can accept any object function. Then, we passedbluandpeggyObject, it runs effectively.

Key points of object-oriented programming:

• Make programming simple and effective.

• Classes are shareable, so code can be reused.

• Improve the productivity of programmers

• Data is safe through data abstraction.