Les classes et leurs composants

2022-10-14 02:53:06  vendredi  32517 mots  

Une classe a une construction spécifique. Chaque partie d’une classe effectue une tâche particulière qui lui donne ses caractéristiques. Bien entendu, la classe commence avec un conteneur qui va l’englober en entier. C’est ce que nous allons préciser dans la prochaine section. Les sections qui suivent décrivent les autres parties d’une classe afin de mieux comprendre comment elles contribuent à celle-ci dans sa globalité.

Créer la définition d’une classe

Une classe n’a pas besoin d’être particulièrement complexe. En fait, vous pouvez créer simplement un conteneur, y placer un élément, et appeler classe le résultat. Bien sûr, celle-ci ne fera pas grand-chose, mais vous pourrez tout de même l’instancier (c’est-à-dire demander à Python de fabriquer un objet à partir de ce moule). Vous pourrez alors travailler avec cette instance comme si l’objet avait toujours été là. Les étapes qui suivent vous aident à comprendre les notions de base sous-jacentes en créant une classe aussi simple que possible 尽可能简单.

  1. Ouvrez une fenêtre de fichier Python.
    Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
  2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne (puis une seconde fois sur Entrée après la dernière ligne) :
    >>> class MyClass:
    ...     MyVar = 0
    ... 
    ...     
    La première ligne définit le conteneur de la classe. Celui-ci est constitué du mot class suivi du nom de cette classe. Toutes les classes doivent débuter précisément de cette manière.
    La seconde ligne est la suite de la classe. Ici, vous voyez une variable de la classe appelée MyVar dont la valeur est égale à 0. Chaque instance de cette classe possédera le même nom de variable, avec la même valeur initiale.
  3. Tapez MyInstance = MyClass() et appuyez sur Entrée.
    Vous venez de créer une instance de la classe MyClass appelée MyInstance. Bien entendu, vous voulez vérifier tout cela. C’est ce que fait l’Étape 4.
  4. Tapez MyInstance.MyVar et appuyez sur Entrée.
    La sortie est, comme on pouvait s’y attendre, égale à 0 (voir la Figure).
    >>> class MyClass:
    ...     MyVar = 0
    ... 
    ...     
    >>> MyInstance = MyClass()
    >>> MyInstance.MyVar
    0
    
    Ce qui prouve que MyInstance possède bien une variable de classe appelée MyVar.
  5. Tapez MyInstance.__class__ et appuyez sur Entrée.
    Python affiche la classe utilisée pour créer l’instance, comme l’illustre la Figure.
    >>> MyInstance.__class__
    <class '__main__.MyClass'>
    
    Cette sortie vous informe que cette classe fait partie du module __main__, ce qui signifie que vous l’avez saisie directement dans le Shell.
    Figure : L’instance contient bien la variable de la classe.
    Figure : Vous pouvez vérifier que l’instance a bien été créée à partir de la classe MyClass.
  6. Gardez cette fenêtre ouverte pour la prochaine section.

Les classes et leurs attributs intégrés

