Définir un objet simple

PythonPythonBeginner
Pratiquer maintenant

This tutorial is from open-source community. Access the source code

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, vous apprendrez à définir une classe Python simple pour représenter des informations sur les actions (stocks). Les classes sont un concept clé en programmation orientée objet, vous permettant de modéliser des entités du monde réel et de structurer votre code plus efficacement.

Les objectifs de ce laboratoire incluent l'apprentissage de la définition d'une classe Python simple, la compréhension des attributs et des méthodes de classe, la création et l'interaction avec des instances de classe, ainsi que l'application de la mise en forme pour afficher les informations sur les objets. Le fichier stock.py sera créé au cours de ce laboratoire.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/ObjectOrientedProgrammingGroup(["Object-Oriented Programming"]) python/BasicConceptsGroup -.-> python/strings("Strings") python/FunctionsGroup -.-> python/function_definition("Function Definition") python/ObjectOrientedProgrammingGroup -.-> python/classes_objects("Classes and Objects") python/ObjectOrientedProgrammingGroup -.-> python/constructor("Constructor") python/ObjectOrientedProgrammingGroup -.-> python/encapsulation("Encapsulation") subgraph Lab Skills python/strings -.-> lab-132394{{"Définir un objet simple"}} python/function_definition -.-> lab-132394{{"Définir un objet simple"}} python/classes_objects -.-> lab-132394{{"Définir un objet simple"}} python/constructor -.-> lab-132394{{"Définir un objet simple"}} python/encapsulation -.-> lab-132394{{"Définir un objet simple"}} end

Comprendre les classes Python

En Python, une classe sert de modèle pour créer des objets. La programmation orientée objet est une approche puissante qui nous permet d'organiser efficacement notre code. Elle le fait en regroupant des données et des fonctions liées ensemble. De cette manière, nous pouvons gérer plus facilement des programmes complexes et rendre notre code plus modulaire et maintenable.

Une classe Python est composée de deux composants principaux :

  • Attributs : Ce sont des variables qui stockent des données au sein d'une classe. Considérez les attributs comme les caractéristiques ou les propriétés d'un objet. Par exemple, si nous créons une classe pour représenter une personne, les attributs pourraient être le nom, l'âge et la taille de la personne.
  • Méthodes : Ce sont des fonctions qui appartiennent à une classe et qui peuvent accéder ou modifier ses attributs. Les méthodes définissent les actions que peut effectuer un objet. En utilisant l'exemple de la classe personne, une méthode pourrait être une fonction qui calcule l'âge de la personne en mois.

Les classes sont extrêmement utiles car elles offrent un moyen de créer du code réutilisable et de modéliser des concepts du monde réel. Dans ce laboratoire, nous allons créer une classe Stock. Cette classe sera utilisée pour représenter des informations sur les actions (stocks) telles que le nom de l'action, le nombre de parts et le prix par part.

Voici la structure de base d'une classe Python :

class ClassName:
    def __init__(self, parameter1, parameter2):
        self.attribute1 = parameter1
        self.attribute2 = parameter2

    def method_name(self):
        ## Code that uses the attributes
        return result

La méthode __init__ est une méthode spéciale dans les classes Python. Elle est appelée automatiquement lorsque nous créons un nouvel objet à partir de la classe. Cette méthode est utilisée pour initialiser les attributs de l'objet. Le paramètre self est une référence à l'instance de la classe. Il est utilisé pour accéder aux attributs et aux méthodes depuis l'intérieur de la classe. Lorsque nous appelons une méthode sur un objet, Python passe automatiquement l'objet lui-même comme premier argument, c'est pourquoi nous utilisons self dans les définitions de méthode. Cela nous permet de travailler avec les attributs de l'instance spécifique et d'effectuer des opérations sur eux.

✨ Vérifier la solution et pratiquer

Création de la classe Stock

En Python, une classe est un modèle pour créer des objets. Elle vous permet de regrouper des données et des fonctionnalités ensemble. Maintenant, créons notre classe Stock pour représenter des informations sur les actions (stocks). Une action a certaines caractéristiques, telles que son nom, le nombre de parts et le prix par part. Nous allons définir des attributs pour ces aspects au sein de notre classe.

  1. Tout d'abord, vous devez être dans le bon répertoire dans le WebIDE. Si vous n'êtes pas déjà dans le répertoire /home/labex/project, naviguez jusqu'à celui-ci. C'est là que nous allons travailler sur le code de notre classe Stock.

  2. Une fois que vous êtes dans le bon répertoire, créez un nouveau fichier dans l'éditeur. Nommez ce fichier stock.py. Ce fichier contiendra le code de notre classe Stock.

  3. Maintenant, ajoutons le code pour définir la classe Stock. Copiez et collez le code suivant dans le fichier stock.py :

class Stock:
    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price

    def cost(self):
        return self.shares * self.price

