Classes et objets en Python : programmation orientée objet

Tu as déjà utilisé des objets chaque fois que tu as manipulé un nombre, une chaîne de caractères, une liste ou un dictionnaire. Un objet a un type, une valeur ou un état, et des opérations qu’il permet. Même les fonctions et None sont des objets. Écrire ta propre classe étend ce système familier.

Trouver le type et les méthodes d’un objet

type("hello") renvoie <class 'str'> ; type([1, 2]) renvoie <class 'list'>. Les mots type et classe décrivent ici le même rôle. isinstance(3.5, float) vaut True, tandis que isinstance("3.5", float) vaut False : la seconde valeur est du texte, même si elle ressemble à un nombre.

Une méthode est une fonction fournie par un type. Dans "ada lovelace".title(), la chaîne avant le point est l’objet, title est la méthode et les parenthèses l’appellent. Le résultat est "Ada Lovelace". dir(value) liste les noms proposés par un objet ; des noms comme __len__ sont des méthodes spéciales qui relient les objets à des opérations Python comme len(value).

Suivre le résultat et l’objet d’origine

Un appel de méthode peut renvoyer un résultat, modifier un objet ou faire les deux. Vérifie le comportement de la méthode avant de décider quoi affecter.

word = "level"
print(word.count("l"))  # 2
print(word.upper())     # LEVEL
print(word)             # level

nums = [3, 1, 2]
result = nums.sort()
print(nums)             # [1, 2, 3]
print(result)           # None

Les chaînes de caractères sont immuables : leur contenu ne peut pas changer. upper() renvoie une autre chaîne, donc word garde sa valeur d’origine. Pour conserver le résultat en majuscules sous ce nom, écris word = word.upper().

Les listes sont mutables. sort() modifie la liste en place et renvoie None. Écrire nums = nums.sort() fait perdre la référence à la liste contenue dans nums et affecte None. Utilise nums.sort() sur une ligne à part, ou nums = sorted(nums) pour obtenir une nouvelle liste triée. Pour un dictionnaire, {"a": 1}.get("b", 0) renvoie 0 parce que la clé demandée est absente.

Les parenthèses comptent aussi. word.upper est un objet méthode ; word.upper() l’exécute. De nombreux objets peuvent proposer le même comportement : "cat".upper() et "dog".upper() utilisent un même type de méthode avec des chaînes différentes.

Distinguer égalité et identité

L’égalité indique si les valeurs correspondent. L’identité indique si deux noms désignent un même objet.

a = [1, 2]
b = [1, 2]
c = a
print(a == b)  # True
print(a is b)  # False
print(c is a)  # True
c.append(3)
print(a)       # [1, 2, 3]
print(b)       # [1, 2]

a et b ont au départ des contenus égaux, mais sont des listes distinctes. c = a crée un alias, un autre nom pour la même liste. L’ajout par l’intermédiaire de c modifie l’objet que a désigne aussi. Il ne modifie pas la liste distincte contenue dans b. Pour suivre un programme, dessine une boîte par objet et une flèche de chaque nom vers sa boîte.

Une classe définit un type que tu peux utiliser dans ton propre programme. Chaque objet créé à partir de cette classe est une instance. Une classe décrit le type de chose ; les instances contiennent les données de choses particulières. Un formulaire vierge et ses copies remplies offrent une comparaison utile.

Écrire une classe et l’appeler

Une instruction de classe comprend le mot-clé class, un nom, deux-points et un corps indenté. pass fournit un corps vide pendant que tu essaies la structure.

class Book:
    pass

b1 = Book()
b2 = Book()
print(b1 is b2)           # False
print(isinstance(b1, Book))  # True

Chaque appel à Book() crée une instance distincte. Dans un script, type(b1) affiche <class '__main__.Book'>. L’instruction de classe doit être exécutée avant que le code essaie d’utiliser Book. Tu peux aussi définir une classe dans un module et l’importer avec from library import Book, puis créer des instances dans le programme appelant.

Suis les conventions de nommage de Python : Book, BankAccount et ShoppingCart utilisent CapWords, chaque mot commençant par une majuscule. Les variables et les méthodes utilisent des mots en minuscules séparés par des tirets bas, comme book_count et add_item. Utilise quatre espaces pour chaque niveau d’indentation.

Stocker des données sur chaque instance

Un attribut est une valeur nommée à laquelle on accède avec un point. Affecter une valeur à un attribut la stocke ; lire le même nom permet de la retrouver.

b1.title = "Dune"
b2.title = "Emma"
b1.pages = 412
print(b1.title)  # Dune
print(b2.title)  # Emma
print(b1.pages)  # 412

Les données appartiennent à l’instance choisie. Donner un attribut pages à b1 n’en donne pas un à b2. Lire b2.pages lève maintenant AttributeError, car cet objet n’a pas d’attribut nommé pages.