Lorsque vous créez une classe, vous pourriez penser que tout ce que vous obtenez, c’est cette classe et rien d’autre. Cependant, Python y ajoute des fonctionnalités intégrées. Par exemple, dans la section précédente, vous avez tapé __class__ et appuyé sur Entrée. L’attribut __class__ est directement intégré. Vous n’avez pas à le créer. Du fait que Python l’ajoute automatiquement, vous n’avez pas à vous en soucier. Une telle fonctionnalité est suffisamment utile pour que toute classe la possède, d’où le travail de Python en arrière-plan. Les étapes qui suivent vont vous montrer comme travailler avec les attributs intégrés des classes.

  1. Revenez à la fenêtre de Python ouverte dans la section précédente.
    Si vous avez passé ces étapes, il est encore temps de les reprendre.
  2. Tapez dir(MyInstance) et appuyez sur Entrée.
    Une liste d’attributs va s’afficher (voir la Figure : La fonction dir() vous indique quels sont les attributs intégrés présents).

    Ces attributs fournissent des fonctionnalités spécifiques pour votre classe. Ces mêmes attributs vont se retrouver dans toutes les classes que vous aurez à créer, et donc vous pourrez toujours compter sur ces fonctionnalités dans vos applications.
  3. Tapez help('__class__') et appuyez sur Entrée.
    Python affiche des informations sur l’attribut __class__ (voir la Figure : Python fournit une aide pour chacun des attributs qu’il ajoute à votre classe.).
    >>> help('__class__')
    Help on class module in module builtins:
    
    __class__ = class module(object)
     |  __class__(name, doc=None)
     |  
     |  Create a module object.
     |  
     |  The name must be a string; the optional doc argument can have any type.
     |  
     |  Methods defined here:
     |  
     |  __delattr__(self, name, /)
     |      Implement delattr(self, name).
     |  
     |  __dir__(...)
     |      __dir__() -> list
     |      specialized dir() implementation
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  __setattr__(self, name, value, /)
     |      Implement setattr(self, name, value).
     |  
     |  ----------------------------------------------------------------------
     |  Static methods defined here:
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __annotations__
     |  
     |  __dict__
    Vous pouvez utiliser la même technique pour en apprendre plus sur tous les attributs que Python ajoute à votre classe.
  4. Vous pouvez maintenant refermer la fenêtre de Python.

Travailler avec les méthodes

Les méthodes sont simplement un autre terme pour les fonctions qui résident dans les classes. Vous créez des méthodes, et vous travaillez avec elles, exactement comme vous le faites avec des fonctions, si ce n’est que le mot méthode est employé exclusivement dans le cas des classes. Vous pouvez créer deux types de méthodes : celles qui sont associées à la classe elle-même, et celles qui sont associées avec une instance de cette classe. Il est important de faire la différence entre les deux. Les sections qui suivent précisent ces notions.

Créer des méthodes de classe

Une méthode de classe peut être exécutée directement dans la classe sans qu’une instance de celle-ci ne soit créée. C’est souvent nécessaire pour disposer de fonctionnalités applicables à toutes les instances, comme celles que vous avez déjà utilisées avec la classe str. Par exemple, dans le Chapitre 9, le code de MultipleException4.py fait appel à la fonction str.upper(). Les étapes qui suivent vous montrent comment créer et utiliser une méthode de classe.

  1. Ouvrez une fenêtre de fichier Python.
    Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File. 介词放在宾语前次数超多
  2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne (puis une seconde fois sur Entrée après la dernière ligne) :
    >>> class Myclass:
    ...     def Sayhello():
    ...         print("Bonjour le monde !")
    ... 
    ...         
    Cet exemple contient un unique attribut, SayHello(). Cette méthode ne reçoit aucun argument et ne renvoie aucune valeur. Elle se contente d’afficher un message. Pour autant, elle suffit à notre propos.
  3. Tapez MyClass.SayHello() et appuyez sur Entrée.
    >>> Myclass.Sayhello()
    Bonjour le monde !
    Vous obtenez bien l’affichage prévu (voir la Figure). Remarquez que vous n’avez pas eu besoin de créer une instance de la classe. La méthode est immédiatement disponible.
    Figure : Cette méthode de classe affiche un simple message.
  4. Refermez la fenêtre de Python.

Une méthode de classe fonctionne uniquement avec les données de celle-ci. Elle ne sait rien des informations qui peuvent être associées 关联 avec une instance de la classe. Vous pouvez lui passer des données en argument 作为参数, et la méthode retournera les valeurs qu’elle aura traitées, mais elle ne peut pas accéder à ce qui relève des instances. Vous devez donc être particulièrement vigilant lorsque vous créez de telles méthodes, puisqu’elles doivent être autosuffisantes.

Créer des méthodes d’instance

Une méthode d’instance est attachée aux instances individuelles. Vous les utilisez pour manipuler les données que la classe doit gérer. Une méthode d’instance ne peut évidemment être utilisée qu’une fois une instance créée.

Toutes les méthodes d’instance acceptent au moins un argument appelé self. Cet argument pointe sur l’instance particulière dont l’application se sert pour manipuler des données. Sans cet argument self, la méthode ne saurait pas quelles données traiter. Cependant, self n’est pas considéré comme un argument accessible. Sa valeur est fournie par Python lui-même et vous ne pouvez pas la changer.

