[Python 3.X] Swinnen 13.18 can't multiply sequence by non-int of type 'float'

Swinnen 13.18 can't multiply sequence by non-int of type 'float'

Bonjour,
Je rencontre un message d'erreur TypeError: can't multiply sequence by non-int of type 'float' sur l'exercice 13.18 du Swinnen.
Je crée une méthode valeur() dans la classe ChoixVibra qui retourne un tuple contenant 3 variables(phase,freq,ampl) de type float. Cette méthode est appelée par le constructeur de la classe ShowVibra via la méthode montreCourbes(). Les 3 variables sont ensuite passés en paramètres dans la methode traceCourbe() de la classe OscilloGraphe.
Je ne comprends pas ce message d'erreur sachant que lorsque j’exécute le code de la classe Oscillographe seul, je n'ai pas ce message d'erreur.
Merci.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
from oscillo import *
from curseurs_copie import *
 
 
class ShowVibra(Frame):
  """Démonstration de mouvements vibratoires harmoniques"""
  def __init__(self, boss =None):
      Frame.__init__(self)	# constructeur de la classe parente
      self.couleur = ['light green', 'yellow', 'orange','maroon']
      self.trace = [0]*4      # liste des tracés (courbes à dessiner)
      self.controle = [0]*4	 # liste des panneaux de contrôle
 
      # Instanciation du canevas avec axes X et Y : 
      self.gra = OscilloGraphe(self, larg =400, haut=200)
      self.gra.configure(bg ='grey', bd=2, relief=GROOVE)
      self.gra.pack(side =TOP, pady=5)
 
      # Instanciation de 4 panneaux de contrôle (curseurs) : 
      for i in range(4):
          self.controle[i] = ChoixVibra(self, self.couleur[i])
          self.controle[i].pack()
 
 
      # Désignation de l'événement qui déclenche l'affichage des tracés :    
      self.master.bind('<Control-Z>', self.montreCourbes)
      self.master.title('Mouvements vibratoires harmoniques')
      self.pack()
 
  def montreCourbes(self, event):
      """(Ré)Affichage des trois graphiques élongation/temps"""   
      for i in range(4):
 
          # D'abord, effacer le tracé précédent (éventuel) :
          self.gra.delete(self.trace[i])
 
          # Ensuite, dessiner le nouveau tracé :  
          if self.controle[i].chk.get():
            freq,phase,ampl = self.controle[i].valeurs()
            coul = self.couleur[i]
 
            self.trace[i] = self.gra.traceCourbe(coul,freq,phase,ampl)
 
#### Code pour tester la classe : ###
 
if __name__ == '__main__':    
  ShowVibra().mainloop()

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
from tkinter import *
from math import sin, pi
 
class OscilloGraphe(Canvas):
  "Canevas spécialisé, pour dessiner des courbes élongation/temps"
  def __init__(self, boss =None, larg=200, haut=150):
      "Constructeur du graphique : axes et échelle horiz."
      # construction du widget parent :
      Canvas.__init__(self)		    # appel au constructeur
      self.configure(width=larg, height=haut)	      # de la classe parente
      self.larg, self.haut = larg, haut 	     # mémorisation
      # tracé des axes de référence :
      self.create_line(10, haut/2, larg, haut/2, arrow=LAST,fill='white',
                       width=2)  # axe X
      self.create_line(larg/2, haut-5, larg/2, 5, arrow=LAST,fill='white',
                       width=2)	       # axe Y
      self.repere()
 
  def repere(self):
      "trace la grille des axes et ajoute les unités de mesure"
 
      pasx = (self.larg-25)/8     # intervalle de l'échelle horizontale
      pasy = (self.haut-10)/12    #intervalle de l'echelle verticale
      # tracé d'une échelle sur X avec 8 graduations :
      for t in range(0, 9):
          stx = 10 + t*pasx	    # +10 pour partir de l'origine
          self.create_line(stx, 5+pasy, stx, self.haut-5-pasy,fill='white')
      # tracé d'une échelle sur Y avec 10 graduations :
      for i in range(1,12):
          sty = 5 + i*pasy
          self.create_line(10,sty,stx,sty,fill='white')
      # indication des unités
      self.create_text(18,10,text='e',anchor=CENTER,fill='red')
      self.create_text(self.larg-5,self.haut/2-10,text='t',anchor=CENTER,fill='red')
 
  def traceCourbe(self, freq=1, phase=0, ampl=10, coul='red'):
      "tracé d'un graphique élongation/temps sur 1 seconde"
      curve =[] 	     # liste des coordonnées
      pas = (self.larg-25)/1000.      # l'échelle X correspond à 1 seconde
      for t in range(0,1001,5):       # que l'on divise en 1000 ms.
          e = ampl*sin(2*pi*freq*t/1000 + phase)
          x = 10 + t*pas
          y = self.haut/2 - e*self.haut/25
          curve.append((x,y))
      n = self.create_line(curve, fill=coul, smooth=1)
      return n		     # n = numéro d'ordre du tracé
 
#### Code pour tester la classe : ####
 