Les affectations peuvent créer de nouveaux noms sans vérifier ton intention. Après b1.titel = "X", le b1.title d’origine contient toujours "Dune" ; l’objet a gagné un second attribut dont le nom est mal orthographié. Si une valeur semble ne pas changer, compare l’orthographe à l’endroit où elle a été affectée et à celui où elle a été lue.

Distinguer la classe de ses instances

b = Book donne un autre nom à la classe. Cela ne crée pas de livre. Si les titres ont été définis uniquement sur les instances, demander Book.title lève AttributeError ; aucun titre unique n’est partagé par le type.

Donner à chaque objet un départ fiable

Définir les attributs depuis l’extérieur est possible, mais cela disperse l’initialisation dans le programme. Un livre pourrait recevoir un titre et un nombre de pages tandis qu’un autre ne recevrait qu’un titre. Le code ultérieur ne peut pas supposer sans risque que les deux ont pages.

Une méthode d’initialisation appelée __init__ place les affectations initiales dans la classe. Chaque appel de création suit alors le même processus d’initialisation. La classe peut imposer un titre et créer d’autres attributs avec des valeurs initiales adaptées, afin que le code appelant n’ait pas à retenir une séquence d’affectations distincte.

Chaque compte nouvellement créé a besoin d’un titulaire et d’un solde initial. Placer cette initialisation dans __init__ donne à chaque objet les attributs attendus par les méthodes ultérieures. Python crée d’abord l’instance, puis appelle __init__ pour l’initialiser.

Relier les arguments aux attributs

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transactions = []

acct = BankAccount("Maya", 50)
other = BankAccount("Leo")

Pour le premier appel, Python passe le nouveau compte comme self, "Maya" comme owner et 50 comme balance. Les affectations donnent à acct.owner la valeur "Maya" et à acct.balance la valeur 50. Le second appel utilise le solde par défaut, donc other.balance vaut 0.

self est le paramètre qui reçoit l’objet courant. C’est une convention, pas un mot-clé Python. Utilise ce nom pour que les lecteurs reconnaissent immédiatement l’objet. Les appelants l’omettent : BankAccount("Maya", 50) fournit deux arguments, pas trois.

Distinguer les noms locaux des données stockées

Dans self.owner = owner, le nom à droite est un paramètre local. Le nom à gauche est un attribut stocké sur l’objet. Une fois l’initialisation terminée, les autres méthodes peuvent toujours utiliser self.owner.

Écrire balance = balance ne fait que réaffecter le nom local. Cela ne crée aucun attribut, donc la lecture ultérieure de acct.balance échoue. Place self. devant chaque attribut qui doit rester associé à l’objet.

Prépare l’initialisation en listant ce dont chaque instance a besoin. Les valeurs obligatoires deviennent des paramètres après self ; les valeurs facultatives peuvent avoir des valeurs par défaut. Les valeurs qui commencent toujours de la même manière peuvent être affectées dans le corps, comme self.visits = 0. Une liste créée par self.transactions = [] est créée à nouveau à chaque appel.

Éviter une liste par défaut partagée

Un argument par défaut est évalué lorsque Python définit la méthode. Avec def __init__(self, items=[]), les appels qui omettent items reçoivent la même liste. Si l’initialiseur stocke directement cette liste, modifier les éléments d’un objet change ceux que voit un autre objet.

Utilise None comme valeur par défaut et crée une nouvelle liste à chaque appel :

class Cart:
    def __init__(self, items=None):
        self.items = [] if items is None else list(items)

a = Cart()
b = Cart()
a.items.append("pen")
print(b.items)  # []

list(items) crée aussi une nouvelle liste externe lorsqu’un appelant en fournit une. Les objets à l’intérieur de cette liste restent des références partagées ; créer la liste ne recrée pas chaque élément.

Lire les erreurs d’initialisation

Il manque à BankAccount() l’argument obligatoire owner, ce qui lève TypeError. Compare l’appel aux paramètres après self.

Le nom __init__ comporte deux tirets bas de chaque côté. _init_ est un nom de méthode ordinaire et n’effectuera pas cette initialisation automatiquement. __init__ doit renvoyer None : omets donc normalement l’instruction de retour. Renvoyer un solde lève TypeError ; l’appel de classe lui-même fournit la nouvelle instance à l’appelant.

Certaines valeurs décrivent un objet ; d’autres décrivent le type dans son ensemble. La taille d’une pizza appartient à cette pizza. Une limite de garnitures ou un compte des pizzas créées peut appartenir à la classe. L’endroit où se trouve une affectation détermine le type d’attribut qu’elle crée.

Placer la valeur au bon endroit

class Pizza:
    MAX_TOPPINGS = 5
    count = 0

    def __init__(self, size):
        self.size = size
        self.toppings = []
        Pizza.count += 1

p1 = Pizza("large")
p2 = Pizza("small")

size et toppings sont des attributs d’instance, définis sur self. Chaque pizza a ses propres valeurs. MAX_TOPPINGS et count sont des attributs de classe, affectés dans le corps de la classe en dehors d’une méthode. Les majuscules indiquent une valeur destinée à être constante ; elles n’empêchent pas sa réaffectation.

