une classe

j_bauvois@yahoo.fr wrote:

Bonjour ;
pouriez vous m'expliquer ce que fai ( et comment fonctionne ) cette
fonction ?


class Doublet:
def __init__(self,referenceMonome,refSuiv):
self.refMon = referenceMonome
self.suiv = refSuiv
def __repr__(self):
res=''
cour=self
while cour!=None:
res+=str(cour.refMon)
cour=cour.suiv
if res[0]=='+':
return res[1:]
return res


merci d'avance

La doc dit que "overloader" __repr__ n'est généralement utilisé que dans des
cas de débug.

Difficile de voir (à part cette recherche de '+' et son remplacement) ce
qu'elle fait.

un premier essai retourne d'ailleur une erreur innatendue

ex:
class Doublet:
def __init__(self,referenceMonome,refSuiv):
self.refMon = referenceMonome
self.suiv = refSuiv
def __repr__(self):
res=''
cour=self
while cour!=None:
res+=str(cour.refMon)
cour=cour.suiv
if res[0]=='+':
return res[1:]
return res


c = Doublet('a+b+c','-')
print c


Traceback (most recent call last):
File "t.py", line 17, in -toplevel-
print c
File "t.py", line 9, in __repr__
res+=str(cour.refMon)
AttributeError: 'str' object has no attribute 'refMon'



hg

Bonjour ;
Bonjour

pouriez vous m'expliquer ce que fai ( et comment fonctionne ) cette
fonction ?


class Doublet:
def __init__(self,referenceMonome,refSuiv):
self.refMon = referenceMonome
self.suiv = refSuiv
def __repr__(self):
res=''
cour=self
while cour!=None:
res+=str(cour.refMon)
cour=cour.suiv
if res[0]=='+':
return res[1:]
return res

Visiblement, il faut analyser le fonctionnement de cette classe dans son contexte.

A la lecture de la définition des deux méthodes qu'elle contient (il y en a sûrement d'autres dans la vraie classe), les appels se font de la façon suivante :
c1 = Doublet(x1, None)
c2 = Doublet(x2, c1)
c3 = Doublet(x3, c2)
.
.
.
La méthode __repr__ permet d'obtenir une représentation textuelle de cn. Par exemple, pour c3, on aura str(x3)+str(x2)+str(x1). Eventuellement, un "+" au début de la chaîne obtenue sera supprimé.

Nicolas

Bonjour ;
pouriez vous m'expliquer ce que fai ( et comment fonctionne ) cette
fonction ?

s/fonction/classe/

class Doublet:
def __init__(self,referenceMonome,refSuiv):
self.refMon = referenceMonome
self.suiv = refSuiv

Une instance de cette classe est initialisée avec un objet
'referenceMonome' (aucune idée de ce que ça peut être) et un objet
refSuiv qui est manifestement supposé être une autre instance de
Doublet. Bref, une implémentation d'une liste simplement chaînée ayant
des 'referenceMonome' comme 'valeur'...

def __repr__(self):
res=''
cour=self
while cour!=None:
res+=str(cour.refMon)
cour=cour.suiv

Typiquement un parcours de liste simplement chaînée, ici utilisé pour
construire la représentation de l'objet.

if res[0]=='+':
return res[1:]
NB : Suppression du premier caractère si c'est le caractère '+'

return res

Sinon, qu'est-ce qui te pose problème exactement ?

Bonjour
En fait j'avais pas donné beaucoup de détails qui auraient pu vous
aider a mieux comprendre ma question
voila mon probleme
les fonctions encadrées sont données


# Polynômes à deux indéterminées : ENONCE
# les choix :
# les monomes qui composent un polynôme ne composent que ce
polynôme :
# ils ne composent pas d'autre polynôme
# si deux polynômes contiennent un même monome, ce monome existe
en deux exemplaires
# les monomes d'un polynôme n'ont JAMAIS de coefficient nul
___________________________________________________________________________ __

class Monome:
def __init__(self, coefficient, exposantX, exposantY):
self.coeff = coefficient
self.expoX = exposantX
self.expoY = exposantY
def __repr__(self):
s=str(self.coeff)+"*x^"+str(self.expoX)+"*y^"+str(self.expoY)
if self.coeff<0: return s
return "+"+s
def __lt__(self, autre):
return (self.expoX < autre.expoX) or ((self.expoX ==
autre.expoX) and (self.expoY < autre.expoY))
def __gt__(self,autre):
return (self.expoX > autre.expoX) or ((self.expoX ==
autre.expoX) and (self.expoY >autre.expoY))
___________________________________________________________________________ __


___________________________________________________________________________ __

