Solution du problème Vector

Vous trouverez ici la solution pour l'exercice suivant:

Vector

Exercice de base

Rien de bien compliqué ici, il s'agit simplement d'ecrire une classe Vector, avec les coordonnées sous forme d'attributs. Comme déjà vu précédement, il faut redéfinir la fonction __repr__ afin de pouvoir avoir la bonne représentation en text.

class Vector:
    def __init__(self, point1, point2):
        self.x = point2[0] - point1[0]
        self.y = point2[1] - point1[1]
        self.z = point2[2] - point1[2]

    def __repr__(self):
        return f"Vector(x={self.x}, y={self.y}, z={self.z})"

Note

ici nous utilisons une f-string qui a étée introduite avec Python 3 et qui permet de faire des remplacements de valeurs directement dans une string.

La partie restante concerne l'egalité entre deux vecteurs. Pour cela on redefini l'operateur __eq__ où on va regarder si les coordonnées sont égales deux à deux:

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y and self.z == other.z

Et Voila!

Bonus 1

Ajoutons la possibilité d'ajouter des vecteurs entre eux. Pour cela il faut redefinir la methode __add__. Comme nous ne voulons pas changer un vecteur quand nous faisons une addition il va falloir retourner un nouveau vecteur:

    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        z = self.z + other.z
        return Vector((0, 0, 0), (x, y, z))

Pour la soustraction, il suffit de remplacer le '+' par '-' en redéfinissant la function __sub__:

def __sub__(self, other):
    x = self.x - other.x
    y = self.y - other.y
    z = self.z - other.z
    return Vector((0, 0, 0), (x, y, z))

Bonus 2

La multiplication par un scalaire, c'est tout aussi simple: redéfinir la fonction __mul__:

def __mul__(self, factor):
    x = self.x * factor
    y = self.y * factor
    z = self.z * factor
    return Vector((0, 0, 0), (x, y, z))

Cela permettra de faire en sorte que AB * 2 fonctionne, mais pour que 2 * AB fonctionne, cela n'aide pas. En effet, lorsqu'on tape AB * 2, python va chercher la methode __mul__ sur AB. Donc, lorsqu'on tape 2 * AB, python cherche la methode __mul__ sur 2 et lui demande de se mltiplier par un vecteur. Or il ne connais pas du tout Vector... La manière de faire fonctionner cela est de redefinir la methode __rmul__ qui est la justement pour palier ce manque. Du coup, quand on fera 2 * AB, python appellera __rmul__ sur le vecteur AB, et comme, ici, la multiplication est commutative, on peut appeler __mul__ dans notre implementation:

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

Bonus 3

Ah enfin quelque chose de plus complex... , non? Non!? Et bien non! Ici il va juste falloir faire en sorte que notre classe retourne un iterateur. Rien de plus simple: redéfinir __iter__ qui devra retourner un iterator sur la liste des coordonnées:

    def __iter__(self):
        return iter((self.x, self.y, self.z))

Juste pour la route, voila une solution qui m'a été souflée pendant la présentation:

    def __iter__(self):
        yield self.x
        yield self.y
        yield self.z

Et oui, mettre yield permet de faire d'une simple fonction un iterateur, et donc de remplir le besoin ici.

Et voila qui clos cet exercice. Merci de votre attention.