logo Debian Debian Debian-France Debian-Facile Debian-fr.org Forum-Debian.fr Debian ? Communautés logo inclusivité

Debian-facile

Bienvenue sur Debian-Facile, site d'aide pour les nouveaux utilisateurs de Debian.

Vous n'êtes pas identifié(e).

#1 17-02-2019 23:26:45

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

[RESOLU] cadrillage en python

Hello je sais , ça doit être super simple . J'ai essayé des tas d'autres changements. Qu'importe. Mon petit projet est de dessiner des diagramme d'accord de guitare.

J'en suis là , alors si quelqu'un peut me mettre sur la piste:


#!/usr/bin/env python
# -*- coding: utf-8 -*-

from tkinter import *
tk=Tk()
canvas=Canvas(tk, width=1000, height=1000)
canvas.pack()

def diagramme_accord(x,y, x1,y1):
  canvas.create_rectangle(x,y, x1,y1)
  for i in range (1,5):
    canvas.create_line (x, y, x1,y)
    canvas.create_line(x,y,x,y1)
    x=x+60
    y=y+60
   
   
print (diagramme_accord(10,10, 250,250))

tk.mainloop()
 



Merci d'avance

Dernière modification par calixtus06 (11-09-2019 09:47:15)


Il n'y a pas de mauvaises questions...

Hors ligne

#2 18-02-2019 00:49:04

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

J'ai bricolé ça, c'est ce genre de trucs que tu veux?
(je mets mes interfaces dans des classes, par habitude et par simplicité)



#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tkinter as tk

class Guitare(tk.Frame):
   
    def __init__(self, root):

        tk.Frame.__init__(self, root)
        self.root = root
       
        self.canvas1 = tk.Canvas(root, width=1000, height=1000)
        self.canvas1.pack()
       
       
        cordes_espacement = 20
        cordes_offset = 10
        cordes_nombre = 6
       
        frets_nombre = 15
        frets_taille = 120
        frets_espacement = 60
       
        self.note_x_offset = cordes_offset
        self.note_x_espacement = cordes_espacement
        self.note_y_espacement = frets_espacement
       
               
        cordes_taille = (frets_nombre + 1) * frets_espacement
        for n_corde in range(cordes_nombre):
            self.canvas1.create_line(n_corde * cordes_espacement + cordes_offset,
                                     0,
                                     n_corde * cordes_espacement + cordes_offset,
                                     cordes_taille)
   
   
        for n_fret in range(frets_nombre) :
            self.canvas1.create_line(0,
                                     frets_espacement * n_fret,
                                     frets_taille,
                                     frets_espacement * n_fret,
                                     fill="red")

        LAm = [0, 0, 2, 2, 1, 0]
        self.show_accord(LAm)
       
    def show_accord(self, accord) :
       
        for i, note in enumerate(accord) :
            x = i * self.note_x_espacement + self.note_x_offset/2
            y = note * self.note_y_espacement + self.note_y_espacement/2
            self.canvas1.create_oval(x, y, x+15, y+15, fill="blue")
           
           
root = tk.Tk()
guitare = Guitare(root).pack()
root.mainloop()            

 

Dernière modification par David5647 (18-02-2019 00:53:56)

Hors ligne

#3 18-02-2019 07:44:05

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Salut et un grand merci !

En fait je cherche à faire ça mais en plusieurs exemplaires:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from tkinter import *
tk=Tk()
canvas=Canvas(tk, width=1000, height=1000)
canvas.pack()

def diagramme_accord(x,y, x1,y1):
  canvas.create_rectangle(x,y, x1,y1)
  canvas.create_line(x,y+10,x1,y+10)
  for i in range (0,5):
    canvas.create_line (x, y, x1,y)
    canvas.create_line(x,y,x,y1)
    canvas.create_line(x,y+80,x1,y+80)
    canvas.create_line(x,y+160,x1,y+160)
    canvas.create_line(x,y+230,x1,y+230)
    x=x+46
    y=y
   
   
print (diagramme_accord(10,10, 240,240))

tk.mainloop()