Après ces appels, Pizza.count vaut 2. Chaque initialiseur met à jour le même attribut de classe. p1.size vaut "large", tandis que p2.size vaut "small".

Suivre la recherche et le masquage

Pour des attributs de données ordinaires comme ceux-ci, la lecture de p1.MAX_TOPPINGS vérifie d’abord l’instance, puis la classe. Puisqu’aucune valeur n’est stockée sur p1, Python trouve Pizza.MAX_TOPPINGS, qui vaut 5.

Une affectation par l’intermédiaire d’une instance a un autre effet :

p1.MAX_TOPPINGS = 8
Pizza.MAX_TOPPINGS = 6
print(p1.MAX_TOPPINGS)     # 8
print(p2.MAX_TOPPINGS)     # 6
print(Pizza.MAX_TOPPINGS)  # 6

La première ligne crée un attribut d’instance sur p1. Il masque la valeur de classe pour cet objet. Modifier ensuite la valeur de classe atteint p2, qui lit toujours la valeur de la classe, mais ne remplace pas la valeur propre de p1.

Repérer deux formes de partage involontaire

Si l’initialiseur utilisait self.count += 1, Python lirait le 0 de la classe, ajouterait un et stockerait un attribut d’instance. Chaque nouvelle pizza recevrait son propre count de 1, tandis que Pizza.count resterait à 0. Nomme la classe lorsque tu mets à jour un compteur commun à toute la classe.

Une liste dans le corps de la classe provoque un autre problème. Avec toppings = [], les instances qui n’ont pas d’attribut de garnitures distinct trouvent toutes la même liste. p1.toppings.append("olives") modifie cette liste partagée ; cette instruction n’affecte pas de nouvel attribut d’instance. Place self.toppings = [] dans __init__ lorsque chaque pizza a besoin de ses propres garnitures.

Examiner les données propres d’un objet

Pour le p2 d’origine, vars(p2) donne {'size': 'small', 'toppings': []}. Les valeurs de classe sont absentes parce qu’elles se trouvent sur Pizza. C’est utile pour déboguer une recherche dont le résultat surprend : vérifie si l’instance a sa propre valeur, puis examine la valeur de classe. Un paramètre partagé appartient à la classe ; un nom, une taille, un solde ou une collection personnelle appartient à l’instance.

Un objet doit commencer dans un état que ses méthodes peuvent utiliser. Un rectangle de largeur négative ne peut pas représenter la forme voulue. Une règle qui doit toujours rester vraie pour chaque objet d’une classe est un invariant. La validation vérifie ces règles avant d’accepter les données.

Vérifier avant de stocker

class Rectangle:
    def __init__(self, width, height):
        if width <= 0:
            raise ValueError("width must be positive")
        if height <= 0:
            raise ValueError("height must be positive")
        self.width = width
        self.height = height

Rectangle(3, 4) passe les deux vérifications et renvoie un objet initialisé. Rectangle(-2, 4) lève ValueError à la première vérification. Les affectations suivantes ne s’exécutent jamais. Si le programme n’intercepte pas cette exception, l’exécution s’arrête à cet endroit.

Supposons que r désigne déjà un rectangle valide. Dans r = Rectangle(-2, 4), l’appel à droite échoue avant l’affectation. r garde sa valeur précédente. Si r n’avait pas de valeur avant l’échec de l’appel, l’affectation ne lui en donne pas.

Choisir une exception utile

Une largeur numérique négative est une erreur de valeur. Du texte fourni là où un nombre est nécessaire est une erreur de type. Dans cet exemple, la comparaison avec 0 lève déjà TypeError pour du texte. Une classe peut aussi vérifier explicitement un type avec isinstance lorsqu’elle a besoin d’un message plus clair.

Écris des messages qui nomment la règle, comme "width must be positive". Un message qui dit seulement "bad input" laisse l’appelant deviner quelle valeur doit être corrigée.

Laisser le code appelant gérer la reprise

while True:
    try:
        width = float(input("Width: "))
        room = Rectangle(width, 3)
        break
    except ValueError as error:
        print("Try again:", error)

La saisie de abc échoue dans float ; celle de -2 passe la conversion mais échoue dans Rectangle. Les deux lèvent ValueError, donc cette boucle gère les deux cas. La classe énonce sa règle sur les données, tandis que le code appelant décide de demander une nouvelle saisie.

Afficher un avertissement dans __init__ ne rejette pas l’appel. Si l’exécution continue, le programme peut recevoir un objet invalide et échouer plus tard en l’utilisant. Lever une exception arrête l’initialisation qui échoue à l’endroit où le problème se produit.

Nettoyer les données délibérément et maintenir la règle

