Comment construire des classes et définir des objets dans Python 3

introduction

Python est un langage de programmation orienté objet. * La programmation orientée objet * (OOP) se concentre sur la création de modèles de code réutilisables, contrairement à la programmation procédurale, qui met l’accent sur des instructions séquentielles explicites. Lorsque vous travaillez sur des programmes complexes en particulier, la programmation orientée objet vous permet de réutiliser du code et d’écrire du code plus lisible, ce qui le rend plus facile à gérer.

L’un des concepts les plus importants de la programmation orientée objet est la distinction entre classes et objets, définis comme suit:

* Classe * - Un plan créé par un programmeur pour un objet. Cela définit un ensemble d’attributs qui caractériseront tout objet instancié à partir de cette classe.
* Object * - Une instance d’une classe. Ceci est la version réalisée de la classe, où la classe est manifestée dans le programme.

Celles-ci sont utilisées pour créer des motifs (dans le cas de classes), puis utiliser les motifs (dans le cas d’objets).

Dans ce didacticiel, nous allons créer des classes, instancier des objets, initialiser des attributs avec la méthode constructeur et travailler avec plusieurs objets de la même classe.

Des classes

Les classes ressemblent à des plans ou à des prototypes que vous pouvez définir pour créer des objets.

Nous définissons les classes en utilisant le mot-clé + class +, similaire à la façon dont nous define en utilisant le + def + mot-clé.

Définissons une classe appelée + Shark + qui a deux fonctions associées, une pour la natation et l’autre pour être génial:

shark.py

class Shark:
   def swim(self):
       print("The shark is swimming.")

   def be_awesome(self):
       print("The shark is being awesome.")

Comme ces fonctions sont indentées dans la classe + Shark +, elles sont appelées méthodes. * Les méthodes * sont un type spécial de fonction défini dans une classe.

L’argument de ces fonctions est le mot + self +, qui est une référence aux objets créés à partir de cette classe. Pour référencer des occurrences (ou des objets) de la classe, + self + sera toujours le premier paramètre, mais ce ne sera pas nécessairement le seul.

La définition de cette classe n’a pas créé d’objets + Shark +, mais uniquement le modèle d’objet + Shark + que nous pourrons définir plus tard. Autrement dit, si vous exécutez le programme ci-dessus à ce stade, rien ne sera renvoyé.

La création de la classe + Shark + ci-dessus nous a fourni un plan détaillé pour un objet.

Objets

Un objet est une instance d’une classe. Nous pouvons prendre la classe + Shark + définie ci-dessus et l’utiliser pour créer un objet ou une instance de celui-ci.

Nous allons créer un objet + Shark + appelé + sammy +:

sammy = Shark()

Ici, nous avons initialisé l’objet + sammy + en tant qu’instance de la classe en le plaçant égal à + Shark () +.

Maintenant, utilisons les deux méthodes avec les objets + Shark + + sammy +:

sammy = Shark()
sammy.swim()
sammy.be_awesome()