if __name__ == '__main__':
  root = Tk()
  gra = OscilloGraphe(root, 450, 325)
  gra.pack()
  gra.configure(bg ='ivory', bd =2, relief=SUNKEN)
  gra.traceCourbe(2.0, 1.2, 10, 'purple')
  root.mainloop()

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
from tkinter import *
from math import pi
 
class ChoixVibra(Frame):
    """Curseurs pour choisir fréquence, phase,amplitude d'une vibration"""
    def __init__(self,boss=None, coul='red'):
        Frame.__init__(self)        #constructeur de la classe parente
        #initialisation de quelques attributs d'instance :
        self.freq, self.phase,self.ampl,self.coul=0,0,0,coul
        #variable d'etat de la case à cocher :
        self.chk= IntVar()
        Checkbutton(self,text='Afficher',variable=self.chk,fg=self.coul,
                    command=self.setCurve).pack(side=LEFT)
        #definition des 3 widgets curseurs :
        Scale(self, length=150, orient=HORIZONTAL, sliderlength =25,
              label ='Fréquence (Hz) :', from_=1., to=9., tickinterval =2,
              resolution =0.25,showvalue =0,
              command = self.setFrequency).pack(side=LEFT)
        Scale(self, length=150, orient=HORIZONTAL, sliderlength =15,
              label ='Phase (degrés) :', from_=-180, to=180, tickinterval =90,
              showvalue =0, command = self.setPhase).pack(side=LEFT)
        Scale(self, length=150, orient=HORIZONTAL, sliderlength =25,
              label ='Amplitude :', from_=1, to=9, tickinterval =2,
              showvalue =0, command = self.setAmplitude).pack(side=LEFT)
 
    def setCurve(self):
        self.event_generate('<Control-Z>')
 
    def setFrequency(self,f):
        self.freq=float(f)
        self.event_generate('<Control-Z>')
 
    def setPhase(self,p):
        pp=float(p)
        self.phase=pp*2*pi/360  #conversion degrés  > radians
        self.event_generate('<Control-Z>')
 
    def setAmplitude(self,a):
        self.ampl=float(a)
        self.event_generate('<Control-Z>')
 
    def valeurs(self):
        tup=self.freq,self.phase,self.ampl
 
        return tup
 
 
# #### Code pour tester la classe : ###
 
if __name__ == '__main__':
    def afficherTout(event=None):
        lab.configure(text = '{0} - {1} - {2} - {3}'.\
                      format(fra.chk.get(), fra.freq, fra.phase, fra.ampl))
    root = Tk()
    fra = ChoixVibra(root,'navy')
    fra.pack(side =TOP)
    fra.valeurs()
    lab = Label(root, text ='test')
    lab.pack()
    root.bind('<Control-Z>', afficherTout)
    root.mainloop()

EDIT : modification de la classe ShowVibra

Bonjour

J'ai exécuté les deux codes et je n'ai eu aucun ennui. Donc faudrait que tu dises à quelle occasion ça arrive.

Sinon quand tu as un message d'erreur, Pytjon te donne d'abord la ligne ayant provoqué l'erreur puis ensuite tout l'empilement des lignes ayant amené à cette ligne là (telle fonction appelle telle fonction qui appelle telle fonction). Si les programmeurs de Python se sont cassés le luc à faire remonter ces infos, c'est peut-être parce qu'elles sont utiles tu ne crois pas ???

Pour info le message te dis que quand tu écris un truc de type [x, y] * n, le "n" doit-être impérativement un int. Ca peut arriver par exemple dans des cas comme ça: print "%f" % 2*3.5 où il croit que tu veux multiplier la chaine "2" par 3.5 alors que toi tu veux l'opération 2*3.5 => print "%f" % (2*3.5)...

C'est quand j’exécute ShowVibra (1e code). J'ai le message :
File "C:\Python34\lib\tkinter\__init__.py", line 1482, in __call__
return self.func(*args)
File "C:/Python34/Scripts/test_erreur_ch13.py", line 41, in montreCourbes
self.trace[i] = self.gra.traceCourbe(coul,freq,phase,ampl)
File "C:\Python34\lib\oscillo.py", line 41, in traceCourbe
e = ampl*sin(2*pi*freq*t/1000 + phase)
TypeError: can't multiply sequence by non-int of type 'float'

Je ne comprends pas le 1e message d'erreur.

Citation:

Envoyé par loncle

File "C:\Python34\lib\oscillo.py", line 41, in traceCourbe
e = ampl*sin(2*pi*freq*t/1000 + phase)

Je ne comprends pas le 1e message d'erreur.

Le tout premier message d'erreur vient de la librairie tk. A la limite tu t'en moques puisque cela vient en final de ta ligne. Il faut que tu affiches chacune de ces variables "pi", "freq" et "t" ainsi que leur type => print t, type(t). Surtout que ces variables viennent de l'extèrieur (passées en paramètre). L'une d'entre elles ne doit pas être du bon type. Ca peut arriver à cause d'une simple virgule
Exemple:
Code:

1 2 3 4 5 6 7 def carre(x): return x*x a=2 carre(a) # ok, affichera 4 a=3, # La virgule fait que "a" contient non plus un int mais un tuple carre(a) # => Erreur
Donc te faut checker attentivement pour chacune de ces variables la façon dont tu les remplis...