Avec des points comme tu as fait et le même manche que tu as fait aussi mais à l'horizontale.

Il y a ce fichier json qui m'a l'air intéressant :

https://gschoppe.com/js/json-chords/

Dernière modification par calixtus06 (18-02-2019 07:47:42)


Il n'y a pas de mauvaises questions...

Hors ligne

#4 18-02-2019 08:50:32

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

Pour mettre à l'horizontal : t'as juste à inverser les axes x et y
Pour en faire plusieurs : il te suffit de créer plusieurs instances de la classe guitare, dans plusieurs frames par exemples

Je te laisse regarder le code et me dire si tu as besoin d'explications

Pour ce qui est du fichier, ça doit être possible de le récuperer, je regarderai ça!

Hors ligne

#5 18-02-2019 18:30:43

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Salut David !
Ton programme est un peu costaud pour moi. Dès qu'on attaque les classes, je me mélange les pinceaux. Qu'appelles tu offset dans ton programme ?

Il n'y a pas de mauvaises questions...

Hors ligne

#6 18-02-2019 20:03:25

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

le offset, c'est juste pour que les cordes ne soient pas en bord de frettre, c'est un petit décalage, c'est tout.
un superbe dessin : https://framapic.org/gallery#c81xbVfIiQ … KvenQv.png

Les classes, c'est la vie! Je te conseille de t'y pencher, ça change tout est c'est pas si compliqué.
Le mieux c'est que tu ailles voir!

Pour faire succin et mal :
Une classe, c'est un ensemble de fonctions et d'attributs :
une fonction tu vois ce que c'est, un attribut, c'est une constante, une liste.
à l'exterieur de la classe on notera :
       ma_classe.attribut ou ma_classe.fonction()
à l'interieur de la classe, elle peut se faire référence à elle même avec le mot "self" :
       self.attribut ou self.fonction()

Lorsque l'on fait appel la première fois à la classe (x = MaClasse())
on exécute le code contenu dans __init__, c'est la seule fois ou il sera executé.

Ici, on aurait très bien pu se passer de classe, j'ai juste l'habitude de faire comme ça et si tu compliques un peu le tout, elles deviendrons nécessaires. Ca ne change pas grand chose au code mis à part les "self" et un peu de formalisme inhérent aux classes. Ca me facilite juste un peu la vie pour la fonction show_accord, où je n'ai pas besoin de passer les paramètres dans la fonction, mais fait appel directement à self.attribut.
Voilà!

Le code, un peu commenté :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tkinter as tk

# là pas grand chose à comprendre, ça s'écrit comme ça, c'est tout =)
class Guitare(tk.Frame):
# pareil, déclaration d'une classe
    def __init__(self, root):

        # là, on crée la fenetre
        tk.Frame.__init__(self, root)
        self.root = root

        # on crée l'espace de dessin dans la fenetre
        self.canvas1 = tk.Canvas(root, width=1000, height=1000)
        self.canvas1.pack()

        # définitions de constances géométriques (cf mon superbe dessin)
        cordes_espacement = 20 # espacement entre les cordes
        cordes_offset = 10 # décalage à l'origine
        cordes_nombre = 6 # nombre de cordes

        frets_nombre = 15 # nombre de frettes
        frets_taille = 120 # ~= largeur du manche
        frets_espacement = 60 # espace entre les frettes

        # Paramètres géométiques pour les notes en fonction des constantes
        # précédentes (histoire que les notes tombent sur les cordes et entre
        # les frettes)
        self.note_x_offset = cordes_offset
        self.note_x_espacement = cordes_espacement
        self.note_y_espacement = frets_espacement

        # calcul de la taille des cordes (un peu plus loin que les frettes),
        # explicite non?
        cordes_taille = (frets_nombre + 1) * frets_espacement
        # pour chaque corde (de 0 à 5) : création d'une ligne
        # n_corde = numéro de la corde
        # en x :
        # elles sont toutes décallés de offset
        # et on va en pas de taille espacement
        # en y :
        # de 0 à cordes_taille
        # (on a découpé la ligne pour plus de lisibilité)
        for n_corde in range(cordes_nombre):
            self.canvas1.create_line(n_corde * cordes_espacement + cordes_offset,
                                     0,
                                     n_corde * cordes_espacement + cordes_offset,
                                     cordes_taille)

        # pareil sans le offset (mais on peut en mettre un...)
        for n_fret in range(frets_nombre) :
            self.canvas1.create_line(0,
                                     frets_espacement * n_fret,
                                     frets_taille,
                                     frets_espacement * n_fret,
                                     fill="red")
        # definition d'un accord sous forme d'une liste avec la position des
        # doigts pour chaque corde en partant de la plus grave (comme d'hab
        # quoi!)
        LAm = [0, 0, 2, 2, 1, 0]
        # et on lance l'affichage des notes sur le manche
        self.show_accord(LAm)

    def show_accord(self, accord) :

        # petite subtilité : enumerate : en même temps que la commande liste le
        # contenu de mon accord, elle incrémente i (qui me servira de numero de
        # corde)
        for i, note in enumerate(accord) :
            # pour la note numéro i, je me place sur la corde numéro i
            x = i * self.note_x_espacement + self.note_x_offset
            # pour la note numéro i en frette "note", je me place sur la frette
            # + la moitié d'une frette pour etre au milieu.
            y = note * self.note_y_espacement + self.note_y_espacement/2
            # je crée un rond pour symboliser la note.
            self.canvas1.create_oval(x, y, x+15, y+15, fill="blue")