Un nettoyage documenté peut être utile. self.name = name.strip() supprime les espaces aux extrémités ; valide le nom nettoyé si les noms vides sont interdits. self.items = list(items) crée une liste externe distincte : ajouter un élément à la liste de l’appelant ne l’ajoute donc pas à celle-ci. Remplacer une largeur invalide par sa valeur absolue changerait le sens voulu par l’appelant ; cela nécessite donc une règle de conception explicite.

Les vérifications de l’initialisation s’exécutent à la création. Une simple affectation comme r.width = -5 les contourne toujours par la suite. Les méthodes qui modifient une largeur doivent la vérifier à nouveau. Une propriété peut placer une vérification sur l’affectation à l’attribut elle-même, ce qui permet d’appliquer la même règle pendant l’initialisation et les mises à jour ultérieures.

Une méthode d’instance est une fonction définie dans une classe qui utilise l’objet passé comme self. L’objet fournit ses données stockées ; des paramètres supplémentaires fournissent les autres informations nécessaires à l’action.

Lire les attributs par self

Ajoute ces méthodes dans la classe Rectangle avec validation, au même niveau d’indentation que __init__ :

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

    def is_square(self):
        return self.width == self.height

Avec r = Rectangle(3, 4), r.area() renvoie 12, r.perimeter() renvoie 14 et r.is_square() renvoie False. Chaque méthode lit les attributs du même objet. Un second rectangle utilise les mêmes définitions de méthodes avec sa propre largeur et sa propre hauteur.

Dans une méthode, self.width désigne un attribut. Un simple width désigne une variable locale ou une autre variable accessible ; Python ne la cherche pas automatiquement sur l’objet courant. Si aucune variable de ce nom n’existe, return width * height lève NameError. Écrire self. indique explicitement à quel objet appartiennent les données voulues.

Suivre l’appel

Pour cette classe, r.area() fonctionne comme Rectangle.area(r). Python trouve la fonction sur la classe et fournit r comme premier argument. Une référence à une méthode comme r.area est une méthode liée : elle mémorise la fonction et ce rectangle. Ajouter () effectue l’appel.

Si une méthode est définie par def resize(self, factor), appelle-la sous la forme r.resize(2). r remplit self et 2 remplit factor. Tu ne passes pas r une seconde fois. Si une méthode d’instance est écrite par erreur sous la forme def area():, un appel sur r lève TypeError, car Python fournit quand même l’objet à une fonction qui n’accepte aucun argument.

Une méthode peut en utiliser une autre par l’intermédiaire de self :

    def double_area(self):
        return self.area() * 2

Ici, self.area() effectue le calcul avec le même rectangle. Omettre self. désignerait une fonction distincte appelée area, pas la méthode de l’objet.

Renvoyer des résultats à l’appelant

Une méthode de calcul doit normalement renvoyer son résultat. Le renvoi donne au code appelant une valeur à stocker, combiner, tester ou afficher :

r1 = Rectangle(3, 4)
r2 = Rectangle(2, 5)
total = r1.area() + r2.area()
print(total)  # 22

Si area se contentait d’afficher sa réponse, chaque appel renverrait None. L’addition échouerait alors avec TypeError, même si deux nombres étaient apparus à l’écran. Afficher est une action ; renvoyer fournit une valeur à l’expression qui contient l’appel.

Utilise des noms de méthodes qui montrent leur rôle. deposit et resize désignent des actions ; is_square et has_room suggèrent des vérifications booléennes. Une méthode n’a pas besoin de paramètres pour les données déjà stockées sur son objet. Elle a besoin de paramètres pour les nouvelles entrées, comme un facteur de redimensionnement ou un montant à déposer.

L’état d’un objet est l’ensemble des valeurs actuelles de ses attributs. Un accesseur permet de consulter cet état. Un mutateur le modifie. Un mutateur utile vérifie ses entrées et tient à jour tous les attributs concernés, afin que le code appelant n’ait pas à coordonner plusieurs mises à jour.

Valider d’abord l’ensemble de la modification

Ajoute ces méthodes dans la classe BankAccount avec son titulaire, son solde et sa liste de transactions :

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("deposit must be positive")
        self.balance += amount
        self.transactions.append(("deposit", amount))

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("withdrawal must be positive")
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance -= amount
        self.transactions.append(("withdraw", amount))

Un dépôt modifie le solde et enregistre l’opération. Un retrait vérifie à la fois le signe du montant et le solde disponible avant de soustraire. Ces vérifications empêchent un retrait refusé de modifier le solde ou son historique.

En partant de BankAccount("Maya", 50), un dépôt de 25 donne 75, et un retrait de 30 donne 45. Une tentative ultérieure de retrait de 100 lève ValueError ; elle laisse le solde à 45 et n’ajoute aucune transaction. Placer la soustraction avant la vérification des fonds modifierait l’état même en cas d’échec.

Distinguer une modification d’une valeur renvoyée

Ces mutateurs n’ont pas d’instruction de retour, donc ils renvoient None. Après new_balance = acct.deposit(25), le dépôt a eu lieu, mais new_balance vaut None. Lis ensuite acct.balance pour obtenir la valeur mise à jour.