Dans ce code :

  • La déclaration class Stock: crée une nouvelle classe nommée Stock. C'est comme un modèle pour créer des objets d'actions.
  • La méthode __init__ est une méthode spéciale dans les classes Python. Elle est appelée un constructeur. Lorsque vous créez un nouvel objet de la classe Stock, la méthode __init__ s'exécutera automatiquement. Elle prend trois paramètres : name, shares et price. Ces paramètres représentent les informations sur l'action.
  • À l'intérieur de la méthode __init__, nous utilisons self pour faire référence à l'instance de la classe. Nous stockons les valeurs des paramètres en tant qu'attributs d'instance. Par exemple, self.name = name stocke le paramètre name en tant qu'attribut de l'objet.
  • La méthode cost() est une méthode personnalisée que nous avons définie. Elle calcule le coût total de l'action en multipliant le nombre de parts (self.shares) par le prix par part (self.price).
  1. Après avoir ajouté le code, enregistrez le fichier. Vous pouvez le faire en appuyant sur Ctrl+S ou en cliquant sur l'icône Enregistrer. Enregistrer le fichier garantit que vos modifications sont conservées.

Examinons à nouveau le code pour nous assurer de le comprendre :

  • Nous avons défini une classe nommée Stock. Cette classe sera utilisée pour créer des objets d'actions.
  • La méthode __init__ prend trois paramètres : name, shares et price. Elle initialise les attributs de l'objet avec ces valeurs.
  • À l'intérieur de __init__, nous stockons ces paramètres en tant qu'attributs d'instance en utilisant self. Cela permet à chaque objet d'avoir son propre ensemble de valeurs pour ces attributs.
  • Nous avons ajouté une méthode cost() qui calcule le coût total en multipliant le nombre de parts par le prix. C'est une fonctionnalité utile pour nos objets d'actions.

Lorsque nous créons un objet Stock, la méthode __init__ s'exécutera automatiquement, configurant l'état initial de notre objet avec les valeurs que nous fournissons. De cette manière, nous pouvons facilement créer plusieurs objets d'actions avec différents noms, nombres de parts et prix.

✨ Vérifier la solution et pratiquer

Création d'objets Stock

Maintenant que nous avons défini notre classe Stock, il est temps de la mettre en pratique. Créer des instances d'une classe revient à créer des exemples spécifiques à partir d'un modèle général. Dans ce cas, la classe Stock est notre modèle, et nous allons créer quelques objets d'actions. Après avoir créé ces objets, nous apprendrons à accéder à leurs attributs (caractéristiques) et à leurs méthodes (actions qu'ils peuvent effectuer).

  1. Tout d'abord, nous devons ouvrir un terminal dans le WebIDE. Le terminal est comme un centre de commandes où nous pouvons donner des instructions à notre ordinateur. Pour l'ouvrir, cliquez sur "Terminal" dans le menu.

  2. Une fois le terminal ouvert, nous devons nous assurer que nous sommes dans le bon répertoire de projet. Le répertoire de projet est l'endroit où tous les fichiers pertinents de notre projet sont stockés. Si vous n'êtes pas déjà dans le répertoire de projet, utilisez la commande suivante pour y accéder :

cd /home/labex/project
  1. Maintenant, nous voulons démarrer Python en mode interactif avec notre fichier stock.py. Le mode interactif nous permet de tester notre code étape par étape et de voir immédiatement les résultats. Le fichier stock.py contient la définition de notre classe Stock. Utilisez la commande suivante :
python3 -i stock.py

Le drapeau -i est important ici. Il indique à Python d'exécuter d'abord le script stock.py. Après avoir exécuté le script, il démarre une session interactive. Dans cette session, nous pouvons accéder à toutes les classes et variables définies dans le script stock.py.

  1. Créons un nouvel objet Stock pour les actions de Google. Créer un objet revient à créer une instance spécifique de la classe Stock avec des valeurs particulières. Utilisez le code suivant :
s = Stock('GOOG', 100, 490.10)

Cette ligne de code crée une nouvelle instance de la classe Stock. Voici ce que chaque valeur signifie :

  • Nom : 'GOOG' - C'est le symbole des actions de Google.
  • Parts : 100 - Cela représente le nombre de parts d'actions de Google que nous possédons.
  • Prix : 490.10 - C'est le prix par part des actions de Google.
  1. Maintenant que nous avons notre objet Stock, nous pouvons accéder à ses attributs. Les attributs sont comme les propriétés d'un objet. Pour accéder à un attribut, nous utilisons le nom de l'objet suivi d'un point et du nom de l'attribut.
s.name

Lorsque vous exécutez ce code, il affichera le nom de l'action :

'GOOG'

Accédons au nombre de parts :

s.shares

La sortie sera le nombre de parts que nous avons défini :

100