L’objet + Shark + + sammy + utilise les deux méthodes + swim () + et + be_awesome () + . Nous les avons appelés en utilisant l’opérateur point (+. +`), Qui est utilisé pour référencer un attribut de l’objet. Dans ce cas, l’attribut est une méthode et il est appelé avec des parenthèses, comme si vous appeliez également avec une fonction.

Le mot-clé + self + étant un paramètre des méthodes telles que définies dans la classe + Shark +, l’objet + sammy + est transmis aux méthodes. Le paramètre + self + garantit que les méthodes ont une manière de faire référence aux attributs d’objet.

Cependant, lorsque nous appelons les méthodes, rien n’est passé entre les parenthèses, l’objet + sammy + est automatiquement transmis avec l’opérateur point.

Ajoutons l’objet dans le contexte d’un programme:

shark.py

class Shark:
   def swim(self):
       print("The shark is swimming.")

   def be_awesome(self):
       print("The shark is being awesome.")


def main():
   sammy = Shark()
   sammy.swim()
   sammy.be_awesome()

if __name__ == "__main__":
   main()

Lançons le programme pour voir ce qu’il fait:

python shark.py

OutputThe shark is swimming.
The shark is being awesome.

L’objet + sammy + appelle les deux méthodes de la fonction + main () + du programme, ce qui entraîne l’exécution de ces méthodes.

La méthode du constructeur

La méthode constructeur est utilisée pour initialiser les données. Il est exécuté dès qu’un objet d’une classe est instancié. Aussi connue sous le nom de méthode + init +, ce sera la première définition d’une classe et ressemblera à ceci:

class Shark:
   def __init__(self):
       print("This is the constructor method.")

Si vous avez ajouté la méthode + init + ci-dessus à la classe + Shark + dans le programme ci-dessus, le programme générerait les éléments suivants sans que vous ne modifiiez quoi que ce soit dans l’instanciation + sammy +:

OutputThis is the constructor method.
The shark is swimming.
The shark is being awesome.

En effet, la méthode constructeur est automatiquement initialisée. Vous devriez utiliser cette méthode pour effectuer toute initialisation que vous voudriez faire avec vos objets de classe.

Au lieu d’utiliser la méthode constructeur ci-dessus, créons-en une qui utilise une variable + nom + que nous pouvons utiliser pour assigner des noms aux objets. Nous allons passer + name + en tant que paramètre et définir + self.name + égal à + name +:

shark.py

class Shark:
   def __init__(self, name):
       self.name = name

Ensuite, nous pouvons modifier les chaînes dans nos fonctions pour référencer les noms, comme ci-dessous:

shark.py

class Shark:
   def __init__(self, name):
       self.name = name

   def swim(self):
       # Reference the name
       print(self.name + " is swimming.")

   def be_awesome(self):
       # Reference the name
       print(self.name + " is being awesome.")

Enfin, nous pouvons définir le nom de l’objet + Shark + + + sammy + égal à + "Sammy" + en le passant en tant que paramètre de la classe + Shark + `:

shark.py

class Shark:
   def __init__(self, name):
       self.name = name

   def swim(self):
       print(self.name + " is swimming.")

   def be_awesome(self):
       print(self.name + " is being awesome.")


def main():
   # Set name of Shark object
   sammy = Shark("Sammy")
   sammy.swim()
   sammy.be_awesome()

if __name__ == "__main__":
   main()

Nous pouvons exécuter le programme maintenant:

python shark.py

OutputSammy is swimming.
Sammy is being awesome.

Nous voyons que le nom que nous avons donné à l’objet est en cours d’impression. Nous avons défini la méthode + init + avec le nom du paramètre (avec le mot-clé + self +) et défini une variable dans la méthode.

Etant donné que la méthode constructeur est automatiquement initialisée, il n’est pas nécessaire de l’appeler explicitement, mais uniquement de transmettre les arguments entre parenthèses après le nom de la classe lorsque nous créons une nouvelle instance de la classe.

Si nous voulions ajouter un autre paramètre, tel que + age +, nous pourrions le faire en le passant également à la méthode + init +:

class Shark:
   def __init__(self, name, age):
       self.name = name
       self.age = age

Ensuite, lorsque nous créons notre objet + sammy +, nous pouvons passer l’âge de Sammy dans notre déclaration:

sammy = Shark("Sammy", 5)

Pour utiliser + age +, nous aurions également besoin de créer une méthode dans la classe qui l’appelle.

Les méthodes de constructeur nous permettent d’initialiser certains attributs d’un objet.

Travailler avec plus d’un objet

Les classes sont utiles car elles nous permettent de créer de nombreux objets similaires basés sur le même modèle.

Pour comprendre comment cela fonctionne, ajoutons un autre objet + Shark + à notre programme:

shark.py

class Shark:
   def __init__(self, name):
       self.name = name

   def swim(self):
       print(self.name + " is swimming.")

   def be_awesome(self):
       print(self.name + " is being awesome.")

def main():
   sammy = Shark("Sammy")
   sammy.be_awesome()
   stevie = Shark("Stevie")
   stevie.swim()

if __name__ == "__main__":
 main()

Nous avons créé un deuxième objet + Shark + appelé + stevie + et lui avons attribué le nom " Stevie ". Dans cet exemple, nous avons utilisé la méthode + be_awesome () + avec + sammy + et la méthode + swim () + avec + stevie +.

Lançons le programme:

python shark.py

OutputSammy is being awesome.
Stevie is swimming.

La sortie montre que nous utilisons deux objets différents, l’objet + sammy + et l’objet + stevie +, tous deux de la classe + Shark +.

Les classes permettent de créer plusieurs objets en suivant le même modèle sans les créer à partir de rien.

Conclusion

Ce tutoriel a permis de créer des classes, d’instancier des objets, d’initialiser des attributs avec la méthode constructeur et de travailler avec plusieurs objets de la même classe.

La programmation orientée objet est un concept important à comprendre car elle facilite le recyclage du code, car les objets créés pour un programme peuvent être utilisés dans un autre. Les programmes orientés objet permettent également d’améliorer la conception des programmes, car les programmes complexes sont difficiles à écrire et nécessitent une planification minutieuse, ce qui rend le travail du programme moins fastidieux.

TOC

Comment construire des classes et définir des objets dans Python 3

introduction

Des classes

Objets

La méthode du constructeur

Travailler avec plus d’un objet

Conclusion

Related