Une classe peut proposer un autre type de méthode qui renvoie un nouvel objet. resize suggère de modifier un rectangle ; resized peut être choisi pour une méthode qui renvoie un nouveau rectangle et laisse l’original intact. Lis le contrat de la méthode : le nom est utile, mais c’est sa définition qui détermine le comportement.

Suivre les références partagées

a = BankAccount("Maya", 50)
b = a
b.deposit(10)
print(a.balance)  # 60
print(a is b)     # True

Une affectation lie un nom à un objet ; elle ne copie pas cet objet. Les deux noms donnent accès au compte dont le solde a changé. Passer a à une fonction donne aussi accès à cet objet. Une fonction qui appelle account.withdraw(5) peut donc modifier le compte vu par son appelant.

Pour obtenir un compte indépendant avec le même titulaire et le même solde, crée BankAccount(a.owner, a.balance). Ce constructeur fournit aussi un nouvel historique vide. C’est un nouveau compte, pas une copie complète de l’historique.

copy.copy(a) crée un nouvel objet externe mais conserve des références aux mêmes objets internes, notamment la liste des transactions. copy.deepcopy(a) copie aussi les objets imbriqués. Lorsque l’indépendance compte, vérifie les objets contenus dans les attributs ainsi que l’instance externe.

Affecter directement acct.balance = -500 contourne les vérifications des deux méthodes. Les conventions pour les attributs internes et les propriétés aident à rendre claire la façon prévue de faire les mises à jour et à garder la validation près des changements d’état.

Le code appelant a besoin d’un moyen clair de lire et de modifier un objet. L’encapsulation conserve les règles relatives aux données avec les méthodes qui les gèrent. Python utilise des conventions et des propriétés pour exprimer cette interface.

Signaler le stockage interne

Un tiret bas initial dans _balance signale un attribut interne. Les appelants doivent utiliser les méthodes du compte, mais Python autorise toujours l’accès direct. Il n’existe pas de mot-clé private qui verrouille l’accès à la valeur.

Un nom comme __balance, avec deux tirets bas au début et sans double tiret bas à la fin, déclenche la déformation des noms. Dans class Acc, self.__balance est stocké sous _Acc__balance. À l’extérieur, obj.__balance échoue, mais obj._Acc__balance peut toujours fonctionner. La déformation évite les conflits de noms ; elle ne protège pas les données sensibles.

Exécuter une méthode avec la syntaxe d’un attribut

Une propriété fait exécuter une méthode lorsqu’un attribut est lu. La ligne @property est un décorateur : elle change la manière dont Python expose la méthode. Une propriété sans setter permet la lecture mais refuse l’affectation.

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    @property
    def balance(self):
        return self._balance

Après acct = Account("Maya", 50), lis acct.balance sans parenthèses. L’affectation acct.balance = 10 lève AttributeError, car cette propriété n’a pas de setter. Une méthode de dépôt dans la classe pourrait mettre à jour _balance après ses vérifications.

Vérifier une affectation avec un setter

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not 0 <= value <= 100:
            raise ValueError("score must be between 0 and 100")
        self._score = value

L’accesseur et le setter portent tous deux le nom score ; la valeur stockée utilise _score. À la création, self.score = score exécute le setter.

Pour s = Student("Ana", 88), l’affectation s.score = 92 stocke 92. L’affectation s.score = -1 lève ValueError avant le stockage, donc le score reste à 92. Student("Ana", 105) échoue pendant l’initialisation.

Dans le setter, self.score = value rappellerait le setter, et cela se répéterait jusqu’à RecursionError. L’accesseur présente le même risque s’il renvoie self.score. Utilise le nom de stockage distinct _score dans les deux corps.

Calculer les valeurs à leur lecture

Une propriété peut calculer une valeur à partir d’autres attributs :

    @property
    def area(self):
        return self.width * self.height

Placée dans une classe de rectangle, elle permet d’utiliser r.area. Pour une largeur de 3 et une hauteur de 4, la valeur est de 12. Faire passer la largeur à 5 amène la lecture suivante à renvoyer 20. Stocker une aire une seule fois pendant l’initialisation laisserait une ancienne valeur après un changement de largeur.

Commence par un attribut simple lorsqu’un stockage simple répond au besoin.

Un objet est plus facile à examiner lorsqu’il peut décrire ses propres données. Les méthodes spéciales permettent à Python de demander cette description au moyen d’actions familières comme print, str et repr. Leurs noms commencent et se terminent par deux tirets bas et sont souvent appelés noms dunder.

Choisir un texte pour deux publics

__str__ fournit un texte lisible aux utilisateurs d’un programme. __repr__ fournit une description précise aux programmeurs. Les deux renvoient des chaînes de caractères ; aucune ne doit afficher son résultat au lieu de le renvoyer.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)        # (3, 4)
print(repr(p))  # Point(3, 4)