Les étapes qui suivent vous montrent comment créer et utiliser des méthodes d’instance dans Python.

  1. Ouvrez une fenêtre de fichier Python.
    Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
  2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne (puis une seconde fois sur Entrée après la dernière ligne) :
    >>> class Myclass:
    SyntaxError: invalid character ':' (U+FF1A)
    >>> class Myclass:
    ...     def SayHello(self):
    ...         print("Bonjour le monde !")
    ... 
    ...         
    
    Cet exemple contient un unique attribut, SayHello(). Cette méthode ne reçoit aucun argument et ne renvoie aucune valeur. Elle se contente d’afficher un message. Pour autant, elle suffit à notre propos.
  3. Tapez MyInstance = MyClass() et appuyez sur Entrée.
    Python crée une instance de MyClass appelée MyInstance.
  4. Tapez MyInstance.SayHello() et appuyez sur Entrée.
    Vous voyez le message illustré sur la Figure.

    Figure : Le message est appelé depuis l’objet MyInstance.

    >>> Myinstance.SayHello()
    Bonjour le monde !
    

     

  5. Vous pouvez refermer la fenêtre de Python.

Travailler avec les constructeurs

Un constructeur est un type spécial de méthode que Python appelle lorsqu’il instancie un objet en utilisant les définitions trouvées dans votre classe. Python s’appuie sur ce constructeur pour effectuer différentes tâches, comme l’initialisation (l’affectation de valeurs) des variables d’instance dont l’objet a besoin lors de sa création. Les constructeurs peuvent aussi vérifier qu’il y a suffisamment de ressources pour l’objet, et effectuer toute autre procédure d’initialisation à laquelle vous pouvez penser.

Le nom du constructeur est toujours le même, __init__. Il peut si nécessaire accepter des arguments. Si vous fabriquez une classe sans constructeur, Python le fait automatiquement à votre place. Dans ce cas, ce constructeur par défaut ne fait rien. Toute classe doit posséder un constructeur, même s’il s’agit simplement du constructeur par défaut de Python.

Les étapes qui suivent illustrent cette notion de constructeur.

  1. Ouvrez une fenêtre de fichier Python.
    Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
  2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne (puis une seconde fois sur Entrée après la dernière ligne) :
    >>> class MyClass:
    ...     Greeting = ""
    ...     def __int__(self, Name="le monde"):
    ...         self.Greeting = Name + " !"
    ...     def SayHello(self):
    Vous trouvez ici un premier exemple de surcharge de fonction. Dans ce cas, il y a deux versions de __init__. La première ne demande aucune entrée particulière, puisqu’elle se contente de la valeur par défaut de la variable Name, « le monde ». La seconde nécessite un nom en entrée. Elle définit la valeur de Greeting avec cette entrée, et y ajoute un point d’exclamation. La méthode SayHello () est, pour le reste, la même que dans les exemples précédents.
    Python ne supporte pas les vraies surcharges de fonctions. De nombreux aficionados de la Programmation Orientée Objet (POO) considèrent que les valeurs par défaut sont différentes de la surcharge. Cependant, le résultat est au final le même, et c’est de toute manière la seule technique offerte par Python. Dans une « vraie » surcharge, vous verriez de multiples copies de la même fonction, chacune pouvant traiter différemment ses entrées.
  3. Tapez MyInstance = MyClass() et appuyez sur Entrée.
    Python crée une instance de MyClass appelée MyInstance.
  4. Tapez MyInstance.SayHello() et appuyez sur Entrée.
    Vous voyez le message illustré sur la Figure. Remarquez que ce message fournit la valeur générique du salut.
  5. Tapez MyInstance = MyClass('Pierre') et appuyez sur Entrée.
    Python crée une instance de MyClass appelée MyInstance.
  6. Tapez MyInstance.SayHello() et appuyez sur Entrée.
    Vous voyez cette fois le message illustré sur la Figure. Le salut est devenu plus personnalisé.
    Figure : La première version du constructeur fournit une valeur par défaut pour le nom.
    Figure : Fournir un nom au constructeur donne une sortie personnalisée.
  7. Vous pouvez refermer la fenêtre de Python.

