Python Language Méthodes Magic / Dunder


Exemple

Les méthodes magiques (également appelées dbr comme abréviation de double-trait de soulignement) en Python ont un objectif similaire à la surcharge d'opérateurs dans d'autres langages. Ils permettent à une classe de définir son comportement lorsqu'elle est utilisée comme opérande dans des expressions d'opérateur unaires ou binaires. Ils servent également d'implémentations appelées par certaines fonctions intégrées.

Considérons cette implémentation de vecteurs à deux dimensions.

import math

class Vector(object):
    # instantiation
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # unary negation (-v)
    def __neg__(self):
        return Vector(-self.x, -self.y)

    # addition (v + u)
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    # subtraction (v - u)
    def __sub__(self, other):
        return self + (-other)

    # equality (v == u)
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    # abs(v)
    def __abs__(self):
        return math.hypot(self.x, self.y)

    # str(v)
    def __str__(self):
        return '<{0.x}, {0.y}>'.format(self)

    # repr(v)
    def __repr__(self):
        return 'Vector({0.x}, {0.y})'.format(self)

Il est maintenant possible d'utiliser naturellement des instances de la classe Vector dans diverses expressions.

v = Vector(1, 4)
u = Vector(2, 0)

u + v           # Vector(3, 4)
print(u + v)    # "<3, 4>" (implicit string conversion)
u - v           # Vector(1, -4)
u == v          # False
u + v == v + u  # True
abs(u + v)      # 5.0