# boucle
root = tk.Tk()
guitare = Guitare(root).pack()
root.mainloop()

 

Dernière modification par David5647 (18-02-2019 20:11:17)

Hors ligne

#7 18-02-2019 23:07:48

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

ok, pour ce soir j'en suis là ...

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from tkinter import *


class Accord:
  def __init__ (self,canvas,x,y,x1,y1):
    self.canvas=canvas
    self.x=x
    self.y=y
    self.x1=x1
    self.y1=y1
    canvas.create_rectangle(x,y, x1,y1)
    canvas.create_line(x,y+10,x1,y+10)
    for i in range (0,5):
      canvas.create_line (x, y, x1,y)
      canvas.create_line(x,y,x,y1)
      canvas.create_line(x,y+80,x1,y+80)
      canvas.create_line(x,y+160,x1,y+160)
      canvas.create_line(x,y+230,x1,y+230)
      x=x+46
      y=y
tk=Tk()
canvas=Canvas(tk, width=1000, height=1000)
canvas.pack()

diagramme=Accord(canvas,10,10,240,240)
print(diagramme)

tk.mainloop()



Si j'ai bien compris, il me reste à créer une classe note( sous forme de cercle bleu), d 'appeler  le fichier json et de mettre en lien avec les note...Un gros travail en perspective !

Dernière modification par calixtus06 (18-02-2019 23:10:47)


Il n'y a pas de mauvaises questions...

Hors ligne

#8 18-02-2019 23:34:17

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

Salut,

Tu devrais faire deux boucles pour créer tes lignes,
une pour les lignes verticales, et une pour les horizontales

Dans ta boucle seule la ligne :

canvas.create_line(x,y,x,y1)


est utile
les autres sont retracées les unes sur les autres et n'y ont pas leur place.

plutôt qu'une nouvelle classe, créé une fonction que tu appelleras à chaque fois que tu veux tracer un nouvel accord

ps : juste une remarque de bonne pratique :
éviter les

import *


ça prête à confusion, notamment ta variable "canvas" qui se recoupe avec tkinter

pps : j'ai pu exploiter la liste des accords et réussi à les afficher avec des listes déroulantes,
j'te laisse réfléchir. Je peux te les envoyer au besoin big_smile

Dernière modification par David5647 (18-02-2019 23:43:42)

Hors ligne

#9 19-02-2019 12:01:27

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Hello, j'y suis depuis ce matin , c'est rude :

#!/usr/bin/env python
# -*- coding: utf-8 -*-


from tkinter import *