str(p) renvoie la chaîne "(3, 4)". repr(p) renvoie "Point(3, 4)". Lorsque c’est possible, une représentation ressemble à un appel de classe qui recréerait la valeur. Cela reste du texte : appeler repr ne crée pas en soi un autre point.

Sans représentation personnalisée, une instance ordinaire affiche généralement un nom de classe et un identifiant qui ressemble à une adresse. Cela aide à distinguer les objets mais ne montre pas leurs données utiles. Tu appelles rarement ces méthodes spéciales directement ; définis-les une fois et utilise les opérations d’affichage ordinaires de Python.

Prévoir ce qu’affiche un conteneur

Avec la classe ci-dessus, print([Point(3, 4), Point(0, 0)]) affiche [Point(3, 4), Point(0, 0)]. La liste utilise les représentations de ses éléments, même si chaque élément possède aussi __str__.

Si tu définis __repr__ seule, la méthode __str__ par défaut l’utilise aussi. Définir __str__ seule ne change pas repr ni l’affichage des conteneurs. Si tu ajoutes une seule méthode d’affichage, __repr__ sert donc dans davantage de situations d’examen.

Éviter les ambiguïtés dans les champs textuels

Pour un livre qui stocke déjà title, author et year, ces méthodes donnent deux représentations utiles :

    def __str__(self):
        return f"{self.title} by {self.author} ({self.year})"

    def __repr__(self):
        return f"Book({self.title!r}, {self.author!r}, {self.year})"

Pour le livre dont le titre est "Dune", l’auteur "Frank Herbert" et l’année 1965, la première méthode donne "Dune by Frank Herbert (1965)". La seconde donne "Book('Dune', 'Frank Herbert', 1965)". !r demande les représentations des champs textuels, guillemets compris.

Un corps qui contient seulement print(self.x) renvoie None, donc str(p) échoue avec TypeError. Renvoyer un entier échoue aussi. Construis le texte nécessaire, puis renvoie cette chaîne.

Les méthodes spéciales relient une classe aux opérateurs et aux fonctions natives. Définis seulement des opérations dont le sens est clair pour ce type : additionner des vecteurs est compréhensible ; ajouter un joueur à une équipe est plus clair avec team.add_player(player).

Comparer les valeurs et assurer la fiabilité du hachage

Par défaut, deux instances ordinaires distinctes ne sont pas égales. Ajoute l’égalité de valeur à une classe de points avec :

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return self.x == other.x and self.y == other.y

Deux points en (3, 4) sont maintenant considérés comme égaux même si leurs identités diffèrent. Sur les listes, in, count, index et remove peuvent trouver de telles valeurs égales. Le résultat habituel de != découle de __eq__.

NotImplemented est une valeur de retour qui permet à Python d’essayer l’autre opérande ou une solution de repli. Ce n’est pas une exception à lever. Lorsqu’aucun des deux opérandes ne prend en charge l’égalité de valeur, == se rabat sur l’identité ; un point et la chaîne "3,4" ne sont pas considérés comme égaux.

Définir __eq__ sans __hash__ rend les instances non hachables. Elles ne peuvent alors pas être membres d’un ensemble ni clés d’un dictionnaire. Des objets égaux doivent avoir des valeurs de hachage égales, et celle d’une clé doit rester stable. Si les attributs comparés ne changent jamais, une méthode de hachage correspondante peut renvoyer hash((self.x, self.y)). Garde les objets de valeur mutables non hachables lorsque leurs champs servant à l’égalité peuvent changer.

Définir un ordre

__lt__ fournit <. Une classe d’étudiants peut comparer les scores avec return self.score < other.score. Les scores 88, 72 et 95 sont alors triés dans l’ordre 72, 88, 95. min choisit le plus bas ; max choisit le plus haut en utilisant > et sa comparaison réfléchie <.

Avec __lt__ seule, a > b peut utiliser b < a. Python ne déduit pas <= ni >= de cette définition ; ces opérateurs ont besoin de leurs propres méthodes. Si un ordre n’est utile que pour une seule tâche, passe plutôt une fonction clé :

def by_score(student):
    return student.score

ordered = sorted(students, key=by_score)

Renvoyer de nouveaux résultats arithmétiques

Dans une classe de vecteurs avec des attributs x et y :

    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, factor):
        if not isinstance(factor, (int, float)):
            return NotImplemented
        return Vector(self.x * factor, self.y * factor)

    def __rmul__(self, factor):
        return self * factor

Vector(1, 2) + Vector(3, 4) produit un nouveau vecteur (4, 6). Multiplier le premier vecteur par 3 produit (3, 6), sans le modifier. __mul__ gère le vecteur à gauche ; __rmul__ prend en charge un nombre à gauche. Python ne suppose pas que les deux ordres ont le même sens.

Fournir une longueur qui a un sens

Pour une liste de lecture qui stocke self.songs, définis __len__ pour renvoyer len(self.songs). Le résultat doit être un entier positif ou nul. len(playlist) compte alors les chansons. Dans cette classe, une longueur nulle rend aussi if playlist: faux ; une méthode __bool__ personnalisée aurait priorité sur la longueur lors du test de vérité.

