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

Ce site au démarrage

begin process at 2010 07 29 16:06:23

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é :1 748 / 93

Auteur : calogerogigante

Ecrire un message privé

Site perso

Commentaire sur cette source (8)

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

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

RENOMMEUR DE FICHIERS PAR LOTS par yveslc

POKER : ANALYSE DES MAINS ET DES RÉSULTATS DE TOURNOIS POUR ... par guillaume_pays_cevenol

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

Sources en rapport avec celle ci

CASSE BRIQUE par elnabo

EQUATION STANDARD DE LA DROITE par calogerogigante

I.A. (DÉBUTANT) par Rano Its

DESSIN DE DÉS À ÉCHELLE VARIABLE SUR CANVAS 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

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

[WP7] AJOUTER DES IMAGES DANS LA MEDIA LIBRARY D'UN WINDOWS PHONE 7 par Audrey

VIVE LES MOCKS ET LES POCOS par vLabz

[WF4] WORKFLOW AND CUSTOM ACTIVITIES - BEST PRACTICES (4/5) par JeremyJeanson

DéVELOPPEMENT MOBILE : .NET COMPACT FRAMEWORK & LIMITATIONS par Pi-R

IPHONE VERSUS WP7 CODING par Nicolas

Forum

RE : CRéER UNE SIMULATION D'UN JEU DE CARTES par jimux06

RE : SQLITE + TKINTER par Mic92

SQLITE + TKINTER par Mic92

RE : CRéER UNE SIMULATION D'UN JEU DE CARTES par aera group

GPS, SONDEUR, TRAME NMEA par Pedro855

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Modifications site institutionnel EZ Publish - republication
Budget : 2 000€
Realisations videos publicite Commerces France
Budget : 200 000€
Realisation emailing
Budget : 150€

Logiciels

Xilisoft HD Vidéo Convertisseur 6 (6.0.3.0421)
XILISOFT HD VIDéO CONVERTISSEUR 6 (6.0.3.0421)

Xilisoft HD Vidéo Convertisseur est un outil professionnel de conversion HDTV, conçu pour transfo...

Cliquez pour télécharger Xilisoft HD Vidéo Convertisseur 6
Xilisoft MP4 Convertisseur 6 (6.0.2.0415)
XILISOFT MP4 CONVERTISSEUR 6 (6.0.2.0415)

Xilisoft MP4 Convertisseur est un outil puissant pour la conversion de vidéo MP4, qui peut conver...

Cliquez pour télécharger Xilisoft MP4 Convertisseur 6
Vade Retro Desktop (3.03)
VADE RETRO DESKTOP (3.03)

Le logiciel antispam Vade Retro pour Microsoft Outlook®, Outlook Express® et Windows Mail®(Vista)...

Cliquez pour télécharger Vade Retro Desktop
Malwarebytes Anti Malwares (1.46)
MALWAREBYTES ANTI MALWARES (1.46)

Malwarebytes' Anti-Malware est un anti-malware qui peut éliminer même les plus avancés des logic...

Cliquez pour télécharger Malwarebytes Anti Malwares
Axalot, logiciel de sauvegarde de données en ligne (1.1.4.3.)
AXALOT, LOGICIEL DE SAUVEGARDE DE DONNéES EN LIGNE (1.1.4.3.)

Perdre tout le contenu de votre disque dur, vous imaginez ? Vos photos, vos musiques, votre compt...

Cliquez pour télécharger Axalot, logiciel de sauvegarde de données en ligne