class Manche:
  def __init__(self, canvas, nombre_de_case, longueur_du_manche, largeur_du_manche, espace_entre_frette):
    self.diagramme=canvas
    self.case = nombre_de_case
    self.longueur= longueur_du_manche
    self.largeur=largeur_du_manche
    self.frette=espace_entre_frette
   
   
tk=Tk()
diagramme=Canvas(tk, bg="yellow", height=300, width=180)
diagramme.pack()

#quelle différence entre diagramme et chord, du coup ? Quels nombre sont pris en compte ??

chord=Manche(diagramme, 4,200,150,60)
print (chord)

#dessiner les frettes
x=0
while (x<=chord.case):
  chord.case=4
  diagramme.create_line(x, chord.frette*x+2,180,chord.frette*x+2, fill="black")
  x=x+1
 
 
#dessin des cordes: je ne parviens pas à dessiner la corde aigüe
x=2
while (x<=chord.largeur):
  chord.largeur=150
  diagramme.create_line(x, 0, x, 300, fill= "black")
  x=x+36
 
 
 
tk.mainloop()
 



Je ne parviens pas à dessiner la dernière ligne verticale: la corde aigüe...

Dernière modification par calixtus06 (19-02-2019 12:02:37)


Il n'y a pas de mauvaises questions...

Hors ligne

#10 19-02-2019 13:03:50

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tkinter as tk
# Cette méthode d'import est à preferer, ça évite de se mélanger dans les fonctions et
# évite l'interaction entre les différents modules

class Manche:
  def __init__(self, canvas, nombre_de_case, longueur_du_manche, largeur_du_manche, espace_entre_frette):
    self.diagramme=canvas
    self.case = nombre_de_case
    self.longueur= longueur_du_manche
    self.largeur=largeur_du_manche
    self.frette=espace_entre_frette

root=tk.Tk()
diagramme=tk.Canvas(root, bg="yellow", height=400, width=280)
diagramme.pack()

### quelle différence entre diagramme et chord, du coup ? Quels nombre sont pris en compte ??
# pour créer la classe :
#     chord = Manche(diagramme, 4, 200, 150, 60)
# puis pour appeler ses attributs :
#     chord.diagramme.create_line(...)
# En bref : diagramme n'est pas le même objet que chord.diagramme

chord=Manche(diagramme, 4,200,150,60) # création de l'objet chord de classe Manche, excecution de __init__
print (chord) # il te dit : "je suis un objet de type Manche"

##dessiner les frettes
x=0
while (x<=chord.case): # pourquoi pas une boucle for? x prendra les valeurs : 0,1,2,3,4
  chord.case=4 # tu peux le définir avant la boucle, ça ne sert à rien de le recalculer
  diagramme.create_line(x,
                        chord.frette*x+2,
                        180,
                        chord.frette*x+2,
                        fill="black")
  x=x+1
 
 
###dessin des cordes: je ne parviens pas à dessiner la corde aigüe
x=2
while (x<=chord.largeur): # x prendra les valeurs : 2, 38, 74, 110, 146, soit 5 valeurs seulement!
  chord.largeur=150 # pareil à placer à l'exterieur de la boucle et à augmenter si tu veux 6 cordes
  diagramme.create_line(x,
                        0,
                        x,
                        300,
                        fill= "black")
  x=x+36
 
 
 
tk.mainloop()



Ta classe ne t'est pas utile, soit tu places tes boucles dans une fonction de la classe Manche, soit tu ne fais pas de classe.
Faire une classe permettra de créer de multiples diagrammes, par ex:

chord_1 = Macnhe(...)
chord_2 = Manche(...)
chord_3 = Manche(...)

Dernière modification par David5647 (19-02-2019 13:06:28)

Hors ligne

#11 21-02-2019 21:16:00

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Hello je suis à l'hosto jusqu'à samedi matin mais prêt à en découdre de ce petit programme !

Il n'y a pas de mauvaises questions...

Hors ligne

#12 21-02-2019 21:39:32

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

Salut!