Enfin, accédons au prix par part :

s.price

La sortie sera le prix par part :

490.1
  1. Notre classe Stock a une méthode appelée cost(). Une méthode est comme une action qu'un objet peut effectuer. Dans ce cas, la méthode cost() calcule le coût total de nos parts. Pour appeler cette méthode, utilisez le code suivant :
s.cost()

La sortie sera le coût total :

49010.0

La méthode cost() fonctionne en multipliant le nombre de parts (100) par le prix par part (490.10), ce qui nous donne 49010.0.

✨ Vérifier la solution et pratiquer

Travailler avec plusieurs objets Stock

En programmation orientée objet, une classe est comme un modèle, et les instances de cette classe sont les objets réels créés à partir de ce modèle. Notre classe Stock est un modèle pour représenter les actions. Nous pouvons créer plusieurs instances de cette classe Stock pour représenter différentes actions. Chaque instance aura son propre ensemble d'attributs, tels que le nom de l'action, le nombre de parts et le prix par part.

  1. Avec la session interactive Python toujours en cours d'exécution, nous allons créer un autre objet Stock. Cette fois, il représentera IBM. Pour créer une instance de la classe Stock, nous appelons le nom de la classe comme si c'était une fonction et nous passons les arguments nécessaires. Les arguments ici sont le nom de l'action, le nombre de parts et le prix par part.
t = Stock('IBM', 50, 91.5)

Dans cette ligne de code, nous créons un nouvel objet Stock nommé t qui représente IBM. Il a 50 parts, et chaque part coûte 91,5 $.

  1. Maintenant, nous voulons calculer le coût de cette nouvelle action. La classe Stock a une méthode nommée cost() qui calcule le coût total de l'action en multipliant le nombre de parts par le prix par part.
t.cost()

Lorsque vous exécutez ce code, Python appellera la méthode cost() sur l'objet t et renverra le coût total.

Sortie :

4575.0
  1. Nous pouvons formater et afficher nos informations sur les actions d'une manière agréable et organisée en utilisant le formatage de chaînes de caractères de Python. Le formatage de chaînes de caractères nous permet de spécifier comment différents types de données doivent être présentés dans une chaîne.
print('%10s %10d %10.2f' % (s.name, s.shares, s.price))

Dans ce code, nous utilisons le formatage de chaînes de caractères de l'ancien style en Python. L'opérateur % est utilisé pour substituer des valeurs dans un modèle de chaîne. Le modèle de chaîne '%10s %10d %10.2f' définit comment le nom de l'action, le nombre de parts et le prix doivent être formatés.

Sortie :

      GOOG        100     490.10

Cette chaîne formatée fonctionne comme suit :

  • %10s formate une chaîne dans un champ de 10 caractères de large (aligné à droite). Cela signifie que le nom de l'action sera placé dans un espace de 10 caractères de large et sera aligné à droite dans cet espace.
  • %10d formate un entier dans un champ de 10 caractères de large. Ainsi, le nombre de parts sera placé dans un espace de 10 caractères de large.
  • %10.2f formate un nombre à virgule flottante avec 2 décimales dans un champ de 10 caractères de large. Le prix sera affiché avec deux décimales et placé dans un espace de 10 caractères de large.
  1. Maintenant, formattons les informations sur les actions IBM de la même manière. Nous devons simplement remplacer le nom de l'objet de s à t dans le code de formatage de chaîne.
print('%10s %10d %10.2f' % (t.name, t.shares, t.price))

Sortie :

       IBM         50      91.50
  1. En Python moderne, nous pouvons également utiliser les f - chaînes pour le formatage. Les f - chaînes sont plus lisibles et plus faciles à utiliser. Comparons les coûts des deux actions à l'aide de f - chaînes.
print(f"Google stock costs ${s.cost()}, IBM stock costs ${t.cost()}")

Dans cette f - chaîne, nous intégrons directement des expressions à l'intérieur d'accolades {}. Python évaluera ces expressions et insérera les résultats dans la chaîne.

Sortie :

Google stock costs $49010.0, IBM stock costs $4575.0
  1. Lorsque vous avez terminé vos expériences, il est temps de quitter le mode interactif Python. Vous pouvez le faire en utilisant la fonction exit().
exit()

Chaque objet Stock conserve son propre ensemble d'attributs, ce qui démontre comment les instances de classe fonctionnent en programmation orientée objet. Cela nous permet de créer plusieurs objets d'actions, chacun avec des valeurs différentes, tout en partageant les mêmes méthodes.

✨ Vérifier la solution et pratiquer

Amélioration de la classe Stock