Travailler avec les variables

Vous savez que les variables sont des conteneurs 容器 chargés de stocker des données. Lorsque vous travaillez avec des classes, vous devez prendre en compte la manière dont vos informations sont enregistrées et gérées. Une classe peut contenir à la fois des variables de classe et des variables d’instance. Les premières 前者 sont définies comme appartenant à la classe elle-même, tandis que les secondes 后者 font partie des méthodes. Les sections qui suivent vous montrent comment utiliser ces deux types de variables.

Créer des variables de classe

Les variables de classe fournissent un accès global aux données manipulées par la classe. Dans la plupart des cas, vous les initialisez en utilisant le constructeur de manière à vous assurer qu’elles contiennent une valeur correcte connue. Suivez ces étapes :

  1. Ouvrez une fenêtre de fichier Python.
    Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
  2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne (puis une seconde fois sur Entrée après la dernière ligne) :
    class MyClass:
        Greeting = ""
        def SayHello(self):
            print("Bonjour {0}".format(self.Greeting))
    C’est une variante 变体 de la section précédente, mais cette version ne contient pas de constructeur. Normalement, vous devriez définir un constructeur pour vous assurer que la variable de classe est correctement initialisée. Cependant, cette série d’étapes vous montre comment les variables de classe peuvent mal tourner.
  3. Tapez MyClass.Greeting = 'Sophie' et appuyez sur Entrée.
    Cette instruction affecte à la variable Greeting une autre valeur que celle utilisée pour créer la classe. La grande question est maintenant de savoir comment les choses vont se passer.
  4. Tapez MyClass.Greeting et appuyez sur Entrée.
    Vous constatez que la valeur de Greeting a bien été modifiée (voir la Figure).
    Figure : Vous pouvez modifier la valeur de la variable de classe.
  5. Tapez MyInstance = MyClass() et appuyez sur Entrée.
    Python crée une instance de MyClass appelée MyInstance.
    Figure : Les modifications apportées à Greeting se répercutent sur toutes les instances de la classe.
  6. Tapez MyInstance.SayHello() et appuyez sur Entrée.
    Vous voyez s’afficher le message illustré sur la Figure. Le changement que vous avez apporté à la variable Greeting s’est répercuté sur l’instance de la classe. Bien sûr, ce n’est pas réellement un problème dans cet exemple, mais imaginez ce qui pourrait se produire dans une application réelle si quelqu’un voulait provoquer des problèmes.
    MyInstance.SayHello()
    Bonjour Sophie
    Ce petit exemple illustre les dangers des variables de classe. Les deux leçons à en retenir sont les suivantes :
    • • Évitez chaque fois que possible les variables de classe pour empêcher une utilisation abusive.
    • • Initialisez toujours les variables de classe avec une valeur connue et sans danger dans le code du constructeur.
  7. Vous pouvez refermer la fenêtre de Python.

Créer des variables d’instance

Les variables d’instance sont définies uniquement à l’intérieur d’une méthode. Les arguments d’entrée de ces méthodes sont considérés comme faisant partie des variables d’instance, car elles n’existent qu’en même temps que la méthode correspondante. Utiliser des variables d’instance est généralement plus sûr que des variables de classe, puisqu’il est plus facile de les contrôler et de s’assurer que l’appelant a fourni les bonnes entrées. Suivez donc ces étapes :

  1. Ouvrez une fenêtre de fichier Python.
    Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
  2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne (puis une seconde fois sur Entrée après la dernière ligne) :
    class MyClass:
        def DoAdd(self, Value1=0, Value2=0):
            Sum = Value1 + Value2
            print("La somme de {0} plus {1} est {2}."
                  .format(Value1, Value2, Sum))
    Vous avez ici trois variables d’instance. Les arguments en entrée, Value1 et Value2, ont pour valeur par défaut 0. De cette manière, la méthode DoAdd ne peut pas échouer sous le prétexte que l’utilisateur aurait oublié de fournir une valeur. Bien entendu, celui-ci pourrait par mégarde saisir autre chose qu’un nombre, et vous devriez donc effectuer les contrôles nécessaires dans votre code. La troisième variable d’instance, Sum, est la somme de Value1 et de Value2. Le code 仅限于 se contente d’effectuer l’opération et d’afficher le résultat.
  3. Tapez MyInstance = MyClass() et appuyez sur Entrée.
    Python crée une instance de MyClass appelée MyInstance.
  4. Tapez MyInstance.DoAdd(1,4) et appuyez sur Entrée.
    Vous voyez le message illustré sur la Figure, soit la somme de 1 et de 4.
    Figure : L’instance affiche simplement la somme de deux nombres.
    MyInstance = MyClass()
    MyInstance.DoAdd(1,4)
    La somme de 1 plus 4 est 5.

     

  5. Vous pouvez refermer la fenêtre de Python.