De mon coté, j'ai avancé sur mon programme, j'ai trouvé l'idée sympa et avec la base de donnée déjà faite...
Je suis parvenu à un truc pas trop mal! On verra tout ça!

Bon courage§

Hors ligne

#13 23-02-2019 15:01:15

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Hello ! l'ambulance m'a ramené à midi . Pour le moment j'en suis là :
J'ai écrit le programme sans classe pour le moment et ajuster l'incrémentation:

#!/usr/bin/env python
# -*- coding: utf-8 -*-


from tkinter import *

case=5  
corde=6          
longueur=300
largeur=180
espace_entre_frette=longueur/case
espace_entre_corde=largeur/corde
fen=Tk()
canvas=Canvas(fen, height=longueur, width=largeur, bg = "yellow")
canvas.pack()

x=0
while (x<=case):
  canvas.create_line(0,espace_entre_frette*x+2,largeur,espace_entre_frette*x+2, fill="black")
  x=x+1
 
y=0
while(y<=corde):
  canvas.create_line(espace_entre_corde*y+1,0,espace_entre_corde*y+1,longueur, fill="red")
  y=y+1.19
fen.mainloop()


Il n'y a pas de mauvaises questions...

Hors ligne

#14 23-02-2019 16:14:26

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

Bon, ça prend forme ! :P

2 remarques :
la grosse :
Outre le fait que faire une itération "y=y+1.19" est vraiment peu conventionnelle, ça met le bazar dans ton programme.
la largeur de ton canvas (180 = 6*30), n'est plus égale à l'espace que prennent les cordes (6*1.19*30)
Si tu veux mettre un facteur pour agrandir facilement le tout, il faut l'insérer à la déclaration des variables !

la petite :
je trouve qu' une boucle for serait plus explicite :

for x in range(case) :
    canvas...


que la while :

x=0
while x <= case :
    canvas...
    x+=1


On y voit plus directement les valeurs que peuvent prendre x

Dernière modification par David5647 (23-02-2019 16:15:38)

Hors ligne

#15 23-02-2019 16:37:54

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Entre temps j'ai pondu ça depuis le premier programme car au fond la place de chaque  diagramme est déterminée par ses coordonnées:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from tkinter import *


class Accord:
  def __init__ (self,canvas,x,y,x1,y1):
    self.canvas=canvas
    self.x=x
    self.y=y
    self.x1=x1
    self.y1=y1
    canvas.create_rectangle(x,y, x1,y1)
    canvas.create_line(x,y+10,x1,y+10) #création du sillet
    for i in range (0,5):
      canvas.create_line (x, y, x1,y)
      canvas.create_line(x,y,x,y1)
      canvas.create_line(x,y+80,x1,y+80)
      canvas.create_line(x,y+160,x1,y+160)
      canvas.create_line(x,y+230,x1,y+230)
      x=x+46
      y=y
tk=Tk()
canvas=Canvas(tk, width=1000, height=1000)
canvas.pack()

             #première ligne

diagramme1=Accord(canvas,  10, 10, 240,240)
diagramme2=Accord(canvas, 260, 10, 490,240)
diagramme3=Accord(canvas, 510, 10, 740,240)
diagramme4=Accord (canvas, 760, 10,990,240)

print(diagramme2)
print(diagramme1)
print(diagramme3)



Cela me paraît plus simple que d'ajuster la corde aigüe, non ?

ps: va falloir que j'ajuste aussi le nombre de case...

Dernière modification par calixtus06 (23-02-2019 16:40:30)


Il n'y a pas de mauvaises questions...

Hors ligne

#16 23-02-2019 17:04:17

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

Pourquoi avoir supprimé l'une des deux boucles?
Ton code précédent était beaucoup mieux
tu remets des erreurs que l'on avait corrigées

qu'entends tu par :

Cela me paraît plus simple que d'ajuster la corde aigüe, non ?

Dernière modification par David5647 (23-02-2019 17:05:18)

Hors ligne

#17 23-02-2019 19:17:33

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Ah !?  En fait je ne parvenais pas à mettre le code avec les boucles while sous forme de classe.