En Python, les classes sont un moyen puissant d'organiser les données et le comportement. Elles nous permettent de regrouper des données et des fonctions liées. Dans cette section, nous allons améliorer notre classe Stock en ajoutant une méthode qui affiche les informations sur les actions formatées. C'est un excellent exemple de la façon dont nous pouvons encapsuler à la fois les données et le comportement dans nos classes. L'encapsulation consiste à regrouper les données avec les méthodes qui opèrent sur ces données, ce qui aide à maintenir notre code organisé et plus facile à gérer.

  1. Tout d'abord, vous devez ouvrir le fichier stock.py dans l'éditeur du WebIDE. Le fichier stock.py est l'endroit où nous avons travaillé sur notre classe Stock. L'ouvrir dans l'éditeur nous permet de modifier la définition de la classe.

  2. Maintenant, nous allons modifier la classe Stock pour ajouter une nouvelle méthode display(). Cette méthode sera chargée d'imprimer les informations sur les actions de manière bien formatée. Voici comment vous pouvez le faire :

class Stock:
    def __init__(self, name, shares, price):
        self.name = name
        self.shares = shares
        self.price = price

    def cost(self):
        return self.shares * self.price

    def display(self):
        print(f"Stock: {self.name}, Shares: {self.shares}, Price: ${self.price:.2f}, Total Cost: ${self.cost():.2f}")

Dans la méthode __init__, nous initialisons le nom de l'action, le nombre de parts et le prix. La méthode cost calcule le coût total de l'action en multipliant le nombre de parts par le prix. La nouvelle méthode display utilise une f - chaîne pour formater et imprimer les informations sur l'action, y compris le nom, le nombre de parts, le prix et le coût total.

  1. Après avoir apporté ces modifications, vous devez enregistrer le fichier. Vous pouvez le faire en appuyant sur Ctrl+S sur votre clavier ou en cliquant sur l'icône Enregistrer dans l'éditeur. Enregistrer le fichier garantit que vos modifications sont conservées et peuvent être utilisées plus tard.

  2. Ensuite, nous allons démarrer une nouvelle session interactive Python. Une session interactive nous permet de tester notre code immédiatement. Pour démarrer la session, exécutez la commande suivante dans le terminal :

python3 -i stock.py

L'option -i indique à Python de démarrer une session interactive après avoir exécuté le fichier stock.py. De cette façon, nous pouvons utiliser la classe Stock et ses méthodes immédiatement.

  1. Maintenant, créons un objet d'action et utilisons la nouvelle méthode display(). Nous allons créer un objet représentant les actions d'Apple, puis appeler la méthode display pour voir les informations formatées. Voici le code :
apple = Stock('AAPL', 200, 154.50)
apple.display()

Lorsque vous exécutez ce code dans la session interactive, vous verrez la sortie suivante :

Stock: AAPL, Shares: 200, Price: $154.50, Total Cost: $30900.00

Cette sortie montre que la méthode display fonctionne correctement et formate les informations sur l'action comme prévu.

  1. Enfin, créons une liste d'actions et affichons - les toutes. Cela montrera comment nous pouvons utiliser la méthode display avec plusieurs objets d'actions. Voici le code :
stocks = [
    Stock('GOOG', 100, 490.10),
    Stock('IBM', 50, 91.50),
    Stock('AAPL', 200, 154.50)
]

for stock in stocks:
    stock.display()

Lorsque vous exécutez ce code, vous obtiendrez la sortie suivante :

Stock: GOOG, Shares: 100, Price: $490.10, Total Cost: $49010.00
Stock: IBM, Shares: 50, Price: $91.50, Total Cost: $4575.00
Stock: AAPL, Shares: 200, Price: $154.50, Total Cost: $30900.00

En ajoutant la méthode display() à notre classe, nous avons encapsulé la logique de formatage à l'intérieur de la classe elle - même. Cela rend notre code plus organisé et plus facile à maintenir. Si nous devons changer la façon dont les informations sur les actions sont affichées, nous n'avons qu'à modifier la méthode display à un seul endroit, plutôt que d'apporter des modifications dans tout notre code.

✨ Vérifier la solution et pratiquer

Résumé

Dans ce laboratoire, vous avez appris à définir une classe Python avec des attributs et des méthodes, à créer des instances de classe avec des valeurs d'attribut spécifiques, à accéder aux attributs d'un objet et à appeler les méthodes d'un objet. Vous avez également appris à formater et afficher les informations d'un objet de diverses manières, à travailler avec plusieurs objets de la même classe et à améliorer une classe en ajoutant de nouvelles méthodes.

Ces concepts de programmation orientée objet sont fondamentaux en Python et servent de base pour organiser le code dans les applications plus importantes. Les classes aident à regrouper les données et les fonctionnalités liées, rendant votre code plus modulaire et plus facile à maintenir. Pour améliorer encore vos compétences, envisagez d'ajouter des fonctionnalités à la classe Stock, telles que la validation des données, des méthodes pour mettre à jour le nombre de parts ou le prix, et une méthode pour calculer le profit ou la perte.