CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 02 08 12:10:00

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

ILLUSTRATION DE SINUS ET DE COSINUS

Information sur la source

Note :

8,00 / 10

Catégorie :Application complète Classé sous :Tkinter, pack, grid, gui, graphiques Niveau :Débutant Date de création :17/01/2010 Vu / téléchargé :2 852 / 141

Auteur : calogerogigante

Ecrire un message privé

Site perso

Commentaire sur cette source (9)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

Un programme simple qui permet d'illustrer dynamiquement les fonctions sinus et cosinus. Ecrit pour Python 2.6, l'interface graphique fait appel à Tkinter. Pas de difficulté majeure si ce n'est la structuration du code en classe. Une particularité : c'est l'utilisation d'une variable de classe self.u, qui contient une valeur entière en pixels, sur laquelle se basent toutes les dimensions proportionnelles de l'application. En d'autres termes, tapez 12 dans cette valeur pour avoir une petite taille de la fenêtre (et les canvas qu'elle contient), tapez 24, et l'interface doublera de taille...

Source

#!/usr/local/bin/python
# -*- coding:utf-8 -*-
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# Illustration du SINUS et du COSINUS
# -----------------------------------------------------------------------------
# Auteur : Calogero GIGANTE
# Version python : 2.6.4. avec Tkinter
# Objectif : illustrer dynamiquement le sin et le cos d'un angle en degrés.
# Date : 17 janvier 2010
# Site web : www.gigante.be
# Site python : www.gigante.be/python
# License : GPL
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
from Tkinter import *
import tkMessageBox
from math import *
class Application:
def __init__(self):
self.root=Tk()
self.root.title('Sinus et cosinus - par C. Gigante')
self.u = 24 # unite en px servant à dimensionner TOUS les composants graphiques
self.trait = 2 # épaisseur en px des barres cos et sin
# création des 4 canvas :
self.c1 = Canvas(self.root, bg="white", width=12*self.u, height=12*self.u)
self.c1.grid(row=0, column=0, padx=0, pady=0)
self.c2 = Canvas(self.root, bg="white", width=17*self.u, height=12*self.u)
self.c2.grid(row=0, column=1, padx=0, pady=0)
self.c3 = Canvas(self.root, bg="white", width=12*self.u, height=17*self.u)
self.c3.grid(row=1, column=0, padx=0, pady=0)
self.c4 = Canvas(self.root, width=17*self.u, height=17*self.u)
self.c4.grid(row=1, column=1, padx=0, pady=0)
self.nbre_de_pixels_sur_axe_x = self.u * 12
# sur ce nombre de pixels, s'étendent 360 degrés.
self.nbre_pixels_pour_1_deg = float(self.nbre_de_pixels_sur_axe_x)/360
coordspoursin = []
for t in range(0,self.nbre_de_pixels_sur_axe_x,1):
x = t
y = sin ( radians( x / self.nbre_pixels_pour_1_deg ))
xx = 2 * self.u + x
yy = 6 * self.u - (4 * self.u) * y
coordspoursin.append((xx, yy))
coordspourcos = []
# attention, ici, on a tenu compte de l'orientation vers le bas du tracé
# de la fonction cosinus
for t in range(0,self.nbre_de_pixels_sur_axe_x,1):
y = t
x = cos ( radians( y / self.nbre_pixels_pour_1_deg ))
yy = 2 * self.u + y
xx = 6 * self.u + (4 * self.u) * x
coordspourcos.append((xx, yy))
# dessins des éléments fixes du 1er canvas :
self.c1.create_line( 6 * self.u, 11 * self.u, 6 * self.u, 1 * self.u, arrow=LAST, tag="c1_axex")
self.c1.create_line( 1 * self.u, 6 * self.u, 11 * self.u, 6 * self.u, arrow=LAST, tag="c1_axey")
self.c1.create_oval( 2 * self.u, 2 * self.u, 10 * self.u, 10 * self.u)
self.c1.create_text( 7 * self.u, 1 * self.u, text="1")
self.c1.create_text( 11 * self.u, 5 * self.u, text="1")
self.c1.create_text( 1 * self.u, 5 * self.u, text="-1")
self.c1.create_text( 5 * self.u, 11 * self.u, text="-1")
self.c1_x0 = 6 * self.u
self.c1_y0 = 6 * self.u
# dessins des éléments mobiles du 1er canvas :
self.arc1 = self.c1.create_arc( 5 * self.u, 5 * self.u, 7 * self.u, 7 * self.u, start = 0, extent = 0, fill="", style=ARC, outline="#EFEFEF", width = 1, tag="arc1")
self.barrecosc1 = self.c1.create_line( self.c1_x0, self.c1_y0 - (self.trait/2), 10 * self.u, 6 * self.u - (self.trait/2), fill="green", width=self.trait, tag="barrecosc1")
# le (- self.trait/2) de self.barrecosc1 sert à décaler légèrement la vue de la barre cosinus de l'axe horizontal
self.barresinc1 = self.c1.create_line( 10 * self.u, 6 * self.u, 10 * self.u, 6 * self.u, fill="red", width=self.trait, tag="barresinc1")
self.rayon = self.c1.create_line( self.c1_x0, self.c1_y0, 10 * self.u, 6 * self.u, tag="rayon")
self.boule1 = self.c1.create_oval( 9.8 * self.u, 5.8 * self.u, 10.2 * self.u, 6.2 * self.u, fill="orange", width=0, tag="boule1")
# dessins des éléments fixes du 2ème canvas :
self.c2.create_line( 1 * self.u, 6 * self.u, 16 * self.u, 6 * self.u, arrow=LAST, tag="c2_axex")
self.c2.create_line( 2 * self.u, 11 * self.u, 2 * self.u, 1 * self.u, arrow=LAST, tag="c2_axey")
self.c2.create_line( 5 * self.u, 5.5 * self.u, 5 * self.u, 6.5 * self.u) # trait x
self.c2.create_line( 8 * self.u, 5.5 * self.u, 8 * self.u, 6.5 * self.u) # trait x
self.c2.create_line( 11 * self.u, 5.5 * self.u, 11 * self.u, 6.5 * self.u) # trait x
self.c2.create_line( 14 * self.u, 5.5 * self.u, 14 * self.u, 6.5 * self.u) # trait x
self.c2.create_line( 1.5 * self.u, 2 * self.u, 2.5 * self.u, 2 * self.u) # trait y
self.c2.create_line( 1.5 * self.u, 10 * self.u, 2.5 * self.u, 10 * self.u) # trait y
self.c2.create_text( 1 * self.u, 2 * self.u, text="1")
self.c2.create_text( 1 * self.u, 10 * self.u, text="-1")
self.c2.create_text( 3 * self.u, 1 * self.u, text="Sin(x)")
self.c2.create_text( 15 * self.u, 5 * self.u, text="x (degré)")
self.c2.create_line( coordspoursin, fill="blue", smooth=1 )
self.c2_x0 = 2 * self.u
self.c2_y0 = 6 * self.u
# dessins des éléments mobiles du 2ème canvas :
self.barresinc2 = self.c2.create_line( 2 * self.u, 6 * self.u, 2 * self.u, 6 * self.u, fill="red", width=self.trait, tag="barresinc2")
self.boule2 = self.c2.create_oval( 1.8 * self.u, 5.8 * self.u, 2.2 * self.u, 6.2 * self.u, fill="orange", width=0, tag="boule2")
# dessins des éléments fixes du 3ème canvas :
self.c3.create_line( 6 * self.u, 1 * self.u, 6 * self.u, 16 * self.u, arrow=LAST, tag="c3_axex")
self.c3.create_line( 1 * self.u, 2 * self.u, 11 * self.u, 2 * self.u, arrow=LAST, tag="c3_axey")
self.c3.create_line( 2 * self.u, 1.5 * self.u, 2 * self.u, 2.5 * self.u) # trait y
self.c3.create_line( 10 * self.u, 1.5 * self.u, 10 * self.u, 2.5 * self.u) # trait y
self.c3.create_line( 5.5 * self.u, 5 * self.u, 6.5 * self.u, 5 * self.u) # trait x
self.c3.create_line( 5.5 * self.u, 8 * self.u, 6.5 * self.u, 8 * self.u) # trait x
self.c3.create_line( 5.5 * self.u, 11 * self.u, 6.5 * self.u, 11 * self.u) # trait x
self.c3.create_line( 5.5 * self.u, 14 * self.u, 6.5 * self.u, 14 * self.u) # trait x
self.c3.create_text( 2 * self.u, 1 * self.u, text="-1")
self.c3.create_text( 10 * self.u, 1 * self.u, text="1")
self.c3.create_text( 7 * self.u, 1 * self.u, text="Cos(x)")
self.c3.create_text( 8 * self.u, 16 * self.u, text="x (degré)")
self.c3.create_line( coordspourcos, fill="blue", smooth=1 )
self.c3_x0 = 6 * self.u
self.c3_y0 = 2 * self.u
# dessins des éléments mobiles du 3ème canvas :
self.barrecosc3 = self.c3.create_line( self.c3_x0, self.c3_y0, self.c3_x0 + 4 * self.u, self.c3_y0, fill="green", width=self.trait, tag="barrecosc3")
self.boule3 = self.c3.create_oval( 9.8 * self.u, 1.8 * self.u, 10.2 * self.u, 2.2 * self.u, fill="orange", width=0, tag="boule3")
# éléments du 4ème canvas :
imgsin = PhotoImage(file = "img_sinus.gif")
imgcos = PhotoImage(file = "img_cosinus.gif")
img1 = Label(self.c4, image=imgsin)
img1.pack(side=TOP)
self.controle = Scale(self.c4, from_ = 0, to = 360, label="Degrés", resolution = 1, tickinterval=45, orient=HORIZONTAL, length = 15*self.u, command = self.redessinertout)
self.controle.pack(side=TOP)
img2 = Label(self.c4, image=imgcos)
img2.pack(side=TOP)
bouton_apropos = Button(self.c4, text="A propos de ce programme...", command=self.afficherapropos)
bouton_apropos.pack(side=RIGHT)
self.root.mainloop()
def redessinertout(self, event=None):
angle = int(self.controle.get())
nouv_sin = sin(radians(angle))
nouv_cos = cos(radians(angle))
# update de l'arc symbolisant l'angle dans le canvas 1
arc_angle = angle
if arc_angle == 360:
arc_angle = 359 # ceci est fait pour éviter la disparition de l'arc quand l'angle atteint 360 deg.
self.c1.itemconfigure("arc1",extent=arc_angle)
# update de la boule 1 (et du rayon) :
x = self.c1_x0 + nouv_cos * 4 * self.u
y = self.c1_y0 - nouv_sin * 4 * self.u
self.c1.coords("rayon", self.c1_x0, self.c1_y0, x, y) # update du rayon
self.c1.coords("boule1", x - 0.2 * self.u, y - 0.2 * self.u, x + 0.2 * self.u, y + 0.2 * self.u)
# update de la barre du sin dans le canvas 1
dx = self.c1_x0 + nouv_cos * 4 * self.u
dy = self.c1_y0 - nouv_sin * 4 * self.u
self.c1.coords("barresinc1", dx, 6 * self.u, dx, dy)
# update de la barre du cos dans le canvas 1
self.c1.coords("barrecosc1", self.c1_x0 , self.c1_y0 - (self.trait/2) , self.c1_x0 + nouv_cos * 4 * self.u, self.c1_y0 - (self.trait/2) )
# update de la barre du sin dans le canvas 2
dx2 = self.c2_x0 + angle * self.nbre_pixels_pour_1_deg
dy2 = self.c2_y0 - nouv_sin * 4 * self.u
self.c2.coords("barresinc2", dx2, 6 * self.u, dx2, dy2)
# update de la boule 2 dans le canvas 2
self.c2.coords("boule2", dx2 - 0.2 * self.u, dy2 - 0.2 * self.u, dx2 + 0.2 * self.u, dy2 + 0.2 * self.u)
# update de la barre du cos dans le canvas 3
dx3 = self.c3_x0 + nouv_cos * 4 * self.u
dy3 = self.c3_y0 + angle * self.nbre_pixels_pour_1_deg
self.c3.coords("barrecosc3", self.c3_x0, dy3, dx3, dy3)
# update de la boule 3 dans le canvas 3
self.c3.coords("boule3", dx3 - 0.2 * self.u, dy3 - 0.2 * self.u, dx3 + 0.2 * self.u, dy3 + 0.2 * self.u)
def afficherapropos(self):
tkMessageBox.showinfo(
"A propos de...",
"Sinus et Cosinus\n\n"+
"Un petit programme écrit en Python 2.6 qui\n"+
"utilise Tkinter et qui permet simplement\n"+
"de visualiser dynamiquement le sinus\n"+
"et le cosinus d'un angle en degrés.\n\n"+
"Auteur : Calogero GIGANTE - www.gigante.be - 2010")
# départ du programme principal :
f = Application()

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

# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# Illustration du SINUS et du COSINUS
# -----------------------------------------------------------------------------
# Auteur : Calogero GIGANTE
# Version python : 2.6.4. avec Tkinter
# Objectif : illustrer dynamiquement le sin et le cos d'un angle en degrés.
# Date : 17 janvier 2010
# Site web : www.gigante.be
# Site python : www.gigante.be/python
# License : GPL
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------

from Tkinter import *
import tkMessageBox
from math import *

class Application:
    def __init__(self):
        self.root=Tk()
        self.root.title('Sinus et cosinus - par C. Gigante')

        self.u = 24 # unite en px servant à dimensionner TOUS les composants graphiques
        self.trait = 2 # épaisseur en px des barres cos et sin

        # création des 4 canvas :
        self.c1 = Canvas(self.root, bg="white", width=12*self.u, height=12*self.u)
        self.c1.grid(row=0, column=0, padx=0, pady=0)
        self.c2 = Canvas(self.root, bg="white", width=17*self.u, height=12*self.u)
        self.c2.grid(row=0, column=1, padx=0, pady=0)
        self.c3 = Canvas(self.root, bg="white", width=12*self.u, height=17*self.u)
        self.c3.grid(row=1, column=0, padx=0, pady=0)
        self.c4 = Canvas(self.root,             width=17*self.u, height=17*self.u)
        self.c4.grid(row=1, column=1, padx=0, pady=0)

        self.nbre_de_pixels_sur_axe_x = self.u * 12
        # sur ce nombre de pixels, s'étendent 360 degrés.
        self.nbre_pixels_pour_1_deg = float(self.nbre_de_pixels_sur_axe_x)/360

        coordspoursin = []
        for t in range(0,self.nbre_de_pixels_sur_axe_x,1):
            x = t
            y = sin ( radians( x / self.nbre_pixels_pour_1_deg ))
            xx = 2 * self.u + x
            yy = 6 * self.u - (4 * self.u) * y
            coordspoursin.append((xx, yy))

        coordspourcos = []
        # attention, ici, on a tenu compte de l'orientation vers le bas du tracé
        # de la fonction cosinus
        for t in range(0,self.nbre_de_pixels_sur_axe_x,1):
            y = t
            x = cos ( radians( y / self.nbre_pixels_pour_1_deg ))
            yy = 2 * self.u + y
            xx = 6 * self.u + (4 * self.u) * x
            coordspourcos.append((xx, yy))

        # dessins des éléments fixes du 1er canvas :
        self.c1.create_line(  6 * self.u, 11 * self.u,  6 * self.u,  1 * self.u, arrow=LAST, tag="c1_axex")
        self.c1.create_line(  1 * self.u,  6 * self.u, 11 * self.u,  6 * self.u, arrow=LAST, tag="c1_axey")
        self.c1.create_oval(  2 * self.u,  2 * self.u, 10 * self.u, 10 * self.u)
        self.c1.create_text(  7 * self.u,  1 * self.u, text="1")
        self.c1.create_text( 11 * self.u,  5 * self.u, text="1")
        self.c1.create_text(  1 * self.u,  5 * self.u, text="-1")
        self.c1.create_text(  5 * self.u, 11 * self.u, text="-1")
        self.c1_x0 = 6 * self.u
        self.c1_y0 = 6 * self.u
        # dessins des éléments mobiles du 1er canvas :
        self.arc1 = self.c1.create_arc(  5 * self.u,  5 * self.u, 7 * self.u, 7 * self.u, start = 0, extent = 0, fill="", style=ARC, outline="#EFEFEF", width = 1, tag="arc1")
        self.barrecosc1 = self.c1.create_line(  self.c1_x0,  self.c1_y0 - (self.trait/2), 10 * self.u,  6 * self.u - (self.trait/2), fill="green", width=self.trait, tag="barrecosc1")
        #              le (- self.trait/2) de self.barrecosc1 sert à décaler légèrement la vue de la barre cosinus de l'axe horizontal
        self.barresinc1 = self.c1.create_line(  10 * self.u,  6 * self.u, 10 * self.u,  6 * self.u, fill="red", width=self.trait, tag="barresinc1")
        self.rayon =  self.c1.create_line(  self.c1_x0,  self.c1_y0, 10 * self.u,  6 * self.u, tag="rayon")
        self.boule1 = self.c1.create_oval(  9.8 * self.u,  5.8 * self.u, 10.2 * self.u, 6.2 * self.u, fill="orange", width=0, tag="boule1")

        # dessins des éléments fixes du 2ème canvas :
        self.c2.create_line( 1 * self.u,  6 * self.u, 16 * self.u,  6 * self.u, arrow=LAST, tag="c2_axex")
        self.c2.create_line( 2 * self.u, 11 * self.u,  2 * self.u,  1 * self.u, arrow=LAST, tag="c2_axey")
        self.c2.create_line(  5 * self.u,  5.5 * self.u,  5 * self.u,  6.5 * self.u) # trait x
        self.c2.create_line(  8 * self.u,  5.5 * self.u,  8 * self.u,  6.5 * self.u) # trait x
        self.c2.create_line( 11 * self.u,  5.5 * self.u, 11 * self.u,  6.5 * self.u) # trait x
        self.c2.create_line( 14 * self.u,  5.5 * self.u, 14 * self.u,  6.5 * self.u) # trait x
        self.c2.create_line( 1.5 * self.u,  2 * self.u, 2.5 * self.u,  2 * self.u) # trait y
        self.c2.create_line( 1.5 * self.u, 10 * self.u, 2.5 * self.u, 10 * self.u) # trait y
        self.c2.create_text(  1 * self.u,  2 * self.u, text="1")
        self.c2.create_text(  1 * self.u, 10 * self.u, text="-1")
        self.c2.create_text(  3 * self.u, 1 * self.u, text="Sin(x)")
        self.c2.create_text( 15 * self.u, 5 * self.u, text="x (degré)")
        self.c2.create_line( coordspoursin, fill="blue", smooth=1 )
        self.c2_x0 = 2 * self.u
        self.c2_y0 = 6 * self.u
        # dessins des éléments mobiles du 2ème canvas :
        self.barresinc2 = self.c2.create_line(  2 * self.u,  6 * self.u, 2 * self.u,  6 * self.u, fill="red", width=self.trait, tag="barresinc2")
        self.boule2 = self.c2.create_oval(  1.8 * self.u,  5.8 * self.u, 2.2 * self.u, 6.2 * self.u, fill="orange", width=0, tag="boule2")

        # dessins des éléments fixes du 3ème canvas :
        self.c3.create_line( 6 * self.u,  1 * self.u,  6 * self.u, 16 * self.u, arrow=LAST, tag="c3_axex")
        self.c3.create_line( 1 * self.u,  2 * self.u, 11 * self.u,  2 * self.u, arrow=LAST, tag="c3_axey")
        self.c3.create_line(  2 * self.u,  1.5 * self.u,  2 * self.u,  2.5 * self.u) # trait y
        self.c3.create_line( 10 * self.u,  1.5 * self.u, 10 * self.u,  2.5 * self.u) # trait y
        self.c3.create_line( 5.5 * self.u,  5 * self.u, 6.5 * self.u,  5 * self.u) # trait x
        self.c3.create_line( 5.5 * self.u,  8 * self.u, 6.5 * self.u,  8 * self.u) # trait x
        self.c3.create_line( 5.5 * self.u, 11 * self.u, 6.5 * self.u, 11 * self.u) # trait x
        self.c3.create_line( 5.5 * self.u, 14 * self.u, 6.5 * self.u, 14 * self.u) # trait x
        self.c3.create_text(  2 * self.u,  1 * self.u, text="-1")
        self.c3.create_text( 10 * self.u,  1 * self.u, text="1")
        self.c3.create_text(  7 * self.u,  1 * self.u, text="Cos(x)")
        self.c3.create_text(  8 * self.u, 16 * self.u, text="x (degré)")
        self.c3.create_line( coordspourcos, fill="blue", smooth=1 )
        self.c3_x0 = 6 * self.u
        self.c3_y0 = 2 * self.u
        # dessins des éléments mobiles du 3ème canvas :
        self.barrecosc3 = self.c3.create_line(  self.c3_x0,  self.c3_y0, self.c3_x0 + 4 * self.u,  self.c3_y0, fill="green", width=self.trait, tag="barrecosc3")
        self.boule3 = self.c3.create_oval( 9.8 * self.u,  1.8 * self.u, 10.2 * self.u, 2.2 * self.u, fill="orange", width=0, tag="boule3")

        # éléments du 4ème canvas :
        imgsin = PhotoImage(file = "img_sinus.gif")
        imgcos = PhotoImage(file = "img_cosinus.gif")
        img1 = Label(self.c4, image=imgsin)
        img1.pack(side=TOP)
        self.controle = Scale(self.c4, from_ = 0, to = 360, label="Degrés", resolution = 1, tickinterval=45, orient=HORIZONTAL, length = 15*self.u, command = self.redessinertout)
        self.controle.pack(side=TOP)
        img2 = Label(self.c4, image=imgcos)
        img2.pack(side=TOP)
        bouton_apropos = Button(self.c4, text="A propos de ce programme...", command=self.afficherapropos)
        bouton_apropos.pack(side=RIGHT)

        self.root.mainloop()

    def redessinertout(self, event=None):
        angle = int(self.controle.get())
        nouv_sin = sin(radians(angle))
        nouv_cos = cos(radians(angle))

        # update de l'arc symbolisant l'angle dans le canvas 1
        arc_angle = angle
        if arc_angle == 360:
            arc_angle = 359 # ceci est fait pour éviter la disparition de l'arc quand l'angle atteint 360 deg.
        self.c1.itemconfigure("arc1",extent=arc_angle)

        # update de la boule 1 (et du rayon) :
        x = self.c1_x0 + nouv_cos * 4 * self.u
        y = self.c1_y0 - nouv_sin * 4 * self.u
        self.c1.coords("rayon", self.c1_x0, self.c1_y0, x, y) # update du rayon
        self.c1.coords("boule1", x - 0.2 * self.u, y - 0.2 * self.u, x + 0.2 * self.u, y + 0.2 * self.u)

        # update de la barre du sin dans le canvas 1
        dx = self.c1_x0 + nouv_cos * 4 * self.u
        dy = self.c1_y0 - nouv_sin * 4 * self.u
        self.c1.coords("barresinc1",  dx,  6 * self.u, dx,  dy)

        # update de la barre du cos dans le canvas 1
        self.c1.coords("barrecosc1", self.c1_x0 ,  self.c1_y0 - (self.trait/2) , self.c1_x0 + nouv_cos * 4 * self.u, self.c1_y0 - (self.trait/2) )

        # update de la barre du sin dans le canvas 2
        dx2 = self.c2_x0 + angle * self.nbre_pixels_pour_1_deg
        dy2 = self.c2_y0 - nouv_sin * 4 * self.u
        self.c2.coords("barresinc2",  dx2,  6 * self.u, dx2,  dy2)
        # update de la boule 2 dans le canvas 2
        self.c2.coords("boule2",  dx2 - 0.2 * self.u,  dy2 - 0.2 * self.u, dx2 + 0.2 * self.u,  dy2 + 0.2 * self.u)

        # update de la barre du cos dans le canvas 3
        dx3 = self.c3_x0 + nouv_cos * 4 * self.u
        dy3 = self.c3_y0 + angle * self.nbre_pixels_pour_1_deg
        self.c3.coords("barrecosc3", self.c3_x0, dy3, dx3,  dy3)
        # update de la boule 3 dans le canvas 3
        self.c3.coords("boule3",  dx3 - 0.2 * self.u,  dy3 - 0.2 * self.u, dx3 + 0.2 * self.u,  dy3 + 0.2 * self.u)

    def afficherapropos(self):
        tkMessageBox.showinfo(
            "A propos de...",
            "Sinus et Cosinus\n\n"+
            "Un petit programme écrit en Python 2.6 qui\n"+
            "utilise Tkinter et qui permet simplement\n"+
            "de visualiser dynamiquement le sinus\n"+
            "et le cosinus d'un angle en degrés.\n\n"+
            "Auteur : Calogero GIGANTE - www.gigante.be - 2010")

# départ du programme principal :

f = Application()

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

img_cosinus.gif 1 786 octets
img_sinus.gif 1 605 octets
sinus_cosinus.pyw 10 703 octets

Télécharger le zip

Sources du même auteur

EQUATION STANDARD DE LA DROITE

DESSIN DE DÉS À ÉCHELLE VARIABLE SUR CANVAS

Toutes les sources de calogerogigante

Sources de la même categorie

EDITEUR CROQUIS par grephit

TV PROGRAM FETCHING AND PARSING FOR ANYONE WOULD KEEP TRACE ... par Senethril

RECHERCHE DE DOUBLONS DANS DES DOSSIERS. par Rano Its

LE MOT LE PLUS LONG PAR DICO par Clempython

EQUATION STANDARD DE LA DROITE par calogerogigante

Toutes les sources de la catégorie Application complète

Sources en rapport avec celle ci

TPYCODE, TRADUCTEUR DE CODE par jonathan33350

TAQUIN 4*4 par fredericfabry

TRIANGULATION par mecrosoft

EQUATION STANDARD DE LA DROITE par calogerogigante

CALCULATRICE SIMPLICISTE SOUS TKINTER par elnabo

Commentaires et avis

Commentaire de bothan le 27/01/2010 13:17:48

Bonjour

Bravo pour ce petit code educatif que je me suis permis de completer pour utiliser tes routines de mise a jour des canvas afin de transformer l'application en une animation interactive: en voici le code modifié si cela t'interesse.

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

# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# Illustration dynamique des fonctions Sin(x) et Cos(x)
# -----------------------------------------------------------------------------
# Auteurs : Calogero GIGANTE - MRG
# Version python : 2.6.4. avec Tkinter
# Objectif : illustrer dynamiquement le sinus et le cosinus d'un angle en degrés.
# Date : 27 janvier 2010
# Site web : www.gigante.be
# Site python : www.gigante.be/python
# License : GPL
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------

from Tkinter import *
import tkMessageBox
import threading
from math import *
from time import *

class Application(threading.Thread):
      def __init__(self):
          threading.Thread.__init__(self)
          self.Terminated = False
          self.root=Tk()
          self.root.title('Sinus et cosinus - par C. Gigante - Mod MRG')
          self.root.geometry('740x720+300+50')

          self.u = 24 # unite en px servant à dimensionner TOUS les composants graphiques
          self.trait = 2 # épaisseur en px des barres cos et sin

          # création des 4 canvas :
          self.c1 = Canvas(self.root, bg="white", width=12*self.u, height=12*self.u)
          self.c1.grid(row=0, column=0, padx=0, pady=0)
          self.c2 = Canvas(self.root, bg="white", width=17*self.u, height=12*self.u)
          self.c2.grid(row=0, column=1, padx=0, pady=0)
          self.c3 = Canvas(self.root, bg="white", width=12*self.u, height=17*self.u)
          self.c3.grid(row=1, column=0, padx=0, pady=0)
          self.c4 = Canvas(self.root, width=17*self.u, height=17*self.u)
          self.c4.grid(row=1, column=1, padx=0, pady=0)

          self.nbre_de_pixels_sur_axe_x = self.u * 12
          # sur ce nombre de pixels, s'étendent 360 degrés.
          self.nbre_pixels_pour_1_deg = float(self.nbre_de_pixels_sur_axe_x)/360

          coordspoursin = []
          for t in range(0,self.nbre_de_pixels_sur_axe_x,1):
              x = t
              y = sin ( radians( x / self.nbre_pixels_pour_1_deg ))
              xx = 2 * self.u + x
              yy = 6 * self.u - (4 * self.u) * y
              coordspoursin.append((xx, yy))

              coordspourcos = []
              # attention, ici, on a tenu compte de l'orientation vers le bas du tracé
              # de la fonction cosinus
              for t in range(0,self.nbre_de_pixels_sur_axe_x,1):
                  y = t
                  x = cos ( radians( y / self.nbre_pixels_pour_1_deg ))
                  yy = 2 * self.u + y
                  xx = 6 * self.u + (4 * self.u) * x
                  coordspourcos.append((xx, yy))

          # dessins des éléments fixes du 1er canvas :
          self.c1.create_line( 6 * self.u, 11 * self.u, 6 * self.u, 1 * self.u, arrow=LAST, tag="c1_axex")
          self.c1.create_line( 1 * self.u, 6 * self.u, 11 * self.u, 6 * self.u, arrow=LAST, tag="c1_axey")
          self.c1.create_oval( 2 * self.u, 2 * self.u, 10 * self.u, 10 * self.u)
          self.c1.create_text( 7 * self.u, 1 * self.u, text="1")
          self.c1.create_text( 11 * self.u, 5 * self.u, text="1")
          self.c1.create_text( 1 * self.u, 5 * self.u, text="-1")
          self.c1.create_text( 5 * self.u, 11 * self.u, text="-1")
          self.c1_x0 = 6 * self.u
          self.c1_y0 = 6 * self.u
          # dessins des éléments mobiles du 1er canvas :
          self.arc1 = self.c1.create_arc( 5 * self.u, 5 * self.u, 7 * self.u, 7 * self.u, start = 0, extent = 0, fill="", style=ARC, outline="#EFEFEF", width = 1, tag="arc1")
          self.barrecosc1 = self.c1.create_line( self.c1_x0, self.c1_y0 - (self.trait/2), 10 * self.u, 6 * self.u - (self.trait/2), fill="green", width=self.trait, tag="barrecosc1")
          # le (- self.trait/2) de self.barrecosc1 sert à décaler légèrement la vue de la barre cosinus de l'axe horizontal
          self.barresinc1 = self.c1.create_line( 10 * self.u, 6 * self.u, 10 * self.u, 6 * self.u, fill="red", width=self.trait, tag="barresinc1")
          self.rayon = self.c1.create_line( self.c1_x0, self.c1_y0, 10 * self.u, 6 * self.u, tag="rayon")
          self.boule1 = self.c1.create_oval( 9.8 * self.u, 5.8 * self.u, 10.2 * self.u, 6.2 * self.u, fill="orange", width=0, tag="boule1")

          # dessins des éléments fixes du 2ème canvas :
          self.c2.create_line( 1 * self.u, 6 * self.u, 16 * self.u, 6 * self.u, arrow=LAST, tag="c2_axex")
          self.c2.create_line( 2 * self.u, 11 * self.u, 2 * self.u, 1 * self.u, arrow=LAST, tag="c2_axey")
          self.c2.create_line( 5 * self.u, 5.5 * self.u, 5 * self.u, 6.5 * self.u) # trait x
          self.c2.create_line( 8 * self.u, 5.5 * self.u, 8 * self.u, 6.5 * self.u) # trait x
          self.c2.create_line( 11 * self.u, 5.5 * self.u, 11 * self.u, 6.5 * self.u) # trait x
          self.c2.create_line( 14 * self.u, 5.5 * self.u, 14 * self.u, 6.5 * self.u) # trait x
          self.c2.create_line( 1.5 * self.u, 2 * self.u, 2.5 * self.u, 2 * self.u) # trait y
          self.c2.create_line( 1.5 * self.u, 10 * self.u, 2.5 * self.u, 10 * self.u) # trait y
          self.c2.create_text( 1 * self.u, 2 * self.u, text="1")
          self.c2.create_text( 1 * self.u, 10 * self.u, text="-1")
          self.c2.create_text( 3 * self.u, 1 * self.u, text="Sin(x)")
          self.c2.create_text( 15 * self.u, 5 * self.u, text="x (degré)")
          self.c2.create_line( coordspoursin, fill="blue", smooth=1 )
          self.c2_x0 = 2 * self.u
          self.c2_y0 = 6 * self.u
          # dessins des éléments mobiles du 2ème canvas :
          self.barresinc2 = self.c2.create_line( 2 * self.u, 6 * self.u, 2 * self.u, 6 * self.u, fill="red", width=self.trait, tag="barresinc2")
          self.boule2 = self.c2.create_oval( 1.8 * self.u, 5.8 * self.u, 2.2 * self.u, 6.2 * self.u, fill="orange", width=0, tag="boule2")

          # dessins des éléments fixes du 3ème canvas :
          self.c3.create_line( 6 * self.u, 1 * self.u, 6 * self.u, 16 * self.u, arrow=LAST, tag="c3_axex")
          self.c3.create_line( 1 * self.u, 2 * self.u, 11 * self.u, 2 * self.u, arrow=LAST, tag="c3_axey")
          self.c3.create_line( 2 * self.u, 1.5 * self.u, 2 * self.u, 2.5 * self.u) # trait y
          self.c3.create_line( 10 * self.u, 1.5 * self.u, 10 * self.u, 2.5 * self.u) # trait y
          self.c3.create_line( 5.5 * self.u, 5 * self.u, 6.5 * self.u, 5 * self.u) # trait x
          self.c3.create_line( 5.5 * self.u, 8 * self.u, 6.5 * self.u, 8 * self.u) # trait x
          self.c3.create_line( 5.5 * self.u, 11 * self.u, 6.5 * self.u, 11 * self.u) # trait x
          self.c3.create_line( 5.5 * self.u, 14 * self.u, 6.5 * self.u, 14 * self.u) # trait x
          self.c3.create_text( 2 * self.u, 1 * self.u, text="-1")
          self.c3.create_text( 10 * self.u, 1 * self.u, text="1")
          self.c3.create_text( 7 * self.u, 1 * self.u, text="Cos(x)")
          self.c3.create_text( 8 * self.u, 16 * self.u, text="x (degré)")
          self.c3.create_line( coordspourcos, fill="blue", smooth=1 )
          self.c3_x0 = 6 * self.u
          self.c3_y0 = 2 * self.u
          # dessins des éléments mobiles du 3ème canvas :
          self.barrecosc3 = self.c3.create_line( self.c3_x0, self.c3_y0, self.c3_x0 + 4 * self.u, self.c3_y0, fill="green", width=self.trait, tag="barrecosc3")
          self.boule3 = self.c3.create_oval( 9.8 * self.u, 1.8 * self.u, 10.2 * self.u, 2.2 * self.u, fill="orange", width=0, tag="boule3")

          # éléments du 4ème canvas :
          imgsin = PhotoImage(file = "img_sinus.gif")
          imgcos = PhotoImage(file = "img_cosinus.gif")
          img1 = Label(self.c4, image=imgsin)
          img1.pack(side=TOP)
          self.controle = Scale(self.c4, from_ = 0, to = 360, label="Degrés", resolution = 1, tickinterval=45, orient=HORIZONTAL, length = 15*self.u, command = self.redessinertout)
          self.controle.pack(side=TOP)
          img2 = Label(self.c4, image=imgcos)
          img2.pack(side=TOP)

          #Spacers pour les boutons du 4éme canvas ::
          spcr = Label(self.c4, text=" ")
          spcr2 = Label(self.c4, text=" ")
          spcr3 = Label(self.c4, text=" ")

          #Boutons du 4éme canvas :
          bouton_animate = Button(self.c4, text="Animation 0-360", command=self.ianimate)
          bouton_stop = Button(self.c4, text="Arret", command=self.stop)
          bouton_reprendre =Button(self.c4, text="Reprendre", command=self.reprendre)
          bouton_reset = Button(self.c4, text="Remise a 0", command=self.reset)
          bouton_apropos = Button(self.c4, text="A propos...", command=self.afficherapropos)
          bouton_animate.pack(side=LEFT)
          spcr.pack(side=LEFT)
          bouton_stop.pack(side=LEFT)
          spcr2.pack(side=LEFT)
          bouton_reprendre.pack(side=LEFT)
          spcr3.pack(side=LEFT)
          bouton_reset.pack(side=LEFT)
          bouton_apropos.pack(side=RIGHT)
          self.root.mainloop()

      #Thread Stop :
      def stop(self):
          self.Terminated = True

      #Mise a jour des canvas avec un angle donné :
      def redessiner(self,x):

          self.controle.set(x)
          angle = int(self.controle.get())
          nouv_sin = sin(radians(x))
          nouv_cos = cos(radians(x))

          # update de l'arc symbolisant l'angle dans le canvas 1
          arc_angle = x
          if arc_angle == 360:
             arc_angle = 359 # ceci est fait pour éviter la disparition de l'arc quand l'angle atteint 360 deg.
          self.c1.itemconfigure("arc1",extent=arc_angle)

          # update de la boule 1 (et du rayon) :
          x = self.c1_x0 + nouv_cos * 4 * self.u
          y = self.c1_y0 - nouv_sin * 4 * self.u
          self.c1.coords("rayon", self.c1_x0, self.c1_y0, x, y) # update du rayon
          self.c1.coords("boule1", x - 0.2 * self.u, y - 0.2 * self.u, x + 0.2 * self.u, y + 0.2 * self.u)

          # update de la barre du sin dans le canvas 1
          dx = self.c1_x0 + nouv_cos * 4 * self.u
          dy = self.c1_y0 - nouv_sin * 4 * self.u
          self.c1.coords("barresinc1", dx, 6 * self.u, dx, dy)

          # update de la barre du cos dans le canvas 1
          self.c1.coords("barrecosc1", self.c1_x0 , self.c1_y0 - (self.trait/2) , self.c1_x0 + nouv_cos * 4 * self.u, self.c1_y0 - (self.trait/2) )

          # update de la barre du sin dans le canvas 2
          dx2 = self.c2_x0 + angle * self.nbre_pixels_pour_1_deg
          dy2 = self.c2_y0 - nouv_sin * 4 * self.u
          self.c2.coords("barresinc2", dx2, 6 * self.u, dx2, dy2)
          # update de la boule 2 dans le canvas 2
          self.c2.coords("boule2", dx2 - 0.2 * self.u, dy2 - 0.2 * self.u, dx2 + 0.2 * self.u, dy2 + 0.2 * self.u)

          # update de la barre du cos dans le canvas 3
          dx3 = self.c3_x0 + nouv_cos * 4 * self.u
          dy3 = self.c3_y0 + angle * self.nbre_pixels_pour_1_deg
          self.c3.coords("barrecosc3", self.c3_x0, dy3, dx3, dy3)
          # update de la boule 3 dans le canvas 3
          self.c3.coords("boule3", dx3 - 0.2 * self.u, dy3 - 0.2 * self.u, dx3 + 0.2 * self.u, dy3 + 0.2 * self.u)

      #Mise a jour des canvas avec un angle donné par le controle :
      def redessinertout(self, event=None):
          angle = int(self.controle.get())
          self.redessiner(angle)

      def reset(self, event=None):
          if self.Terminated == False:
            self.Terminated = True
          self.redessiner(0)

      #Reprise de l'animation :
      def reprendre(self):
          self.animate(self.controle.get())

      #Lancement animation 0-360 :
      def ianimate(self):
          self.controle.set(0)
          self.animate(0)

      #Lancement de l'animation
      def animate(self, y):
        if self.Terminated == True:
            self.Terminated = False

        while not self.Terminated:
              for i in range(361):
                  if self.Terminated == True:
                        stop
                  if i >= int(self.controle.get()):
                           self.controle.set(i)
                           sleep(0.02)
                           self.redessiner(i)
                           self.root.update()

              # update de la boule 2 dans le canvas 2
              dx2 = self.c2_x0 + 0 * self.nbre_pixels_pour_1_deg
              dy2 = self.c2_y0 - sin(radians(0)) * 4 * self.u
              self.c2.coords("boule2", dx2 - 0.2 * self.u, dy2 - 0.2 * self.u, dx2 + 0.2 * self.u, dy2 + 0.2 * self.u)

              # update de la boule 3 et barre 3 dans le canvas 3
              dx3 = self.c3_x0 + cos(radians(0)) * 4 * self.u
              dy3 = self.c3_y0 + 0 * self.nbre_pixels_pour_1_deg
              self.c3.coords("boule3", dx3 - 0.2 * self.u, dy3 - 0.2 * self.u, dx3 + 0.2 * self.u, dy3 + 0.2 * self.u)
              self.c3.coords("barrecosc3", self.c3_x0, dy3, dx3, dy3)

              #update du controle
              self.controle.set(0)

      #Affichage MsgBox :
      def afficherapropos(self):
        tkMessageBox.showinfo(
        "A propos de...",
        "Sinus et Cosinus\n\n"+
        "Un petit programme écrit en Python 2.6 qui\n"+
        "utilise Tkinter et qui permet simplement\n"+
        "de visualiser dynamiquement le sinus\n"+
        "et le cosinus d'un angle en degrés.\n\n"+
        "Auteurs : Calogero GIGANTE - MRG - www.gigante.be - 2010")

# Lancement programme principal :
f = Application()

Pour l'indentation cela a l'air OK.

Bonne continuation

Commentaire de calogerogigante le 27/01/2010 14:44:45

Waaaouuuuwwww !!!!

Mille mercis Bothan pour ton ajout qui me ravit, pourquoi ?

Parce que je n'ai pas encore commencé l'étude des threads qui m'intimident un peu...

Ton exemple est donc une superbe opportunité d'approcher le fonctionnement de ces bestioles-là... sur mon propre programme !!! Trop fun !

Juste une petite question : ton code s'exécute très bien sur mon PC, mais j'ai des messages d'erreurs sur la console quand je stoppe ou quand je reprends l'animation...

global name stop is not defined

C'est normal ?

Commentaire de bothan le 27/01/2010 19:42:50

Salut

stop n'est pas reconnue comme methode et du coup on sort de la boucle et ça m'arrange bien d'ailleurs.

ligne229: mettre un return a la place de stop qui permet de sortir de la boucle de maniere plus correcte

en même temps on peut aussi retirer le 2eme parametre de animate que je n'utilise pas

Bonne soirée

Commentaire de calogerogigante le 28/01/2010 11:55:31

Salut BOTHAN, merci pour ta correction, il n'y a plus un seul message d'erreur maintenant. Je suis content de ton code car il m'a fourni un superbe exemple simple d'utilisation des Threads avec un graphisme dans le Canvas. J'ai fait un petit travail de simplification de code, pour aller à l'essentiel et comprendre comment fonctionne la manipulation d'une fonction avec un Thread, en m'inspirant à 100% de ton code modifié.

Voici ce que cela donne :

#!/usr/local/bin/python
# -*- coding:utf-8 -*-
from Tkinter import *
import threading
from time import *
import sys

class Application(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.Terminated = False
        self.root=Tk()
        self.root.title('Barre qui avance avec un thread...')
        self.root.geometry('600x160')
        self.root.protocol("WM_DELETE_WINDOW", self.finirapplication)

        self.valeur = 1

        self.c1 = Canvas(self.root, bg="white")
        self.c1.pack(side=LEFT, expand=YES, fill=BOTH)

        self.barre = self.c1.create_rectangle( 10, 50, 510, 100, fill="yellow")

        #Boutons du 4éme canvas :
        bouton_animate   = Button(self.root, text="Démarrer",      command=self.ianimate)
        bouton_stop      = Button(self.root, text="Arrêt",         command=self.stop)
        bouton_reprendre = Button(self.root, text="Reprendre",     command=self.reprendre)
        bouton_reset     = Button(self.root, text="Remise à zéro", command=self.reset)
        bouton_animate.pack(side=TOP, expand=YES)
        bouton_stop.pack(side=TOP, expand=YES)
        bouton_reprendre.pack(side=TOP, expand=YES)
        bouton_reset.pack(side=TOP, expand=YES)

        self.root.mainloop()

    def stop(self):
        #Thread Stop :
        self.Terminated = True

    def redessiner(self,x):
        #Mise a jour de la barre :
        self.valeur = x

        self.c1.coords(self.barre, 10, 50, 10+x, 100)

    def redessinertout(self, event=None):
        #Mise a jour de la barre avec la valeur donnée par self.valeur :
        self.redessiner(self.valeur)

    def reset(self, event=None):
        if self.Terminated == False:
            self.Terminated = True
        self.redessiner(1)

    def reprendre(self):
        #Reprise de l'animation :
        self.animate()

    def ianimate(self):
        #Lancement animation 0-500 :
        self.valeur = 0
        self.animate()

    def animate(self):
        #Lancement de l'animation
        if self.Terminated == True:
            self.Terminated = False

        while not self.Terminated:
            for i in range(500):
                if self.Terminated == True:
                    return
                if i >= self.valeur:
                    self.valeur = i
                    sleep(0.01)
                    self.redessiner(i)
                    self.root.update()
            #update du controle
            self.valeur = 0

    def finirapplication(self):
        self.Terminated = True
        self.stop()
        sys.exit()

# Lancement programme principal :
if __name__ == "__main__":
    app = Application()

=================

Est-ce que c'est correct, ce que j'ai fait ?

Comment créer un canvas maintenant qui possède plusieurs barres jaunes, chacune manipulées par un thread différent ?

Commentaire de calogerogigante le 28/01/2010 13:34:56

Petite question BUTHON : es-tu sûr d'utiliser les threads correctement ? Car je viens de tester ton programme et mon code simplifié ci-dessus sans invoquer la classe Thread, eh bien, ça marche aussi...

Exemple :

#!/usr/local/bin/python
# -*- coding:utf-8 -*-
from Tkinter import *
import threading
from time import *
import sys

class Application:
    def __init__(self):
        self.Terminated = False
        self.root=Tk()
        self.root.title('Barre qui avance avec un thread...')
        self.root.geometry('600x160')
        self.root.protocol("WM_DELETE_WINDOW", self.finirapplication)

        self.valeur = 1

        self.c1 = Canvas(self.root, bg="white")
        self.c1.pack(side=LEFT, expand=YES, fill=BOTH)

        self.barre = self.c1.create_rectangle( 10, 50, 11, 100, fill="yellow")

        #Boutons du 4éme canvas :
        bouton_animate   = Button(self.root, text="Démarrer",      command=self.ianimate)
        bouton_stop      = Button(self.root, text="Arrêt",         command=self.stop)
        bouton_reprendre = Button(self.root, text="Reprendre",     command=self.reprendre)
        bouton_reset     = Button(self.root, text="Remise à zéro", command=self.reset)
        bouton_animate.pack(side=TOP, expand=YES)
        bouton_stop.pack(side=TOP, expand=YES)
        bouton_reprendre.pack(side=TOP, expand=YES)
        bouton_reset.pack(side=TOP, expand=YES)

        self.root.mainloop()

    def stop(self):
        #Thread Stop :
        self.Terminated = True

    def redessiner(self,x):
        #Mise a jour de la barre :
        self.valeur = x

        self.c1.coords(self.barre, 10, 50, 10+x, 100)

    def redessinertout(self, event=None):
        #Mise a jour de la barre avec la valeur donnée par self.valeur :
        self.redessiner(self.valeur)

    def reset(self, event=None):
        if self.Terminated == False:
            self.Terminated = True
        self.redessiner(1)

    def reprendre(self):
        #Reprise de l'animation :
        self.animate()

    def ianimate(self):
        #Lancement animation 0-500 :
        self.valeur = 0
        self.animate()

    def animate(self):
        #Lancement de l'animation
        if self.Terminated == True:
            self.Terminated = False

        while not self.Terminated:
            for i in range(500):
                if self.Terminated == True:
                    return
                if i >= self.valeur:
                    self.valeur = i
                    sleep(0.01)
                    self.redessiner(i)
                    self.root.update()
            #update du controle
            self.valeur = 0

    def finirapplication(self):
        self.Terminated = True
        self.stop()
        sys.exit()

# Lancement programme principal :
if __name__ == "__main__":
    app = Application()

Un thread t ne doit-il pas faire appel à la méthode t.run() à un moment donné de son existence ?

Commentaire de bothan le 29/01/2010 09:40:48

Salut calogerogigante

En effet même sans gestion des thread ton programme fonctionne, peut être parce qu'il n'y en a qu'un.

N'étant pas du tout un spécialiste de python et encore moins des threads en python, je ne saurais te dire si ma gestion des threads est correcte.

Cela dit un certain nombre d'ouvrages dont celui de G.Swinnen que tu trouveras ici http://www.inforef.be/swi/download/python_notes.pdf font le point et te seront de meilleur conseil que moi.

Bonne continuation

Commentaire de aera group le 28/07/2010 14:46:21

Beau boulot rien à redire de particulier ça vaut bien un 8/10

Commentaire de aera group le 28/07/2010 14:46:39 8/10

Maque la note, c'est fait

Commentaire de calogerogigante le 29/07/2010 22:26:00

Merci.

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

scrollbar dans scrollbox avec TKinter [ par MHI ] Est-ce que quelqu'un sait comment ajouter les scrollbar à une scrollbox :J'ai essayé ceci :lstFile = Tkinter.Listbox(frmMain)lstFile.place(x = 20, y = checkButton avec TKinter [ par MHI ] comment faire pour tester si un checkButton est coché ? Probleme avec TKinter [ par titasse ] Bonjour, je debute en python. J'ai un probleme lorsque je veux importer TKinter avec la commande from TKinter import * j'ai le message suivant : Imp au sujet de Tkinter et le module turtle [ par nico1900 ] from turtle import *forward(120)left(90) color('red') forward(80)bon en fait je voulais tester le module turtle avec l e code ci-d Un Canvas comme dans Tkinter, mais pour wxPython [ par samurize ] Slt tout le monde.   Voila tout est dans le titre (ou a peu pres  ) :   Je suis à la recherche d'un module pouvant s'integrer da Petit problème avec "return" [ par Uims ] Bonjour, Je suis entrain de faire un annuaire en python (avec Tk), mais j'ai un petit problème avec return dans la fonction "loc", j'aimerai que Taille de widgets sous Tkinter [ par Uims ] Bonjour, Quelqu"un saurait comment definir la taille d'un widgets sous tkinter??? Exemple: fen 1 = Tk(taille=600) J'espere que je me fait comprend Ouverture d'un fichier windows (avec Tkinter) [ par Uims ] Bonjour, Je travaille sous python et Tkinter et j'aurai voulu savoir comment dire a python de demarrer (comme on clique sur un fichier) une applicati Tkinter et Python [ par Telimektar1er ] Voila j'ai commencé e python il y a une semaine et jusqu à aujourd'hui aucun problème. Mais voilà, je viens de commencer la cr&#23 help, faire un mastermind en python et en tkinter avant le 24 !!! [ par Crick132 ] je suis étudiante en 2ème année, je dois réaliser un mastermind en python avec 8 couleurs et 5 combinaisons possibles.si quelqu'un

Nos sponsors

Derniers Blogs

TECHDAYS PARIS 2012 : COMMENT SHAREPOINT A SAUVé MES TECHDAYS par ROMELARD Fabrice

PERSPECTIVE 3.0 POUR SILVERLIGHT 5.0 par odewit

TECHDAYS PARIS 2012 : TOP 10 DES BEST PRACTICES POUR SQL SERVER par ROMELARD Fabrice

TECHDAYS PARIS 2012 : KINECT + OFFICE 365 UN BON GESTE POUR VOTRE SI par ROMELARD Fabrice

TECHDAYS PARIS 2012 : PLEINIèRE DU PREMIER JOUR par ROMELARD Fabrice

Forum

PYVISA PROBLèME par sandrine44

RE : TUTORIAUX PYTHON par MeTeC1

RE : MESSAGE SUR RESEAU par Guillamue06

RE : CRéER UN PETIT JEU DE SIMULATION POLITIQUE par Guillamue06

MESSAGE SUR RESEAU par sanhoua

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Application Smartphone
Budget : 4 100€
TRES URGENT - Mission de developpement et integration sous wordpress
Budget : 1 500€
TRES URGENT-Developpement d-un annuaire
Budget : 13 000€

Logiciels

Academy System (17.2.1.0)
ACADEMY SYSTEM (17.2.1.0)

Logiciel de gestion des établissements. - élèves/étudiants (inscription, dossier, absence...) -...

Cliquez pour télécharger Academy System
Easy-Planning (1.0.0.1)
EASY-PLANNING (1.0.0.1)

Basé sur les mêmes principes que MyPlanning, Easy-Planning permet de créer des plannings sous la ...

Cliquez pour télécharger Easy-Planning
COLLECTOR PLUS (3.00B)
COLLECTOR PLUS (3.00B)

COLLECTOR PLUS version 3.00B est un logiciel utilisant une base de données alimentée par : - L...

Cliquez pour télécharger COLLECTOR PLUS
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)

PONAMEDIA TV DEVIENS HELLLOOO FLASH LA TV SUR VOTRE ORDINATEUR. Toute une plateforme Multi...

Cliquez pour télécharger PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO
LettresFaciles 2011 (8.0.0.1)
LETTRESFACILES 2011 (8.0.0.1)

LettresFaciles est un logiciel facilitant la création et la rédaction de lettres types. Son inte...

Cliquez pour télécharger LettresFaciles 2011