Concernant la corde aigüe, le fait de programmer une boucle pour dessiner les cordes m'obligeait à ajuster l'incrémentation .
En programmant le rectangle je n'ai plus ce problème.

Il n'y a pas de mauvaises questions...

Hors ligne

#18 23-02-2019 21:40:52

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

Concernant la corde aigüe, le fait de programmer une boucle pour dessiner les cordes m'obligeait à ajuster l'incrémentation .


c-à-d ?

for i in range(6):
...     print(i)
...
0
1
2
3
4
5
 

ça fait bien 6 cordes, je ne comprends pas le problème...

EDIT :
ok, je viens de comprendre la question :
tu as 6 cordes :

|   |   |   |   |   |


donc :

| 1 | 2 | 3 | 4 | 5 |


5 intervalles, par le fait:

espace_entre_frette=longueur/(case-1)
espace_entre_corde=largeur/(corde-1)


Je pense que là tu n'aura plus rien à ajuster


D'autre part, ton code en message #15 est vraiment dur à lire, je sais pas si tu t'y retrouve, mais moi je me fais des noeuds au cerveau.

for i in range (0,5):
      canvas.create_line (x, y, x1,y)
      canvas.create_line(x,y,x,y1)
      canvas.create_line(x,y+80,x1,y+80)
      canvas.create_line(x,y+160,x1,y+160)
      canvas.create_line(x,y+230,x1,y+230)
      x=x+46
      y=y


Tu dessines à la fois des lignes verticales et horizontales avec un seul incrément. tu utilise un indice i mais tu incrémente x en même temps et par pas de 46, va te représenter rapidement les valeurs...
x varie mais pas x1, tu incrémente manuellement y, tu écrases la valeur de y par y à chaque itérations. Je devrais avoir 5 itérations * 5 lignes  et on trace en réalité 10 segments au lieu de 25.

alors que si on prend le msg #13

x=0
while (x<=case): # case = 5
  canvas.create_line(0,espace_entre_frette*x+2,largeur,espace_entre_frette*x+2, fill="black")
  x=x+1


Ok, x va de 0 à 5 par pas de 1, je trace les lignes horizontales puisque y1=y2, je vais verticalement de espace_entre_frette en espace_entre_frette et toutes mes lignes sont décalées de 2.
C'est pas plus clair quand même??? lol Et avec un  for in range, je rassemble x=0 x<=case et x=x+1 sur la même ligne :

for i in range(case+1) : # +1 pour être équivalent à while <= et pas à while <
    y = espace_entre_frette * i + 2
    canvas.create_line(0, y, largeur, y, fill="black") # pas x pour les ordonnées, je t'en supplie...

Dernière modification par David5647 (23-02-2019 23:38:47)

Hors ligne

#19 24-02-2019 10:28:02

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Salut David , j'essaie de comprendre ce que tu me dis:

1) Du coup j'ai changé la façon d'importer le module et j'ai remplacé

from tkinter import *


par

import tkinter as tk


J'avoue que ce n'est pas clair pour un débutant comme moi mais bon..

2) Pour différencier le nom des cordes et des cases, j'ai fait deux listes mais peut être que je me complique la vie :

case=[1,2,3,4,5]
corde=[1,2,3,4,5,6]        
longueur=300
largeur=180
espace_entre_frette=longueur/len(case)-1
espace_entre_corde=largeur/len(corde)-1



3) le diagramme produisait 5 cordes  avant que je change la manière d'importer le module:

#!/usr/bin/env python
# -*- coding: utf-8 -*-


from tkinter import *


case=["1ère case", "2ème case", "3ème case", "4ème case", "5ème case"]
corde=["1ère corde","2ème corde","3ème corde","4ème corde","5ème corde","6ème corde"]        
longueur=300
largeur=180
espace_entre_frette=longueur/len(case)
espace_entre_corde=largeur/(len(corde)-1)
tk = Tk()
canvas=Canvas(tk, height=longueur, width=largeur, bg = "yellow")
canvas.pack()