Les attributs d’un objet peuvent désigner d’autres objets. Un panier contient des articles, une bibliothèque contient des livres et un cours compte des étudiants. La composition construit un objet plus grand à partir d’objets plus petits grâce à cette relation de possession.

Donner à chaque objet sa propre responsabilité

class Item:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity

    def subtotal(self):
        return self.price * self.quantity

class ShoppingCart:
    def __init__(self):
        self.items = []

    def add(self, item):
        if not isinstance(item, Item):
            raise TypeError("a cart holds Item objects")
        self.items.append(item)

    def total(self):
        total = 0
        for item in self.items:
            total += item.subtotal()
        return total

Le panier possède une liste distincte créée pendant l’initialisation. Sa méthode add vérifie l’objet reçu avant de l’ajouter. cart.add("pen") lève TypeError au lieu de stocker du texte qui provoquerait un échec lorsqu’un sous-total serait demandé.

Crée les articles avant ou pendant les appels :

cart = ShoppingCart()
cart.add(Item("notebook", 2.50, 4))
cart.add(Item("pen", 1.25, 3))
print(cart.total())         # 13.75
print(cart.items[0].name)   # notebook

Les sous-totaux sont 10.0 et 3.75 ; le panier les additionne pour obtenir 13.75. La chaîne cart.items[0].name accède d’abord à la liste du panier, puis à son premier objet, puis au nom de cet objet.

Déléguer le travail à l’objet qui sait le faire

Le panier demande subtotal() à chaque article. C’est la délégation : un objet appelle la méthode d’un autre objet pour effectuer une partie d’une tâche. Si une remise sur quantité change le calcul d’un sous-total, cette règle appartient à Item.subtotal. Le panier peut continuer à additionner les sous-totaux renvoyés sans dupliquer les règles de prix.

Passer Item au lieu de Item(...) transmet la classe, pas un article acheté. La vérification de type rejette cet objet classe. Effectue tous les ajouts par la méthode qui vérifie ; un accès direct à cart.items.append(...) contournerait add.

Rechercher un objet

Ajoute cette méthode dans ShoppingCart :

    def find(self, name):
        for item in self.items:
            if item.name == name:
                return item
        return None

La première correspondance renvoie l’article existant. En l’absence de correspondance, la méthode renvoie None. Vérifie found is None avant d’utiliser found.name ; None n’a pas un tel attribut. Une méthode __len__ qui renvoie len(self.items) pourrait aussi permettre à len(cart) de compter les objets articles stockés, tandis que __str__ pourrait assembler les lignes des articles en un ticket.

Suivre les références dans les collections

Une liste stocke des références : placer le même article dans deux paniers ne le copie donc pas. Mettre à jour le prix de cet article influe sur le prochain total calculé par les deux paniers. Des listes de panier distinctes évitent le partage involontaire de la liste, mais ne rendent pas indépendants les objets qu’elles contiennent. Crée des articles distincts lorsque les paniers doivent contenir des données indépendantes.

Les objets peuvent être des arguments et des valeurs de retour de méthodes, comme les nombres ou les chaînes de caractères. Suis séparément l’objet récepteur, les arguments et le résultat : une méthode peut modifier un objet existant, renvoyer un nouvel objet ou simplement communiquer une valeur.

Utiliser un autre objet comme entrée

Dans une classe de points avec x et y, une méthode peut lire les deux points :

    def midpoint(self, other):
        return Point((self.x + other.x) / 2,
                     (self.y + other.y) / 2)

Pour p = Point(3, 4) et q = Point(1, 0), middle = p.midpoint(q) crée un troisième point en (2.0, 2.0). Pendant l’appel, self désigne p et other désigne q. La méthode calcule les coordonnées et construit un nouveau point ; elle n’affecte rien à aucun des deux points d’origine.

Avec import math, une méthode de distance peut renvoyer math.hypot(self.x - other.x, self.y - other.y). Point(0, 0).distance_to(Point(3, 4)) donne alors 5.0. Cet appel renvoie un nombre, tandis que midpoint renvoie un objet.

Laisser chaque objet récepteur gérer ses modifications

Dans une classe de comptes avec des méthodes withdraw et deposit qui effectuent des vérifications :

    def transfer_to(self, other, amount):
        self.withdraw(amount)
        other.deposit(amount)

Si Maya a 100 et Leo a 20, maya.transfer_to(leo, 30) retire d’abord une somme du compte de Maya, laissant 70, puis la dépose sur celui de Leo, donnant 50. Dans le premier appel, self est le compte de Maya. Dans l’appel de dépôt, son propre self est le compte de Leo.

Un transfert ultérieur de 500 échoue dans withdraw parce que Maya n’a que 70. L’exécution s’arrête avant deposit, donc les deux soldes gardent leurs valeurs précédentes. L’ordre des appels compte. Python n’annule pas un changement d’état antérieur si un appel ultérieur lève une exception ; cette courte méthode suppose que le compte destinataire puisse accepter le montant du dépôt.