class Doublet:
def __init__(self,referenceMonome,refSuiv):
self.refMon = referenceMonome
self.suiv = refSuiv
def __repr__(self):
res=''
cour=self
while cour!=None:
res+=str(cour.refMon)
cour=cour.suiv
if res[0]=='+':
return res[1:]
return res
___________________________________________________________________________ __


___________________________________________________________________________ __

def degre(mon):
return(mon.expoX + mon.expoY)
___________________________________________________________________________ __


___________________________________________________________________________ __
def degreX (mon):
return mon.expoX
___________________________________________________________________________ __



les fonctions qui suivent , je dois les corriger et/ou les completer

def insereMonome(coefficient, exposantX, exposantY, doublett) :
# chercher le dernier monome avant ce nouveau monome
# faire l'insertion en créant le monome qui sera placé
# bien placé pour l'ordre croissant "<" sur les monomes
# création du nouveau monome
newRefMon = Monome(coefficient, exposantX, exposantY)
print "nouveau monome : ",newRefMon
return None



def insereCopieMonome( refMon, doublett):
# NE PAS modifier cette fonction
return insereMonome(refMon.coeff, refMon.expoX, refMon.expoY,
doublett)




def ajouteDoubletsRec(listeDoublet1, listeDoublet2):
# renvoie une nouvelle liste de doublets obtenue par
# fusion des deux listes en une nouvelle
# ATTENTION : ne pas oublier de traîter le cas où l'on additionne
deux monomes opposés !!!!!
# dans ce cas, NE PAS faire apparaître un monome avec un
coefficient nul.

return None




def multMonomeMonome(refMon1, refMon2):
return Monome(refMon1.coeff * refMon2.coeff, refMon1.expoX +
refMon2.expoX, refMon1.expoY + refMon2.expoY)
def multMonomeListeDoublets(refMon, listeDoublets):
res = None
return res
def multDeuxListesDoublets(ld1, ld2):
res = None
return res


___________________________________________________________________________ __
class Polynome:
def __init__(self,listePrincipale):
self.lp = listePrincipale
self.lDegre = creerListeDegre(listePrincipale)
triDegre(self.lDegre)
___________________________________________________________________________ __



___________________________________________________________________________ __

def __repr__(self):
doub = self.lp
res = " liste pour l'ordre < n"
res = res + str(doub)
res = res + "n n "
res = res + " liste pour l'ordre du degré total n"
doub = self.lDegre
res = res + str(doub)
return res
___________________________________________________________________________ __


___________________________________________________________________________ __



def creerListeDegre(ld):
if ld == None:
return None
else:
return Doublet(ld.refMon, creerListeDegre(ld.suiv))
___________________________________________________________________________ __


def triDegre(doublett):
# on modifie par échange les valeurs des champs "refMon" de la
liste doublett, de façon que
# la liste doublett soit croissante pour l'ordre du degré.
return



def add(pol1, pol2):
return None



def mul(pol1, pol2):
return None



# ---------- FIN de la définition des fonctions et méthodes ----

# --------------------------------------------------------------
# essais sur les monômes
#m1 = Monome(5,2,6)
#m2 = Monome(6,2,8)
#m3 = Monome(-4,3,1)
#m4 = Monome(-6,0,1)
#print "m1 : ",m1, " m2 : ",m2
#print "m3 : ",m3, " m4 : ",m4
#print m1 < m2
#print m3 < m4
#print
# essais sur les doublets
#d1 = Doublet(m1,None)
#print "doublet d1 : ",d1
#doublet1 = Doublet(Monome(-4,7,1),Doublet(Monome(2,4,3),None))
#doublet2 = Doublet(m1,Doublet(m2,None))
#print
#print"doublet1 : ",doublet1, " doublet2 : ",doublet2
#print
# essais de la fonction insereMonome
#doub1 = insereMonome(5, 2, 6, None)
#doub1 = insereMonome(6,3,8, doub1)
#doub2 = insereMonome(5,10,3, None)
#doub2 = insereMonome(4,2,6, doub2)
#doub2 = insereMonome(-3,11,7, doub2)
#doub2 = insereMonome(-6, 3,8, doub2)
#doub2 = insereMonome(2,3,0, doub2)
#print "doub1 : ",doub1
#print" doub2 : ",doub2
# essais de la fonction ajouteDoubletsRec
#listeAjout = ajouteDoubletsRec(doub1, doub2)
#print "somme des deux listes : ", listeAjout

# essais de la fonction multMonomeListeDoublets
# ESSAIS A CONSTRUIRE

# essais de la fonction multDeuxListesDoublets
# ESSAIS A CONSTRUIRE
# Essais de la fonction creerListeDegre
#ESSAIS A CONSTRUIRE
# essais de la fonction triDegre
# ESSAIS A CONSTRUIRE
# essais de polynomes : représentation, addition, multiplication
# ESSAIS A CONSTRUIRE
#pol1 = Polynome(doublet1)
#pol2 = Polynome(doublet2)
#som = add(pol1, pol2)
#prod = mult(pol1, pol2)
#print som
#print prod