x=0
for value in corde:
  canvas.create_line(0,espace_entre_frette*x+2,largeur,espace_entre_frette*x+2, fill="black")
  x=x+1
 
y=0
for value in case:
  canvas.create_line(espace_entre_corde*y+1,0,espace_entre_corde*y+1,longueur, fill="red")
  y=y+1
tk.mainloop()  



4) désormais j'ai ce message d'erreur concernant Canvas en changeant l'invocation du module:

import tkinter as tk


case=[1,2,3,4,5]
corde=[1,2,3,4,5,6]        
longueur=300
largeur=180
espace_entre_frette=longueur/len(case)-1
espace_entre_corde=largeur/len(corde)-1

canvas=Canvas(tk, height=longueur, width=largeur, bg = "yellow")
canvas.pack()

x=0
for value in corde:
  canvas.create_line(0,espace_entre_frette*x+2,largeur,espace_entre_frette*x+2, fill="black")
  x=x+1
 
y=0
for value in case:
  canvas.create_line(espace_entre_corde*y+1,0,espace_entre_corde*y+1,longueur, fill="red")
  y=y+1
tk.mainloop()    

Dernière modification par calixtus06 (24-02-2019 10:37:55)


Il n'y a pas de mauvaises questions...

Hors ligne

#20 24-02-2019 12:17:08

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

1) Du coup j'ai changé la façon d'importer le module et j'ai remplacé
4) désormais j'ai ce message d'erreur concernant Canvas en changeant l'invocation du module:

C'est parceque Canvas est un module de tkinter,
c'est justement le problème de "import *", on ne voit pas d'ou viennent les modules.
Quand tu fais ça tu importes tout les modules de tkinter, saurai tu les nommer?
Et si tkinter contient un module appellé "case"? Utilises tu ta variable "case" ou le module lorsque tu écris "case"?
=> tk.Canvas, tk.Tk()
https://www.courspython.com/modules.html

2) Pour différencier le nom des cordes et des cases, j'ai fait deux listes mais peut être que je me complique la vie :

Non, tu te simplifie la vie, une corde n'est pas une case, donc deux objets différents, on ne mélange pas les pommes et les oranges.


3) le diagramme produisait 5 cordes  avant que je change la manière d'importer le module:

Soit :

x=0
while x <= len(corde):
   ...
   x += 1

soit :

for x in corde :
   ...

ça ne sert à rien de mixer les deux.
et tu as inversé les cordes et les frettes, tu as 6 frettes, tu as 5 cordes, c'est pour ça.

Hors ligne

#21 25-02-2019 10:20:42

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Salut David, pour moi tkinter est un module et Canvas une méthode. Je me trompe ?
*Du coup qu'est ce qui cloche dans mon programme ?

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# le but est ici de mettre le programme GRILLE sous forme de classe:


import tkinter as tk

case=[1,2,3,4,5]
corde= [1,2,3,4,5,6]
nb_case = len(case)
nb_corde=len(corde)      
longueur=300
largeur=180
espace_entre_frette=longueur/len(case)
espace_entre_corde=largeur/len(corde)
fen=tk()
canvas=Canvas(fen, height=longueur, width=largeur, bg = "yellow")
canvas.pack()

x=0
for value in corde:
  canvas.create_line(0,espace_entre_frette*x+2,largeur,espace_entre_frette*x+2, fill="black")
  x=x+1
 
y=0
for value in case:
  canvas.create_line(espace_entre_corde*y+1,0,espace_entre_corde*y+1,longueur, fill="red")
  y=y+1.19
fen.mainloop()  



ligne 17: un objet tk() n'est pas invocable (??)

Dernière modification par calixtus06 (25-02-2019 10:45:33)


Il n'y a pas de mauvaises questions...

Hors ligne

#22 25-02-2019 11:02:38

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

tk.Canvas, tk.Tk()
Tu es allé voir comment on importe un module, une blibliothèque?



Je dis "module" comme ça, pour dire "appartient à, si tu veux faire de la sémantique... En python tout est objet comme ça c'est réglé. big_smile
Je dis que : Canvas et Tk appartienent à tkinter


