class Point:
    def __init__(self,x,y):
        self.__x=x
        self.__y=y
    def __str__(self):
        return "("+str(self.__x)+','+str(self.__y)+")"
    def getX(self):
        return self.__x
    def getY(self):
        return self.__y
    def setx(self,value):
        self.__x=value
    def sety(self,value):
        self.__y=value
    def __add__(self, other):
        return Point(self.__x+other.__x,self.__y+other.__y)
    def __sub__(self, other):
        return Point(self.__x - other.__x, self.__y - other.__y)
    def __mul__(self, other):
        return Point(self.__x * other.__x, self.__y * other.__y)
    def __truediv__(self, other):
        return Point(self.__x/other.__x,self.__y/other.__y)
    def __mod__(self, other):
        return Point(self.__x % other.__x, self.__y % other.__y)
    def __floordiv__(self, other):
        return Point(self.__x // other.__x, self.__y // other.__y)
class Rectongle:
    def __init__(self,p1:Point,p2:Point):
        self.__p1=p1
        self.__p2=p2
    def __str__(self):
        return str(self.__p1)+"  "+str(self.__p2)
    def surface(self):
        return abs(self.__p1.getX()-self.__p2.getX())*abs(self.__p2.getY()-self.__p1.getY())
    def centre(self):
        return Point((self.__p1.getX()+self.__p2.getX())/2,
                     (self.__p1.getY()+self.__p2.getY())/2)
    def deplacer(self,dx,dy):
        self.__p1.setx(self.__p1.getX()+dx)
        self.__p2.setx(self.__p2.getX()+dx)
        self.__p1.sety(self.__p1.getY()+dy)
        self.__p2.sety(self.__p2.getY()+dy)
    def augmenter(self,dx,dy):
        self.__p2.setx(self.__p2.getX()+dx)
        self.__p2.sety(self.__p2.getY()+dy)
# p1=Point(1,3);p2=Point(4,1)
# print(p1+p2);print(p1-p2)
# r1=Rectongle(p1,p2)
# print(r1)
# print(r1.surface())
# print(r1.centre())
# r1.deplacer(4,4)
# print(r1.centre())
# print(r1)
# r1.augmenter(4,4)
# print(r1.surface())
# l=[4,2,4]
# l1=[4,8,5]
class Fraction:
    def __init__(self,num,dem):
        if dem==0:
            raise ZeroDivisionError('le denominateur est null')
        if dem<0:
            dem=-dem
            num=-num
        self.numerateur=num
        self.denominateur=dem
    def __add__(self, other):
        return Fraction(self.numerateur*other.denominateur+self.denominateur*other.numerateur,
                        self.denominateur*other.denominateur)
    def __sub__(self, other):
        return Fraction(self.numerateur * other.denominateur - self.denominateur * other.numerateur,
                        self.denominateur * other.denominateur)
    def __mul__(self, other):
        return Fraction(self.numerateur*other.numerateur,
                        self.denominateur*other.denominateur)
    def __truediv__(self, other):
        return Fraction(self.numerateur*other.denominateur,
                        self.denominateur*other.numerateur)
    def __str__(self):
        return str(self.numerateur)+'/'+str(self.denominateur)
    def __neg__(self):
        return Fraction(-self.numerateur,self.denominateur)
    def simplifier(self):
        from math import gcd
        def pgcd(x,y):
            while y:
                x,y=y,x%y
            return x
            # if y==0: return x
            # else: return pgcd(y,x%y)

        a = pgcd(self.numerateur, self.denominateur)
        return Fraction(int(self.numerateur/a),int(self.denominateur/a))
f1=Fraction(27,18)
print(f1)
print(f1.simplifier())

class Fraction:
    def __init__(self, numerator=1, denominator=1):
        self.numerator = numerator
        self.denominator = denominator
    def __str__(self):
        return f"{self.numerator}/{self.denominator}"
    def __neg__(self):
        return Fraction(-self.numerator, self.denominator)
    def __add__(self, other):
        new_numerator = self.numerator * other.denominator + self.denominator * other.numerator
        new_denominator = self.denominator * other.denominator
        return Fraction(new_numerator, new_denominator)
    def __sub__(self, other):
        new_numerator = self.numerator * other.denominator - self.denominator * other.numerator
        new_denominator = self.denominator * other.denominator
        return Fraction(new_numerator, new_denominator)
    def __mul__(self, other):
        new_numerator = self.numerator * other.numerator
        new_denominator = self.denominator * other.denominator
        return Fraction(new_numerator, new_denominator)
    def __truediv__(self, other):
        new_numerator = self.numerator * other.denominator
        new_denominator = self.denominator * other.numerator
        return Fraction(new_numerator, new_denominator)
class Auteur:
    def __init__(self,nom,email,genre):
        self.__nom=nom
        self.__email=email
        self.__genre=genre
    def getNom(self):
        return self.__nom
    def getEmail(self):
        return self.__email
    def getGenre(self):
        return self.__genre
    def setEmail(self,value):
        self.__email=value
    def __str__(self):
        return self.__nom+" ("+self.__genre+") à "+self.__email
    def __eq__(self, other):
        return self.__email==other.__email
a=Auteur("Mouhamed Aloui","mohamed@gmail.com","M")
a1=Auteur("Mouhamfdgdfged Aloui","mohamed@gmail.com","F")
print(a==a1)
class Livre:
    def __init__(self,titre,auteur,prix,qte_en_stock):
        self.__titre=titre
        self.__auteur=auteur
        self.__prix=prix
        self.__qte=qte_en_stock
    def setPrix(self,value):
        self.__prix=value
    def setQte(self,value):
        self.__qte=value
    def getPrix(self):
        return self.__prix
    def getQte(self):
        return self.__qte
    def getTite(self):
        return self.__titre
    def getAuteur(self):
        return self.__auteur
    def __str__(self):
        res=' et '.join(self.__auteur)
        return self.__titre+' de '+res+" coûte "+str(self.__prix) +" avec "+str(self.__qte)
    def __eq__(self, other):
        return self.__auteur==other.__auteur and self.__titre==other.titre
# l=Livre("POO",["KHalid","Mehdi",'Farida'],120,100)
# print(l)

# class Personne:
#     def __init__(self,nom,prenom,adresse):
#         self.nom=nom
#         self.prenom=prenom
#         self.adresse=adresse
#     def __repr__(self):
#         return self.nom+","+self.prenom+","+self.adresse
# class Etudiant(Personne):
#     def __init__(self,nom,prenom,adresse,filiere):
#         super(Etudiant, self).__init__(nom,prenom,adresse)
#         self.filiere=filiere
#     def __repr__(self):
#         return  super(Etudiant, self).__repr__()+","+self.filiere

# e=Etudiant("ssqdsd","dsqdqs","sdqdsqd","DEV103")
# print(e)
class Personne:
    def __init__(self,nom,prenom,email,tel):
        self.__nom=nom
        self.__prenom=prenom
        self.__tel=tel
        self.__email=email
    def __str__(self):
        return f'{self.__nom} , {self.__prenom} , {self.__email} , {self.__tel}'
class Travailleur(Personne):
    def __init__(self,nom,prenom,email,tel,entro,adresseent,telT):
        super().__init__(nom,prenom,email,tel)
        self.__entro=entro
        self.__adresseEnt=adresseent
        self.__telPro=telT
    def __str__(self):
        return f'{super().__str__()} {self.__entro} {self.__adresseEnt} {self.__telPro}'
class Scientifique(Travailleur):
    def __init__(self,nom,prenom,email,tel,entro,adresseent,telT,displine,typeS):

        super().__init__(nom,prenom,email,tel,entro,adresseent,telT)
        self.__displine=displine
        self.__typeS=typeS
    def ajouterDispline(self,dis):
        self.__displine.append(dis)
    def ajouType(self,value):
        self.__typeS.append(value)
    def __str__(self):
        return f'{super().__str__() } {str(self.__displine)} {str(self.__typeS)}'
sc=Scientifique("ahmed","khaid","sdsd@fgfg.g","024545","test","shdsgq","045454545",["Scien"],["fsdfs"])

sc.ajouType("fsfsdfd")
print(sc)
class Test:
    id=1
    def __init__(self,nom,adresse):
        self.__nom=nom
        self.__adresse=adresse
        self.id=Test.id
        Test.id+=1
    def __repr__(self):
        return f'{self.__nom} {self.id} {self.__adresse}'
    @property
    def nom(self):
        return self.__nom
    @nom.setter
    def nom(self,new):
        self.__nom=new
    @nom.deleter
    def nom(self):
        self.__nom=""
    @nom.getter
    def nom(self):
        return self.__nom
    def afficher(self):
        print('afficher')
    @classmethod
    def afficher2(cls):
        print('afficher 2')
    @staticmethod
    def afficher3():
        print("affciher 3")
t1=Test("ahemd","agadir")
t2=Test("samir","agadir")
print(t1.nom);t1.nom='sdfdsf'
print(t1.nom);del t1.nom;print(t1.nom)
Test.afficher2()
Test.afficher3()
t1.afficher2()