Utiliser des méthodes avec des listes d’arguments variables

Il peut arriver que vous deviez créer des méthodes avec un nombre variable d’arguments. Gérer ce type de situation est quelque chose que Python sait bien faire. Vous pouvez créer deux sortes d’arguments en nombre variable :

  • *args : Fournit une liste d’arguments non nommés.
  • **kwargs : Fournit une liste d’arguments nommés.

Les noms réels des arguments n’a pas d’importance, mais les développeurs Python utilisent la syntaxe *args et **kwargs pour d’autres programmeurs sachent qu’il s’agit d’une liste variable d’arguments. Remarquez que la première variante est précédée d’un unique astérisque, tandis qu’il y en a deux dans la seconde. Les étapes qui suivent montrent comment utiliser ces deux approches dans une application. Vous retrouverez également cet exemple dans le fichier téléchargeable VariableArgs.py.

  1. Ouvrez une fenêtre de fichier Python.
    Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
  2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne :
    class MyClass:
       def PrintList1(*args):
          for Count, Item in enumerate(args):
             print("{0}. {1}".format(Count, Item))
    
       def PrintList2(**kwargs):
          for Name, Value in kwargs.items():
             print("{0} aime le {1}".format(Name, Value))
    
    MyClass.PrintList1("Rouge", "Bleu", "Vert")
    MyClass.PrintList2(Georges="Rouge", Annie="Bleu",
                       Sarah="Vert")
    Pour cette démonstration, vous voyez les arguments implémentés dans une méthode de classe. Il ne serait pas plus compliqué de réaliser la même chose dans une méthode d’instance.
    Observez soigneusement PrintList1 (). Vous y retrouvez la technique de parcours dans une liste à l’aide d’une boucle for. Dans ce cas, la fonction enumerate () renvoie à la fois un compteur (la position dans la boucle) et la chaîne qui a été passée en argument à la fonction.
    La fonction PrintList2 () accepte en entrée un dictionnaire. Comme dans le cas de PrintList1 (), cette liste peut être d’une longueur quelconque. Cependant, vous devez traiter les éléments items () trouvés dans le dictionnaire pour récupérer les valeurs individuelles.
  3. Choisissez la commande Run Module dans le menu Run.
    Une fenêtre Python en mode Shell va s’ouvrir. L’application affiche la sortie illustrée sur la Figure 14.12. Les listes individuelles peuvent être d’une longueur quelconque. Vous pourriez à ce stade jouer un peu avec cette technique. Essayez par exemple de mixer des noms et des chaînes dans la première liste pour voir ce qui se passe. Essayez aussi d’ajouter des valeurs booléennes. L’essentiel, c’est que cela vous permet de créer des méthodes extrêmement flexibles si tout ce que vous voulez est une liste de valeurs en entrée.
    Figure : Le code peut traiter n’importe quel nombre d’entrées dans la liste.
    0. Rouge
    1. Bleu
    2. Vert
    Georges aime le Rouge
    Annie aime le Bleu
    Sarah aime le Vert

Surcharger les opérateurs