et je bloque dès la 1ere question .
en fait , on n'a pas vu les "class" en cours et de ce fait le prof nous
a donné lui meme les fonctions ( class ) necessaires
mais j'ai un souci avec tout ca car je ne comprends pas le
fonctionnement de ces classes et donc j'arrive pas a les utiliser
correctement
en effet , rien que la classe Doublet me pose probleme :

Si , par exemple , je fais

a=Monome(2,7,11)
a
+2*x^7*y^11

b=Monome(-1,17,35)
b
-1*x^17*y^35

c=Doublet(a,b)
t
Traceback (most recent call last):

File "<pyshell#5>", line 1, in <module>
t
File "C:...polynomesXY2_DEVOIR_Enonce.py", line 36, in __repr__
res+=str(cour.refMon)
AttributeError: Monome instance has no attribute 'refMon'

ca me retourne un message d'erreur

est-ce du a une mauvaise utilisation de ma part ou c'est dans a
fonction donnée qu'il y a un probleme ?

pourriez vous m'aider SVP ?
merci d'avance et j'espere avoir été clair

merci

un premier essai retourne d'ailleur une erreur innatendue

Pas innatendue du tout...

ex:
class Doublet:
def __init__(self,referenceMonome,refSuiv):
self.refMon = referenceMonome
self.suiv = refSuiv
def __repr__(self):
res=''
cour=self
while cour!=None:
res+=str(cour.refMon)
cour=cour.suiv
if res[0]=='+':
return res[1:]
return res


c = Doublet('a+b+c','-')

... '-' n'est pas de type Doublet...

print c


Traceback (most recent call last):
File "t.py", line 17, in -toplevel-
print c
File "t.py", line 9, in __repr__
res+=str(cour.refMon)
AttributeError: 'str' object has no attribute 'refMon'

... donc l'erreur est normale.

Nicolas

a=Monome(2,7,11)
a
+2*x^7*y^11

b=Monome(-1,17,35)
b
-1*x^17*y^35

c=Doublet(a,b)

Vu la définition de __repr__, ça ne peut pas s'utiliser comme de cette manière.
Le deuxième paramètre de Doublet doit être un objet de type Doublet ou None.

t
Traceback (most recent call last):

File "<pyshell#5>", line 1, in <module>
t
File "C:...polynomesXY2_DEVOIR_Enonce.py", line 36, in __repr__
res+=str(cour.refMon)
AttributeError: Monome instance has no attribute 'refMon'

ca me retourne un message d'erreur

est-ce du a une mauvaise utilisation de ma part ou c'est dans a
Oui

fonction donnée qu'il y a un probleme ?
Non

J'ai pas regardé le reste des fonctions et classes mais Doublet doit être utilisé correctement avant d'aller plus loin. Comme l'a dit Bruno, Doublet sert à créer une liste chaînée simple de Monome(s).


Nicolas

Bonjour
Pouvez vous m'aider a ecrire la 1ere fonction ( insereMonome ) svp pour
que je me fixe les idees ?
merci

NicolasP wrote:

un premier essai retourne d'ailleur une erreur innatendue

Pas innatendue du tout...

ex:
class Doublet:
def __init__(self,referenceMonome,refSuiv):
self.refMon = referenceMonome
self.suiv = refSuiv
def __repr__(self):
res=''
cour=self
while cour!=None:
res+=str(cour.refMon)
cour=cour.suiv
if res[0]=='+':
return res[1:]
return res


c = Doublet('a+b+c','-')

... '-' n'est pas de type Doublet...

print c


Traceback (most recent call last):
File "t.py", line 17, in -toplevel-
print c
File "t.py", line 9, in __repr__
res+=str(cour.refMon)
AttributeError: 'str' object has no attribute 'refMon'

... donc l'erreur est normale.

Nicolas

A ben oui !

hg

Bonjour
Pouvez vous m'aider a ecrire la 1ere fonction ( insereMonome ) svp pour
que je me fixe les idees ?
merci

Ca serait avec plaisir mais j'ai du boulot qui m'attend.

Et puis, pour apprendre, le mieux est de le faire soit même quitte à se planter ;)

Nicolas

Bonjour
Pouvez vous m'aider a ecrire la 1ere fonction ( insereMonome ) svp pour
que je me fixe les idees ?

Pas de problème, c'est 800 euros HT par jour (toute journée entamée
étant due dans son intégralité). Je commence le travail à réception du
premier acompte.

merci

De rien.