Appeler other.deposit(amount) exécute les règles du compte destinataire à un seul endroit. Modifier directement other.balance les contournerait.

Suivre les objets, pas seulement les noms de variables

Dessine chaque instance sous forme d’une boîte contenant ses attributs. Dessine une flèche de chaque variable vers sa boîte. Lors d’un appel, détermine quelle boîte reçoit self et quelles boîtes sont passées comme arguments. Mets à jour la boîte concernée après chaque ligne qui modifie l’état avec succès. Deux flèches vers une même boîte signifient qu’une modification par l’un ou l’autre nom atteint le même objet.

Une simple fonction peut aussi agir sur plusieurs objets. total_balance(accounts) peut parcourir les comptes et additionner leurs soldes. Ce calcul sur toute la liste n’a pas besoin d’appartenir à un seul compte.

Représenter une relation absente

Un livre peut commencer avec self.borrower = None, puis stocker plus tard un objet représentant un adhérent. Avant de lire un attribut de l’adhérent, vérifie la relation :

if book.borrower is not None:
    print(book.borrower.name)

Sinon, book.borrower.name échoue lorsque le livre n’a pas d’emprunteur. Les classes peuvent être définies au-dessus d’une fonction main() qui crée et relie les objets. Appeler main() sous if __name__ == "__main__": empêche ces actions de s’exécuter lorsque les classes sont importées.

Une classe a sa place lorsque des données liées et des opérations répétées sont plus faciles à comprendre ensemble. Tu n’as pas besoin de transformer chaque fonction ou enregistrement en classe. Choisis la structure qui rend les responsabilités du programme claires.

Chercher les données et le comportement qui vont ensemble

Les classes sont utiles lorsque plusieurs fonctions acceptent sans cesse le même groupe de valeurs, que de nombreux enregistrements partagent une structure et que les changements d’état doivent suivre des règles communes. Plusieurs comptes qui permettent tous des dépôts et des retraits s’y prêtent bien. Un calcul unique peut rester une fonction. Un enregistrement fixe en lecture seule peut rester un tuple ou un dictionnaire.

Une classe qui ne contient que l’initialisation et une opération effectuée une seule fois ajoute souvent plus de formalisme que de structure utile. Demande-toi ce que représente une instance et quelles actions répétées lui appartiennent. Si tu ne peux pas répondre simplement à ces questions, reconsidère la conception.

Placer une opération près de ses données

Un compte fondé sur un dictionnaire pourrait commencer ainsi :

account = {"owner": "Maya", "balance": 50}

def deposit(account, amount):
    account["balance"] += amount

La version avec classe peut placer la même opération à côté de son état et de ses règles :

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("deposit must be positive")
        self.balance += amount

    def __repr__(self):
        return f"BankAccount({self.owner!r}, {self.balance})"

Après acct = BankAccount("Maya", 50) et acct.deposit(25), sa représentation est BankAccount('Maya', 75). La règle qui impose un dépôt positif s’exécute maintenant chaque fois que les appelants utilisent cette méthode. Lire account["balence"] lèverait KeyError ; lire acct.balence lève AttributeError. Une classe n’élimine pas les fautes d’orthographe, mais elle donne aux données et à leurs opérations un emplacement nommé.

Concevoir à partir d’une courte description

Pour « Une bibliothèque prête des livres à ses adhérents. Un adhérent peut emprunter au maximum 3 livres », les noms suggèrent Book, Member et Library. Les verbes suggèrent des méthodes d’emprunt et de retour.

1. Liste ce que chaque instance connaît : le titre, l’auteur et l’emprunteur d’un livre ; le nom et les livres empruntés d’un adhérent ; les livres et les adhérents d’une bibliothèque.
2. Identifie les règles : un livre ne peut pas être déjà emprunté et un adhérent ne peut pas dépasser MAX_LOANS = 3.
3. Place chaque règle dans l’opération qui modifie la relation, comme Library.check_out(book, member).
4. Écris l’initialisation et une représentation utile, puis ajoute et teste une action à la fois.

Des titres différents nécessitent des instances différentes de Book, pas des classes distinctes nommées d’après chaque titre. Utilise des noms au singulier pour les objets individuels, comme Book ; nomme une collection d’après la collection, comme Library. Garde la tâche de chaque classe suffisamment claire pour la décrire en une phrase.

Tester le comportement observable

acct = BankAccount("Maya", 50)
acct.deposit(25)
assert acct.balance == 75

assert lève AssertionError si sa condition est fausse. Teste aussi les actions refusées : intercepte l’exception attendue et vérifie que l’état n’a pas changé. Utilise une validation explicite avec raise pour les entrées de l’appelant ; les assertions sont des vérifications effectuées pendant le développement et peuvent être désactivées lorsque Python s’exécute avec l’optimisation.