Mutateurs a plusieurs arguments

Bonjour !
Je suis en train de programmer une classe permettant de gérer les segments pour mon application de maths et je suis face à un problème assez bête : mon utilisateur peut changer les points d'extrêmités de son segment de deux façons : soit en donnant un objet Coords qui représente un point / des coordonnées, soit en fournissant directement les nouvelles coordonnées de l'extrêmité.
J'ai testé directement avec le mutateur setA (a, b) et cela fonctionne, mais je ne sais pas comment utiliser une syntaxe de la forme : mon_segment.a = 3, -2 ou mon_segment.a = (3, -2)
J'ai testé les deux, ça ne fonctionne pas... Comment faire ?
Merci !

Voici ma classe (Note : l'utilisateur créé ses segments comme un programmeur Python dans le shell):

# isReal (x) est une fonction vérifiant si un nombre est bien réel
# Un objet Coords possède deux caractéristiques principales : son abcisse et son ordonnée respectivement notés x et y.


class Segment:
    def __init__ (self, a, b, c = None, d = None):  # Si l'utilisateur initialise son segment avec deux Coords
        if (type (a) is Coords) and (type (b) is Coords) and (c is None) and (d is None):
            self._x1 = a.x
            self._y1 = a.y

            self._x2 = b.x
            self._y2 = b.y

        elif isReal (a) and isReal (b) and isReal (c) and isReal (d):  # S'il 'initialise avec des coordonnées
            self._x1 = a
            self._y1 = b

            self._x2 = c
            self._y2 = d

        else:  # S'il a fait n'importe quoi...
            print ("\n Invalid extremities : it must be coordinates !")
            self._x1 = 0
            self._y1 = 0

            self._x2 = 0
            self._y2 = 0


    def _getA (self):  # Accesseur de l'extrêmité a
        return Coords (self._x1, self._y1)

    def _getB (self):  # Accesseur de l'extrêmité b
        return Coords (self._x2, self._y2)

    def _getLength (self):  # Accesseur de la longueur du segment
        return (((self._x2 - self._x1)**2 + (self._y2 - self._y1)**2)**0.5)
    
    
    def _setA (self, a, b = None):  # Mutateur de a
        if type (a) is Coords and b is None:  # Si l'utilisateur fait avec un objet Coords
            self._x1 = a.x
            self._y1 = a.y

        elif isReal (a) and isReal (b):  # Si l'utilisateur entre des coordonnées direct
            self._x1 = a
            self._y1 = b
        
        else:
            print ("\n Invalid new coordinates of a !\n")
    
    def _setB (self, a, b = None):   # Fonctionne de la même façon que setA, mais avec l'autre extrêmité
        if type (a) is Coords and b is None:
            self._x2 = a.x
            self._y2 = a.y

        elif isReal (a) and isReal (b):
            self._x2 = a
            self._y2 = b
        
        else:
            print ("\n Invalid new coordinates of b !\n")
    
    def _setLength (self, nLength):  # On ne peut pas changer la longueur d'un segment comme ça
        print ("\n Impossible to do this, I'm sorry !\n")


    def __repr__ (self):  # Renvoie une petite description du segment
        if self.a != self.b:
            return "\n Start point : {0}\n Finish point : {1}\n Length : {2}\n".format (self.a, self.b, trans (self.length))

        return "\n Only one point : {}\n".format (self.a)

    
    a = property (_getA, _setA)
    b = property (_getB, _setB)
    length = property (_getLength, _setLength)