Dans certaines situations, vous voudriez être capable de faire quelque chose de particulier en tant que résultat de l’utilisation d’un opérateur standard tel que l’addition (+). En fait, Python ne fournit parfois pas de comportement par défaut, car il n’a justement pas de comportement par défaut à implémenter. Quelle qu’en soit la raison, la surcharge des opérateurs rend possible l’affectation de nouvelles fonctionnalités à des opérateurs existants, de manière à ce qu’ils fassent ce que vous voulez, et pas ce que Python a prévu. Les étapes qui suivent vous montrent comment cela est possible. Vous retrouverez également cet exemple dans le fichier téléchargeable OverloadOperator.py.

  1. Ouvrez une fenêtre de fichier Python.
    Vous pouvez par exemple lancer Python en mode Shell, puis choisir dans le menu File la commande New File.
  2. Tapez le code suivant en appuyant sur Entrée à la fin de chaque ligne :
    class MyClass:
       def __init__(self, *args):
          self.Input = args
    
       def __add__(self, Other):
          Output = MyClass()
          Output.Input = self.Input + Other.Input
          return Output
    
       def __str__(self):
          Output = ""
          for Item in self.Input:
             Output += Item
             Output += " "
          return Output
    
    Value1 = MyClass("Rouge", "Vert", "Bleu")
    Value2 = MyClass("Jaune", "Pourpre", "Cyan")
    Value3 = Value1 + Value2
    
    print("{0} + {1} = {2}"
          .format(Value1, Value2, Value3))
    Cet exemple illustre plusieurs techniques différentes. Le constructeur __ init__() montre une méthode pour créer une variable d’instance attachée à l’objet self. Vous pouvez utiliser cette approche pour créer autant de variables qu’il est nécessaire 尽可能.
    Lorsque vous créez vos propres classes, aucun opérateur + n’est défini dans la plupart des cas, du moins tant que vous ne l’avez pas fait. La seule exception se produit lorsque vous héritez d’une classe existante dans laquelle cet opérateur a été défini (pour plus de détails, voyez plus loin dans ce chapitre la section « Étendre des classes pour en créer de nouvelles »). Pour pouvoir ajouter des entrées MyClass ensemble, vous devez donc définir la méthode __add__(), qui équivaut à l’opérateur +.
    Le code utilisé pour la méthode __add__() peut paraître un peu étrange, mais il faut le regarder ligne par ligne. Il commence par fabriquer un nouvel objet, output, à partir de MyClass. Rien n’est ajouté à output à ce stade.
    Il s’agit donc d’un objet vierge. Les deux objets que vous voulez ajouter, self. Input et other.Input, sont en fait des tuples (revoyez à ce sujet la section « Travailler avec les tuples »). Le code place la somme de ces deux objets dans output.Input. La méthode __add_() retourne ensuite le résultat à l’appelant.
    Bien entendu, vous voudriez savoir pourquoi vous ne pouvez tout simplement pas additionner les deux entrées comme vous le feriez pour des nombres. La réponse est que vous finissez en sortie par un tuple, et non par un objet MyClass. Le type de la sortie pourrait être changé, ce qui changerait aussi l’utilisation ultérieure de l’objet résultant.
    Pour afficher correctement MyClass, vous avez aussi besoin de définir une méthode __str__(). Dans ce cas, la sortie est une chaîne délimitée par un espace (autrement dit, chacun des éléments de la chaîne est séparé d’un autre par un espace). Cette chaîne contient chacune des valeurs trouvées dans self.Input. Bien entendu, la classe que vous créez peut renvoyer n’importe quelle chaîne permettant de représenter pleinement l’objet.
    La procédure principale crée deux objets de test, Value1 et Value2, puis elle les additionne et place le résultat dans Value3 afin d’afficher la réponse.
  3. Choisissez la commande Run Module dans le menu Run.
    Une fenêtre Python en mode Shell va s’ouvrir. La Figure illustre l’affichage obtenu. Certes, cela fait beaucoup de code pour une simple sortie, mais ce résultat démontre que vous pouvez créer des classes qui contiennent tout ce dont elles ont besoin, et qui sont totalement fonctionnelles.
    Figure : Le résultat de la somme de deux objets MyClass est un troisième objet de même type.
    Rouge Vert Bleu  + Jaune Pourpre Cyan  = Rouge Vert Bleu Jaune Pourpre Cyan

     

Commentaire