import tkinter
tkinter.Canvas(...)
############
import tkinter as tk
tk.Canvas(...)
############
from tkinter import Canvas as je_l_appelle_comme_je_veux
je_l_appelle_comme_je_veux(...)

Tout ça c'est pareil

Sinon, les cordes et les cases sont toujours inversées dans les boucles, les cordes sont elles espacées de espace_entre_frette?
Regarde mes messages précédent, tout à déjà été dit

Dernière modification par David5647 (25-02-2019 11:11:28)

Hors ligne

#23 25-02-2019 12:01:13

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

Du coup , pour les modules Tk() et Canvas(), je présente les variables comme suit:

je ne pige pas ce que tu dis dans les messages précédents: selon toi j'inverse les abscisses et les ordonnées ?

#!/usr/bin/env python
# -*- coding: utf-8 -*-




import tkinter as tk

case=[1,2,3,4,5]
corde= [1,2,3,4,5,6]
nb_case = len(case)
nb_corde=len(corde)      
longueur=300
largeur=180
espace_entre_frette=longueur/len(case)
espace_entre_corde=largeur/len(corde)

fen= tk.Frame()

canvas=tk.Canvas(fen, height=longueur, width=largeur, bg = "yellow")
canvas.pack()

x=0
for value in corde:
  canvas.create_line(0,espace_entre_frette*x+2,largeur,espace_entre_frette*x+2, fill="black")
  x=x+1
 
y=0
for value in case:
  canvas.create_line(espace_entre_corde*y+1,0,espace_entre_corde*y+1,longueur, fill="red")
  y=y+1.19
fen.mainloop()

Dernière modification par calixtus06 (25-02-2019 12:03:42)


Il n'y a pas de mauvaises questions...

Hors ligne

#24 25-02-2019 12:18:18

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Re : [RESOLU] cadrillage en python

Oui, c'est ça,
sauf pour : fen= tk.Tk(), pourquoi avoir changé ça?

Bah, si tu fais une boucle sur les cordes :

for value in cordes :



Tes cordes doivent être espacées de espace_entre_corde, pas de espace_entre_frette, non?
Et tu as l'air de vouloir les placer verticalement, puisqu'elles sont de longueur longueur comme la hauteur de ton canvas
Mais dans ta boucle, elles sont horizontales

Dernière modification par David5647 (25-02-2019 12:19:48)

Hors ligne

#25 25-02-2019 14:21:13

calixtus06
Membre
Distrib. : Librazik 4
Noyau : 5.10.0-14-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : [RESOLU] cadrillage en python

re

Je me mélange les pinceaux avec ces variables "espace_entre_frette" et "espace_entre _corde", du coup je suis revenu à x et y .

Je veux placer les cordes dans le sens vertical et les frettes dans le sens horizontal
Pour autant je n'obtiens qu'une frette et la 6ème corde ( la grosse corde)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tkinter as tk

case=["1ère case", "2ème case", "3ème case", "4ème case", "5ème case"]
corde=["1ère corde","2ème corde","3ème corde","4ème corde","5ème corde","6ème corde"]    
nb_case = len(case)
nb_corde=len(corde)      
longueur=400
largeur=250



fen= tk.Tk()

canvas=tk.Canvas(fen, height=longueur, width=largeur, bg = "yellow")
canvas.pack()


# x est à zéro sur son l'axe des abscisses, l'axe des abscisse est la largeur du manche
#il y a 6 itérations dans la liste corde
x=0
for value in corde:
  canvas.create_line(0,2,largeur,2, fill="black")
  x=x+1
 
 
#y est à zéro sur l'axe des ordonnées, l'axe des ordonnées est la longueur du manche
#il y a 5 itérations dans la liste case puisque je souhaite que 5 cases apparaissent
y=0
for value in case:
  canvas.create_line(2,0,2, longueur, fill="red")
  y=y+1
 
fen.mainloop()    


Il n'y a pas de mauvaises questions...

Hors ligne

Pied de page des forums