[RESOLU] cadrillage en python

calixtus06 · 17-02-2019 23:26:45

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)

David5647 · 18-02-2019 00:49:04

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)

calixtus06 · 18-02-2019 07:44:05

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)

David5647 · 18-02-2019 08:50:32

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!

calixtus06 · 18-02-2019 18:30:43

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 ?

David5647 · 18-02-2019 20:03:25

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)

calixtus06 · 18-02-2019 23:07:48

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)

David5647 · 18-02-2019 23:34:17

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

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

calixtus06 · 19-02-2019 12:01:27

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)

David5647 · 19-02-2019 13:03:50

#!/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)

calixtus06 · 21-02-2019 21:16:00

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

David5647 · 21-02-2019 21:39:32

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§

calixtus06 · 23-02-2019 15:01:15

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()

David5647 · 23-02-2019 16:14:26

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)

calixtus06 · 23-02-2019 16:37:54

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)

David5647 · 23-02-2019 17:04:17

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)

calixtus06 · 23-02-2019 19:17:33

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.

David5647 · 23-02-2019 21:40:52

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??? 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)

calixtus06 · 24-02-2019 10:28:02

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)

David5647 · 24-02-2019 12:17:08

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.

calixtus06 · 25-02-2019 10:20:42

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)

David5647 · 25-02-2019 11:02:38

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

David5647 a écrit :

https://www.courspython.com/modules.html

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é.
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)

calixtus06 · 25-02-2019 12:01:13

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)

David5647 · 25-02-2019 12:18:18

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)

calixtus06 · 25-02-2019 14:21:13

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()

Debian-facile

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

[RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

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

Re : [RESOLU] cadrillage en python

Pied de page des forums