ISN, passe ton FAQ !

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

# les coords du point marginal
x,y=(3,30)
import tkinter
e2,b1=e3,e6=(x,y-12)# coord du dehors dedans
from tkinter import *
e1=fen1=b6=x,y,e2
fen3 = Tk()# programe ki ser de l'aff conversion
e1=b2=e6=fen3.title # pour ke l'aff c mieux
x,y,z,n=3.14,-125,1.45**2,32//14
Label(fen3,
text="Veuillez saisir un entier décimal, SVP :"
).pack(pady=5,
padx=10)
af4 = e6=Entry(fen3);e6.pack(# sinon il est nonne
padx=10)
import tkinter
def af3(*y,z=0):
    global x,n,af3,af1,af6,n
    try:
        c6=y+(z**2,z/x-n*x,3.25) # pour centré le point
        e3.config(
            text=bin(   # c la conv du bin en entier
        int(
                e6.get(
        ))))
    # on fé l'exception
    except:
        from tkinter import Label
        if '*/+-=axzbf^@' or z-len(y) and af4:
            e3.config(text='error')
af6=e2=Label(fen3)
e3 =Label(fen3);e3.pack(
pady=5, padx=10) # input utilizater
af4=Button(fen3,
text="Convertir",
command=af3).pack(side=LEFT,
pady=10,padx=30);af6=Button(fen3, text="Quitter",
command=fen3.destroy).pack(
side=RIGHT, pady=10,
padx=10)
fen3.mainloop()#fontion principal

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

# on utilise la librairie graphique tkinter

from tkinter import *

# zone de déclaration de fonctions

def convertir ():
    """
        cette fonction convertit un nombre décimal entier en séquence
        binaire de 0 et de 1, puis affiche le résultat;
        si les données entrées ne sont pas correctes, le résultat
        affichera 'error';
    """
    # on récupère les données saisies par l'utilisateur
    sequence = entree.get()

    # on essaie de faire la conversion en séquence binaire
    try:
        # conversion d'un entier en séquence binaire
        resultat = bin(int(sequence))
    # si une erreur survient
    except:
        # on affiche 'error' à la place
        resultat = 'error'
    # end try

    # affichage du résultat
    cvar_resultat.set(resultat)

# end def

# programme principal (GUI - interface graphique utilisateur)

# on crée une fenêtre principale
fenetre = Tk()

# on ajoute des composants graphiques

# étiquette texte à afficher
Label(fenetre, text="Veuillez saisir un entier décimal, SVP :").pack(pady=5, padx=10)

# zone de texte pour la saisie des données entrées par l'utilisateur
entree = Entry(fenetre)
entree.pack(padx=10)

# on va utiliser une variable de contrôle pour afficher un résultat
# variable selon les calculs de conversion que l'on va effectuer
# ultérieurement
cvar_resultat = StringVar()

# on rattache cette variable de contrôle à une étiquette texte afin
# de pouvoir afficher ses données en sortie visuelle
Label(fenetre, textvariable=cvar_resultat).pack(pady=5, padx=10)

# il ne nous reste plus qu'à utiliser un bouton cliquable pour
# déclencher l'opération de conversion du nombre en séquence binaire
# de 0 et de 1
Button(fenetre, text="Convertir", command=convertir).pack(side=LEFT, pady=10, padx=30)

# ainsi qu'un bouton cliquable pour quitter notre application
Button(fenetre, text="Quitter", command=fenetre.destroy).pack(side=RIGHT, pady=10, padx=10)

# pour finir, on lance l'application graphique en entrant dans la
# boucle événementielle principale
fenetre.mainloop()

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

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

python mon_script.py

python3 mon_script.py

./mon_script.py

py mon_script.py

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

from __future__ import unicode_literals

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

from __future__ import unicode_literals

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

a = 0

x,y = (10, 20   # l'erreur se trouve ici (parenthèse fermante manquante)

z = 2**3 + 10*2.35 - 45//89

  File "./forum.py", line 8
    z = 2**3 + 10*2.35 - 45//89
    ^
SyntaxError: invalid syntax

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

def f(x):

    print a     # d'où sort ce 'a' ? vouliez-vous dire 'x' plutôt ?

# end def

# début du programme

f(0)

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

def f(x):

    print a     # appel à une variable globale 'a' en lecture seule

# end def

# début du programme

a = 0   # on définit 'a' dès le départ

# on appelle ensuite seulement la fonction
f(0)

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

def f(x):
    if x % 4 == 0:
        a = 10.584
    elif x % 4 == 1:
        a = 12.352
    elif x % 4 == 2:
        a = 24.689
    elif x % 4 == 3:
        a = 39.547
    # end if
    # on retourne le résultat de notre traitement
    return a
# end def

# test

x = 100.235

print "ajustement de la valeur de %f : %f" % (x, f(x))

Traceback (most recent call last):
  File "./forum.py", line 22, in <module>
    print "ajustement de la valeur de %f : %f" % (x, f(x))
  File "./forum.py", line 15, in f
    return a
UnboundLocalError: local variable 'a' referenced before assignment

>>> 100 % 4
0
>>> 100 % 4 == 0
True
>>> 100.235 % 4
0.23499999999999943
>>> 100.235 % 4 == 0
False
>>> 100.235 % 4 == 1
False

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

def f(x):
    # on force 'x' à n'être qu'un entier
    x = int(x)
    # et le reste devrait suivre...
    if x % 4 == 0:
        a = 10.584
    elif x % 4 == 1:
        a = 12.352
    elif x % 4 == 2:
        a = 24.689
    elif x % 4 == 3:
        a = 39.547
    # end if
    # on retourne le résultat de notre traitement
    return a
# end def

# test

x = 100.235

print "ajustement de la valeur de %f : %f" % (x, f(x))

ajustement de la valeur de 100.235000 : 10.584000

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

def f(x):
    # à quoi bon écrire autant de lignes ?
    return (10.584, 12.352, 24.689, 39.547)[int(x) % 4]
# end def

# test

x = 100.235

print "ajustement de la valeur de %f : %f" % (x, f(x))

ajustement de la valeur de 100.235000 : 10.584000

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

def f(x):
    # ici ON NE PEUT PAS modifier notre variable globale
    if x > 5:
        ma_variable = 1 # Python SUPPOSE que c'est une variable LOCALE
# end def

def g(x):
    global ma_variable  # ici ON PEUT modifier notre variable globale
    if x > 5:
        ma_variable = 1 # Python SAIT que c'est une variable globale
# end def

# début du programme

ma_variable = 250
f(1)
print("f(1):\t ma_variable =", ma_variable)
f(10)
print("f(10):\t ma_variable =", ma_variable)
g(1)
print("g(1):\t ma_variable =", ma_variable)
g(10)
print("g(10):\t ma_variable =", ma_variable)

f(1):     ma_variable = 250
f(10):     ma_variable = 250
g(1):     ma_variable = 250
g(10):     ma_variable = 1

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

def f(x):
    # init variables GLOBALES
    global a, b, c, d, e
    # init variables LOCALES
    y = a * x + b
    z = c * x**2 + d * y**2 - e**2
    # on modifie quelques globales
    # pour le prochain appel de f(x)
    a = b // 2
    c = e + d
    b = a * c // e
    d = c // (b + 1)
    # résultat du calcul
    return (x, y, z)
# end def

# début du programme

# init variables globales
a = 10
b = 20
c = 12
d = 14
e = 200

# init test
x = 30

# boucle essais
for i in range(10):
    print("Pour x = {}, coordonnées (x, y, z) = {}".format(x, f(x)))
# end for

# fin du programme

Pour x = 30, coordonnées (x, y, z) = (30, 320, 1404400)
Pour x = 30, coordonnées (x, y, z) = (30, 310, 1978500)
Pour x = 30, coordonnées (x, y, z) = (30, 155, 1022000)
Pour x = 30, coordonnées (x, y, z) = (30, 62, 472232)
Pour x = 30, coordonnées (x, y, z) = (30, 31, 343779)
Pour x = 30, coordonnées (x, y, z) = (30, 0, 265100)
Pour x = 30, coordonnées (x, y, z) = (30, 0, 445100)
Pour x = 30, coordonnées (x, y, z) = (30, 0, 625100)
Pour x = 30, coordonnées (x, y, z) = (30, 0, 805100)
Pour x = 30, coordonnées (x, y, z) = (30, 0, 985100)

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

def debut_programme ():
    # init variables GLOBALES
    global fenetre, canvas, bouton_jouer, bouton_quitter
    # on crée la fenêtre principale
    fenetre = Tk()
    fenetre.title("Mon premier programme !")
    fenetre.resizable(width=False, height=False)
    # on lui ajoute des composants graphiques
    canvas = Canvas(fenetre, bg="sky blue", width=320, height=240)
    canvas.pack(padx=10, pady=10)
    bouton_jouer = Button(fenetre, text="Jouer !", command=lancer_jeu)
    bouton_jouer.pack(side=LEFT, padx=10, pady=5)
    bouton_quitter = Button(fenetre, text="Quitter", command=fenetre.destroy)
    bouton_quitter.pack(side=RIGHT, padx=10, pady=5)
    # on initialise les données du jeu
    initialiser_jeu()
    # boucle événementielle principale
    fenetre.mainloop()
# end def

def initialiser_jeu ():
    # initialisation des données du jeu
    # ici, on ne modifie pas la variable canvas
    # ON L'UTILISE, nuance...
    # on efface le canevas
    canvas.delete(ALL)
    # nouveau texte...
    canvas.create_text(
        160, 120,
        anchor=CENTER,
        text="Mon super jeu !",
        font="sans 16 bold",
        fill="yellow",
    )
# end def

def lancer_jeu ():
    # on lance une nouvelle partie ici
    # on désactive le bouton 'jouer'
    # on le réactivera en fin de partie
    bouton_jouer.configure(state=DISABLED)
    # on efface le canevas
    canvas.delete(ALL)
    # on change la couleur du fond
    canvas.configure(background="gold")
    # nouveau texte...
    canvas.create_text(
        160, 120,
        anchor=CENTER,
        text="Début de la partie...",
        font="sans 14 bold",
        fill="coral",
    )
# end def

if __name__ == "__main__":
    # début du programme
    debut_programme()
# end if

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

def f(x):   # <-- notre fonction s'appelle f !
    # init variables GLOBALES
    global f, g, h
    # init variables LOCALES
    y = f * x + g   # on utilise une variable globale f ou une fonction f ?
    z = h * x + y
    # on modifie quelques globales
    # pour le prochain appel de f(x)
    f = f + 2   # idem ici: globale f ou fonction f ?
    g = g * 3
    h = h - 5
    # résultat du calcul
    return (x, y, z)
# end def

# début du programme

# init variables globales
f = 4   # collision ! on a déjà une fonction qui s'appelle f !
g = 10
h = 12

# init test
x = 30

# boucle essais
for i in range(10):
    print "Pour x = %d, coordonnées (x, y, z) = %s" % (x, f(x)) # boum !
# end for

# fin du programme

Traceback (most recent call last):
  File "./forum.py", line 31, in <module>
    print "Pour x = %d, coordonnées (x, y, z) = %s" % (x, f(x)) # boum !
TypeError: 'int' object is not callable

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

import timeit

def factorielle (n):
    # n doit être un entier naturel
    n = abs(int(n))
    # valeur par défaut
    # 0! = 1! = 1
    resultat = 1
    # on ne traite qu'à partir de n = 2, 3, 4, ...
    if n > 1:
        for i in range(2, n + 1):
            resultat = resultat * i
        # end for
    # end if
    return resultat
# end def

def test ():
    for n in range(10):
        print("{}! = {}".format(n, factorielle(n)))
    # end for
# end def

# test

print(timeit.timeit(test, number=1))

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
0.000202894210815

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

import timeit

def factorielle (n):
    # n doit être un entier naturel
    n = abs(int(n))
    # si n < 2 on retourne 1 puisque 0! = 1! = 1
    if n < 2: return 1
    # on utilise la récursivité (la fonction s'appelle elle-même)
    return n * factorielle(n - 1)
# end def

def test ():
    for n in range(10):
        print("{}! = {}".format(n, factorielle(n)))
    # end for
# end def

# test

print(timeit.timeit(test, number=1))

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
0.000239133834839

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

import timeit

def iterative_factorielle (n):
    # n doit être un entier naturel
    n = abs(int(n))
    # valeur par défaut
    # 0! = 1! = 1
    resultat = 1
    # on ne traite qu'à partir de n = 2, 3, 4, ...
    if n > 1:
        for i in range(2, n + 1):
            resultat = resultat * i
        # end for
    # end if
    return resultat
# end def

def recursive_factorielle (n):
    # n doit être un entier naturel
    n = abs(int(n))
    # si n < 2 on retourne 1 puisque 0! = 1! = 1
    if n < 2: return 1
    # on utilise la récursivité (la fonction s'appelle elle-même)
    return n * recursive_factorielle(n - 1)
# end def

def test_iterative ():
    for n in range(debut, fin):
        iterative_factorielle(n)
    # end for
# end def

def test_recursive ():
    for n in range(debut, fin):
        recursive_factorielle(n)
    # end for
# end def

# tests

debut = 980
fin = debut + 10

boucles = 1000

print("calculs de factorielles de {}! à {}!".format(debut, fin))
print("sur un échantillon statistique de {} boucles :".format(boucles))
print("\ncalculs avec iterative_factorielle(n)...")

test1 = timeit.timeit(test_iterative, number=boucles)

print("total temps iterative : {} s".format(test1))
print("\ncalculs avec recursive_factorielle(n)...")

test2 = timeit.timeit(test_recursive, number=boucles)

print("total temps recursive : {} s".format(test2))
print("\nécart recursive - iterative : {:0.6f} s".format(test2 - test1))

calculs de factorielles de 980! à 990!
sur un échantillon statistique de 1000 boucles :

calculs avec iterative_factorielle(n)...
total temps iterative : 2.74929011399945 s

calculs avec recursive_factorielle(n)...
total temps recursive : 5.866635123000378 s

écart recursive - iterative : 3.117345 s

  File "./forum.py", line 27, in recursive_factorielle
    return n * recursive_factorielle(n - 1)
  File "./forum.py", line 23, in recursive_factorielle
    n = abs(int(n))
RuntimeError: maximum recursion depth exceeded while calling a Python object

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

fenetre = Tk()

# mettez ici tout le code dont vous avez besoin

Label(fenetre, text="Essai fenêtre").pack(pady=20, padx=10)

Button(fenetre, text="Quitter", command=fenetre.destroy).pack(pady=5)

# /!\ n'oubliez pas de finir avec la boucle principale /!\

fenetre.mainloop()

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

fenetre = Tk()

# mettez ici tout le code dont vous avez besoin

Label(fenetre, text="Essai fenêtre").pack(pady=20, padx=10)

Button(fenetre, text="Quitter", command=fenetre.destroy).pack(pady=5)

# /!\ n'oubliez pas de finir avec la boucle principale /!\

fenetre.mainloop()

# ce code ne s'exécutera que lorsque la fenêtre principale sera fermée

print("fin du programme")

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

def nouvelle_fenetre ():
    """
        cette fonction crée une nouvelle fenêtre fille à chaque fois
        qu'on clique sur le bouton correspondant
    """

    global fenetre_fille

    # ceci est une fenêtre fille (Toplevel)
    # elle sera automatiquement détruite lorsque vous quitterez le
    # programme en fermant la fenêtre principale

    fenetre_fille = Toplevel()

    Label(fenetre_fille, text="Hello good people!").pack(pady=20, padx=10)

    Button(fenetre_fille, text="Quitter", command=fenetre_fille.destroy).pack(pady=5)

# end def

# ceci est la fenêtre principale du programme (Tk)

fenetre = Tk()

fenetre.title("Fenêtre principale")

# mettez ici tout le code dont vous avez besoin

Label(fenetre, text="Cliquez sur le bouton").pack(pady=20, padx=10)

Button(fenetre, text="Nouvelle fenêtre fille", command=nouvelle_fenetre).pack(pady=5, padx=10)

Button(fenetre, text="Quitter", command=fenetre.destroy).pack(pady=5)

# /!\ n'oubliez pas de finir avec la boucle principale /!\

fenetre.mainloop()

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

import Tkinter
import ttk
import Tix
import tkFont
import ScrolledText
import tkMessageBox
import tkFileDialog
import tkSimpleDialog
import tkCommonDialog
import tkColorChooser

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

import tkinter
import tkinter.ttk
import tkinter.tix
import tkinter.font
import tkinter.scrolledtext
import tkinter.messagebox
import tkinter.filedialog
import tkinter.simpledialog
import tkinter.commondialog
import tkinter.colorchooser

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

fenetre = Tk()

# voici l'erreur LA PLUS RÉPANDUE QUI SOIT chez les débutants tkinter :

canvas = Canvas(fenetre, bg="ivory", height=50).pack() # <-- pack() retourne None donc canvas = None

print("canvas =", repr(canvas))

# il faut d'abord déclarer l'objet

canvas = Canvas(fenetre, bg="sky blue", height=50)

# ensuite seulement appliquer .pack()

canvas.pack()

print("canvas =", repr(canvas))

btn_quitter = Button(fenetre, text="Quitter", command=fenetre.destroy)

btn_quitter.pack()

print("btn_quitter =", repr(btn_quitter))

fenetre.mainloop()

canvas = None
canvas = <tkinter.Canvas object at 0x7f3550ad8d68>
btn_quitter = <tkinter.Button object at 0x7f3550ad8dd8>

canvas = Canvas(fenetre).pack()

canvas = Canvas(fenetre)   # on crée l'objet et on l'assigne à canvas
canvas.pack()              # on appelle pack() une fois que canvas est correctement initialisé /!\

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

from tkinter import *

print("Tcl version:", TclVersion)

fenetre = Tk()

Label(fenetre, text="widget.pack()").pack()
Label(fenetre, text="widget.grid()").grid()
Label(fenetre, text="widget.place()").place()

fenetre.mainloop()

Tcl version: 8.6
Traceback (most recent call last):
  File "./forum.py", line 11, in <module>
    Label(fenetre, text="widget.grid()").grid()
  File "/usr/lib/python3.4/tkinter/__init__.py", line 2023, in grid_configure
    + self._options(cnf, kw))
_tkinter.TclError: cannot use geometry manager grid inside . which already has slaves managed by pack

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

# on crée la fenêtre principale
fenetre = Tk()
fenetre.resizable(width=False, height=False)

# on crée un conteneur A
conteneur_A = Frame(fenetre)
conteneur_A.pack()

# on ajoute des widgets à A
Label(conteneur_A, text="Je suis dans A et j'utilise pack()").pack(padx=5, pady=5)
Label(conteneur_A, text="Moi aussi ! dans A et j'utilise pack()").pack(padx=5, pady=5)

# on ajoute aussi un conteneur B dans A
conteneur_B = Frame(conteneur_A)
conteneur_B.pack(padx=5, pady=5)

Button(
    conteneur_A,
    text="Je suis dans A et j'utilise pack()",
    command=fenetre.destroy,
).pack(padx=5, pady=5)

# maintenant, on ajoute des widgets à B
canvas = Canvas(conteneur_B, bg="white", width=300, height=200)
canvas.create_text(150, 100, text="Je suis dans B et j'utilise grid()")
hbar = Scrollbar(conteneur_B, orient=HORIZONTAL)
vbar = Scrollbar(conteneur_B, orient=VERTICAL)

# on décide de les placer avec grid()
canvas.grid(row=0, column=0, sticky=NW+SE)
hbar.grid(row=1, column=0, sticky=EW)
vbar.grid(row=0, column=1, sticky=NS)

# boucle principale programme
fenetre.mainloop()

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

def convertir ():
    resultat.set(bin(int(entree.get())))
# end def

fenetre = Tk()
Label(fenetre, text="Entrez un nombre entier:").pack()
entree = Entry(fenetre)
entree.pack()
Label(fenetre, text="Résultat de la conversion:").pack()
resultat = StringVar()
Label(fenetre, textvariable=resultat).pack()

# command=callback attend un NOM de fonction
# et NON PAS la valeur retour d'une fonction

Button(fenetre, text="Convertir", command=convertir()).pack() # ERREUR!

# remplacez par :

Button(fenetre, text="Convertir", command=convertir).pack() # CORRECT

fenetre.mainloop()

Traceback (most recent call last):
  File "./forum.py", line 21, in <module>
    Button(fenetre, text="Convertir", command=convertir()).pack() # ERREUR!
  File "./forum.py", line 7, in convertir
    resultat.set(bin(int(entree.get())))
ValueError: invalid literal for int() with base 10: ''

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

def somme (a, b):
    """
        cette fonction retourne la somme de a et b;
    """
    return a + b
# end def

def produit (a, b):
    """
        cette fonction retourne le produit de a par b;
    """
    return a * b
# end def

def formule (a, b):
    """
        cette fonction applique une formule à a et b;
        vous aurez reconnu ici le calcul de l'hypoténuse;
    """
    return (a**2 + b**2)**0.5
# end def

def traiter_liste (callback, liste):
    """
        cette fonction parcourt les éléments d'une liste puis
        délègue le traitement spécifique à une fonction de rappel
        dite 'callback' capable de traiter deux arguments (a, b)
        puis de retourner à son tour une valeur unique; la fonction
        réduit successivement la liste à une seule valeur finale au
        fur et à mesure des résultats obtenus aux itérations
        précédentes;
    """
    # on crée un itérateur pour parcourir la liste
    iterator = iter(liste)
    # on essaie de récupérer la première valeur (si existe)
    try:
        resultat = next(iterator)
    # la liste est vide !
    except StopIteration:
        raise IndexError("impossible de traiter une liste vide")
        return None
    # end try
    # on peut parcourir la liste, à présent:
    for item in iterator:
        # c'est ici qu'on délègue le traitement à la fonction de rappel
        # la fonction doit accepter 2 arguments a et b i.e. callback(a, b)
        resultat = callback(resultat, item)
    # end for
    # on retourne le résultat
    return resultat
# end def

# maintenant, testons...
ma_liste = [1, 3, 56, 89, 4, 12, 45, 87, 10, 2, 4, 3, 3, 3, 5]

# annonce
print("pour ma_liste = ", ma_liste)

# faisons la somme de tous les termes de ma_liste:
print("somme de ma_liste = ", traiter_liste(somme, ma_liste))

# calculons le produit de tous les termes de ma_liste:
print("produit de ma_liste = ", traiter_liste(produit, ma_liste))

# appliquons une formule à tous les termes de ma_liste:
print("formule de ma_liste = ", traiter_liste(formule, ma_liste))

# fin du test

pour ma_liste =  [1, 3, 56, 89, 4, 12, 45, 87, 10, 2, 4, 3, 3, 3, 5]
somme de ma_liste =  327
produit de ma_liste =  30345622272000
formule de ma_liste =  144.88961315429069

def compter ():
    # on efface la sortie console
    display.delete("1.0", END)
    # et on compte...
    for i in range(10):
        # petit message censé s'afficher PENDANT le comptage...
        display.insert(END, "valeur actuelle : {}\n".format(i))
        # on marque une pause exprès...
        time.sleep(0.200)
    # end for
# end def

def compter ():
    # on désactive le bouton 'compter'
    bouton_compter.configure(state=DISABLED)
    # on efface la sortie console
    display.delete("1.0", END)
    # et on compte...
    boucle_tkinter(0, 10)
# end def

def boucle_tkinter (debut, fin):
    # petit message censé s'afficher PENDANT le comptage...
    display.insert(END, "valeur actuelle : {}\n".format(debut))
    # màj données
    debut += 1
    # on étale dans le temps avec w.after()
    if debut < fin:
        # on marque une pause exprès...
        fenetre.after(200, boucle_tkinter, debut, fin)
    # c'est fini
    else:
        # on réactive le bouton 'compter'
        bouton_compter.configure(state=NORMAL)
    # end if
# end def

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

import time
from tkinter import *

# on force la mise à jour de l'affichage des widgets dans le cas ici
# présent avec w.update_idletasks() (à utiliser avec parcimonie)
def compter ():
    # on désactive le bouton 'compter'
    bouton_compter.configure(state=DISABLED)
    # on efface la sortie console
    display.delete("1.0", END)
    # et on compte...
    for i in range(10):
        # petit message censé s'afficher PENDANT le comptage...
        display.insert(END, "valeur actuelle : {}\n".format(i))
        # on force la màj affichage des widgets
        fenetre.update_idletasks()
        # on marque une pause exprès...
        time.sleep(0.2)
    # end for
    # c'est fini
    # on réactive le bouton 'compter'
    bouton_compter.configure(state=NORMAL)
# end def

# on crée la fenêtre principale
fenetre = Tk()
fenetre.title("Test de freeze")
fenetre.resizable(width=False, height=False)

# on ajoute des widgets
display = Text(
    fenetre,
    bg="black",
    fg="pale green",
    font="monospace 12 bold",
    width=40,
    height=10,
)
display.pack(padx=5, pady=5)

# on ajoute un bouton 'compter'
bouton_compter = Button(fenetre, text="Compter...", command=compter)
bouton_compter.pack(side=LEFT, padx=10, pady=5)

# on ajoute un bouton 'quitter'
bouton_quitter = Button(fenetre, text="Quitter", command=fenetre.destroy)
bouton_quitter.pack(side=RIGHT, padx=5, pady=5)

# on lance la boucle principale
fenetre.mainloop()

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

# la fonction délègue le comptage à une boucle tkinter
def compter ():
    # on désactive le bouton 'compter'
    bouton_compter.configure(state=DISABLED)
    # on efface la sortie console
    display.delete("1.0", END)
    # et on compte...
    boucle_tkinter(0, 10)
# end def

def boucle_tkinter (debut, fin):
    # petit message censé s'afficher PENDANT le comptage...
    display.insert(END, "valeur actuelle : {}\n".format(debut))
    # màj données
    debut += 1
    # on étale dans le temps avec w.after()
    if debut < fin:
        # on marque une pause exprès...
        fenetre.after(200, boucle_tkinter, debut, fin)
    # c'est fini
    else:
        # on réactive le bouton 'compter'
        bouton_compter.configure(state=NORMAL)
    # end if
# end def

# on crée la fenêtre principale
fenetre = Tk()
fenetre.title("Test de freeze")
fenetre.resizable(width=False, height=False)

# on ajoute des widgets
display = Text(
    fenetre,
    bg="black",
    fg="pale green",
    font="monospace 12 bold",
    width=40,
    height=10,
)
display.pack(padx=5, pady=5)

# on ajoute un bouton 'compter'
bouton_compter = Button(fenetre, text="Compter...", command=compter)
bouton_compter.pack(side=LEFT, padx=10, pady=5)

# on ajoute un bouton 'quitter'
bouton_quitter = Button(fenetre, text="Quitter", command=fenetre.destroy)
bouton_quitter.pack(side=RIGHT, padx=5, pady=5)

# on lance la boucle principale
fenetre.mainloop()

def boucle_joueur ():
    "boucle temporelle qui gère les mouvements du joueur"
    # init variables globales
    global boule_x, boule_y
    global tid_joueur
    # le joueur a atteint le carré final ?
    if carre_x - demi_carre < boule_x < carre_x + demi_carre and \
            carre_y - demi_carre < boule_y < carre_y + demi_carre:
        # bravo ! c'est gagné !
        return bravo()
    # end if
    # on recherche des collisions
    collisions = canvas.find_overlapping(*canvas.bbox(boule_joueur))
    # le joueur a heurté autre chose que le carré final ?
    if len(collisions) > 1 and carre_final not in collisions:
        # aïe ! dommage !
        return game_over()
    # end if
    # tout est OK on déplace le joueur
    boule_x = (boule_x + sens_x * pas) % c_width
    boule_y = (boule_y + sens_y * pas) % c_height
    canvas.coords(
        boule_joueur,
        boule_x - rayon, boule_y - rayon,
        boule_x + rayon, boule_y + rayon,
    )
    # on boucle à nouveau dans le temps
    tid_joueur = fenetre.after(50, boucle_joueur)
# end def

def boucle_mines ():
    "boucle temporelle qui gère la vie des mines"
    # init variables globales
    global tid_mines
    # on pose une mine de temps en temps
    poser_mine()
    # prochaine mine dans... (millisecondes)
    delai = random.randint(1000, 2000)
    # on relance la boucle après ce délai
    tid_mines = fenetre.after(delai, boucle_mines)
# end def

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

# logiciel pour Python2

# (c) 2014 Raphaël SEBAN (tarball69)
# publié sous licence GNU General Public License GPLv3
# cf http://www.gnu.org/licenses/gpl.html

# on demande en premier lieu
# la librairie graphique Tkinter
from Tkinter import *

# on veut aussi utiliser
# les nombres aléatoires
import random

# ------------------- DEBUT DU PROGRAMME -------------------------------

def debut_jeu ():
    "le programme commence ici"
    # init variables globales
    global fenetre, canvas, bouton_jouer
    global c_width, c_height, center_x, center_y
    # on crée la fenêtre principale
    fenetre = Tk()
    fenetre.title("Mon super jeu !")
    fenetre.resizable(width=False, height=False)
    # on ajoute des composants graphiques
    canvas = Canvas(fenetre, bg="black", width=400, height=300)
    canvas.pack(padx=5, pady=5)
    # on met des données courantes en globales
    c_width = canvas.winfo_reqwidth()
    c_height = canvas.winfo_reqheight()
    center_x = c_width // 2
    center_y = c_height // 2
    # bouton 'jouer'
    bouton_jouer = Button(fenetre)
    bouton_jouer.pack(side=LEFT, padx=50, pady=5)
    # bouton 'quitter'
    Button(
        fenetre, text="Quitter", command=fenetre.destroy
    ).pack(side=RIGHT, padx=5, pady=5)
    # on affiche une présentation du jeu
    presenter_jeu()
    # et on lance la
    # boucle événementielle principale
    fenetre.mainloop()
# end def

def presenter_jeu ():
    "on affiche ici une présentation du jeu"
    # on commence toujours par effacer le canevas graphique
    # qui nous fait office d'écran de jeu
    canvas.delete(ALL)
    # on affiche un titre
    # par rapport au centre de l'écran de jeu
    canvas.create_text(
        center_x, center_y - 100,
        text="Terrain miné",
        font="sans 16 bold",
        fill="navajowhite2",        # couleur du texte
    )
    # on affiche des règles du jeu succinctes
    canvas.create_text(
        center_x, center_y + 30,
        text="""\
Règles du jeu:

Vous devez déplacer une grosse boule vers un carré placé en bas de l'écran.
Malheureusement pour vous, le terrain est miné !
Saurez-vous atteindre votre but sans vous faire exploser ?
Utilisez les flèches du clavier pour vous déplacer.
        """,
        justify=LEFT,
        font="sans 10 bold italic",
        fill="Pale Goldenrod",
        width=0.8 * c_width,        # 80% de la largeur totale
    )
    # on s'assure que le joueur pourra (re)jouer
    bouton_jouer.configure(
        text="Jouer !", command=nouvelle_partie, state=NORMAL
    )
# end def

def nouvelle_partie ():
    "on réinitialise une nouvelle partie ici"
    # init variables globales
    global tid_joueur, tid_mines
    # on autorise le joueur à arrêter la partie quand il le souhaite
    bouton_jouer.configure(
        text="Stop !", command=arreter_partie, state=NORMAL
    )
    # on efface le canevas graphique
    canvas.delete(ALL)
    # on crée l'avatar du joueur (boule)
    creer_joueur()
    # on crée le carré d'arrivée
    creer_carre_final()
    # on mine le terrain
    miner_terrain()
    # on associe les touches fléchées du clavier
    # à nos propres fonctions de gestion du mouvement
    fenetre.bind_all("<Up>", deplacer_haut)
    fenetre.bind_all("<Down>", deplacer_bas)
    fenetre.bind_all("<Left>", deplacer_gauche)
    fenetre.bind_all("<Right>", deplacer_droite)
    # c'est ici qu'on lance les boucles inscrites dans le temps
    tid_joueur = fenetre.after(100, boucle_joueur)
    # les mines aussi vont avoir leur propre cycle de vie
    tid_mines = fenetre.after(1000, boucle_mines)
# end def

def creer_joueur ():
    """
        on crée l'avatar du joueur;
        ici le joueur est représenté par une grosse boule;
        on conserve l'identifiant de l'objet sur le canevas;
        ça nous servira plus tard;
        on prend des coordonnées au hasard;
    """
    # init variables globales
    global diametre_boule, rayon
    global boule_x, boule_y
    global sens_x, sens_y, pas
    global boule_joueur
    # inits
    diametre_boule = 20         # diamètre de la boule
    rayon = diametre_boule // 2
    boule_x = diametre_boule + random.randint(0, c_width - diametre_boule)
    boule_y = diametre_boule + random.randint(0, 10)
    sens_x, sens_y = (0, 0)     # sens de déplacement initial
    pas = random.randint(2, 5)  # quantité de déplacement (pixels)
    # on dessine l'avatar joueur (boule)
    boule_joueur = canvas.create_oval(
        boule_x - rayon, boule_y - rayon,
        boule_x + rayon, boule_y + rayon,
        outline="ivory2",       # couleur du contour
        width=1,                # épaisseur du trait de contour (pixels)
        fill="light sky blue",  # couleur du remplissage
    )
# end def

def creer_carre_final ():
    """
        on crée le carré final (carré d'arrivée);
        on conserve l'identifiant de l'objet sur le canevas;
        ça nous servira plus tard;
        on prend des coordonnées au hasard;
    """
    # init variables globales
    global taille_carre, demi_carre
    global carre_x, carre_y
    global carre_final
    # on crée le carré d'arrivée
    taille_carre = diametre_boule + 6
    demi_carre = taille_carre // 2
    carre_x = 10 + random.randint(0, c_width - taille_carre - 10)
    carre_y = c_height - taille_carre - random.randint(5, 20)
    # on dessine le carré final (arrivée)
    carre_final = canvas.create_rectangle(
        carre_x - demi_carre, carre_y - demi_carre,
        carre_x + demi_carre, carre_y + demi_carre,
        outline="ivory",        # couleur du contour
        width=1,                # épaisseur du trait de contour (pixels)
        fill="palegreen1",      # couleur du remplissage
    )
# end def

def miner_terrain ():
    "on mine le terrain au début d'une partie"
    # on choisit un nombre au hasard
    nombre_mines = random.randint(10, 20)
    # on boucle pour poser autant de mines
    for i in range(nombre_mines):
        # on pose une mine au hasard
        poser_mine()
    # end for
# end def

def poser_mine ():
    """
        on pose une mine au hasard, mais jamais dans le voisinage
        immédiat du joueur;
    """
    # init variables locales
    tailles = [8, 10, 12]
    couleurs = ["sandy brown", "peru", "sienna1", "coral1"]
    couleur_contour = "burlywood1"
    # on boucle tant que ce n'est pas bon
    # ici, on bouclera cent fois (par précaution)
    # et on abandonnera si on n'y arrive pas
    for i in range(100):
        # on choisit de nouvelles coordonnées au hasard
        mine_x = random.randint(0, c_width)
        mine_y = random.randint(0, c_height)
        # les mines ont une taille variable;
        taille_mine = random.choice(tailles)
        # on recherche les collisions avec d'autres objets
        collisions = canvas.find_overlapping(
            *b_rect(mine_x, mine_y, taille_mine)
        )
        # aucun objet dans le voisinage ?
        if not collisions:
            # on choisit une couleur parmi une palette
            color = random.choice(couleurs)
            # on peut poser notre mine !
            canvas.create_oval(
                b_rect(mine_x, mine_y, taille_mine//2),
                outline=couleur_contour,
                width=1,        # épaisseur de trait de contour (pixels)
                fill=color,     # couleur du remplissage
            )
            # on remonte la boule joueur
            # au premier plan d'affichage
            canvas.tag_raise(boule_joueur, ALL)
            # c'est bon, on a posé notre mine
            # on peut quitter la boucle
            break
        # end if
    # end for
# end def

def b_rect (x, y, size):
    """
        retourne les coordonnées (top, left, bottom, right) d'un
        rectangle de délimitation autour d'un point P(x, y);
    """
    # rectangle d'influence (bounding rectangle)
    return (x - size, y - size, x + size, y + size)
# end def

def boucle_joueur ():
    "boucle temporelle qui gère les mouvements du joueur"
    # init variables globales
    global boule_x, boule_y
    global tid_joueur
    # le joueur a atteint le carré final ?
    if carre_x - demi_carre < boule_x < carre_x + demi_carre and \
            carre_y - demi_carre < boule_y < carre_y + demi_carre:
        # bravo ! c'est gagné !
        return bravo()
    # end if
    # on recherche des collisions
    collisions = canvas.find_overlapping(*canvas.bbox(boule_joueur))
    # le joueur a heurté autre chose que le carré final ?
    if len(collisions) > 1 and carre_final not in collisions:
        # aïe ! dommage !
        return game_over()
    # end if
    # tout est OK on déplace le joueur
    boule_x = (boule_x + sens_x * pas) % c_width
    boule_y = (boule_y + sens_y * pas) % c_height
    canvas.coords(
        boule_joueur,
        boule_x - rayon, boule_y - rayon,
        boule_x + rayon, boule_y + rayon,
    )
    # on boucle à nouveau dans le temps
    tid_joueur = fenetre.after(50, boucle_joueur)
# end def

def boucle_mines ():
    "boucle temporelle qui gère la vie des mines"
    # init variables globales
    global tid_mines
    # on pose une mine de temps en temps
    poser_mine()
    # prochaine mine dans... (millisecondes)
    delai = random.randint(1000, 2000)
    # on relance la boucle après ce délai
    tid_mines = fenetre.after(delai, boucle_mines)
# end def

def bravo ():
    "super ! le joueur a réussi !"
    # on affiche l'écran final
    ecran_final(
        titre="BRAVO",
        sous_titre="C'est gagné !",
        couleur_titre="lemon chiffon",
        couleur_sous_titre="pale green",
    )
# end def

def game_over ():
    "c'est ballot ! le joueur a perdu !"
    # on affiche l'écran final
    ecran_final(
        titre="GAME OVER",
        sous_titre="C'est perdu !",
        couleur_titre="firebrick1",
        couleur_sous_titre="floral white",
    )
# end def

def arreter_partie ():
    "le joueur souhaite arrêter la partie"
    # on affiche l'écran final
    ecran_final(
        titre="ABANDON",
        sous_titre="Partie annulée !",
        couleur_titre="gold",
        couleur_sous_titre="light grey",
    )
# end def

def ecran_final (**kw):
    "on effectue ici des opérations communes à tous les écrans finaux"
    # on bloque les clics intempestifs sur le bouton 'jouer'
    bouton_jouer.configure(state=DISABLED)
    # on stoppe les boucles temporelles qui pourraient
    # éventuellement être encore en cours d'exécution
    arreter_boucles()
    # on efface le canevas graphique
    canvas.delete(ALL)
    # on récupère le titre et sa couleur
    titre = kw.get("titre") or ""
    couleur = kw.get("couleur_titre") or "white"
    # on affiche le titre
    canvas.create_text(
        center_x, center_y - 40,
        text=titre,
        font="sans 36 bold",
        fill=couleur,
    )
    # on récupère le sous-titre et sa couleur
    sous_titre = kw.get("sous_titre") or ""
    couleur = kw.get("couleur_sous_titre") or "white"
    # on affiche le sous-titre
    canvas.create_text(
        center_x, center_y,
        text=sous_titre,
        font="sans 16 bold italic",
        fill=couleur,
    )
    # on relance presenter_jeu() après @delai
    # avec toutefois un minimum de 1 seconde
    delai = kw.get("delai") or 2000     # valeur par défaut
    fenetre.after(max(1000, delai), presenter_jeu)
# end def

def arreter_boucles ():
    "on arrête les boucles temporelles susceptibles de tourner encore"
    # init variables globales
    global tid_joueur, tid_mines
    # stooop !
    fenetre.after_cancel(tid_joueur)
    fenetre.after_cancel(tid_mines)
    # RAZ thread ids
    tid_joueur = tid_mines = 0
# end def

def deplacer_haut (event=None):
    "on déplace l'avatar du joueur vers le haut"
    # init variables globales
    global sens_x, sens_y
    # grâce à la boucle du jeu,
    # nous n'avons pas besoin de plus que ça
    sens_x, sens_y = (0, -1)
# end def

def deplacer_bas (event=None):
    "on déplace l'avatar du joueur vers le bas"
    # init variables globales
    global sens_x, sens_y
    # grâce à la boucle du jeu,
    # nous n'avons pas besoin de plus que ça
    sens_x, sens_y = (0, 1)
# end def

def deplacer_gauche (event=None):
    "on déplace l'avatar du joueur vers la gauche"
    # init variables globales
    global sens_x, sens_y
    # grâce à la boucle du jeu,
    # nous n'avons pas besoin de plus que ça
    sens_x, sens_y = (-1, 0)
# end def

def deplacer_droite (event=None):
    "on déplace l'avatar du joueur vers la droite"
    # init variables globales
    global sens_x, sens_y
    # grâce à la boucle du jeu,
    # nous n'avons pas besoin de plus que ça
    sens_x, sens_y = (1, 0)
# end def

# ------------------- FIN DU PROGRAMME ---------------------------------

# ce script est automatiquement lancé grâce à ceci :

# /!\ à connaître par coeur /!\
if __name__ == "__main__":
    # lancer le programme
    debut_jeu()
# end if

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

# logiciel pour Python3

# (c) 2014 Raphaël SEBAN (tarball69)
# publié sous licence GNU General Public License GPLv3
# cf http://www.gnu.org/licenses/gpl.html

# on demande en premier lieu
# la librairie graphique Tkinter
from tkinter import *

# on veut aussi utiliser
# les nombres aléatoires
import random

# ------------------- DEBUT DU PROGRAMME -------------------------------

def debut_jeu ():
    "le programme commence ici"
    # init variables globales
    global fenetre, canvas, bouton_jouer
    global c_width, c_height, center_x, center_y
    # on crée la fenêtre principale
    fenetre = Tk()
    fenetre.title("Mon super jeu !")
    fenetre.resizable(width=False, height=False)
    # on ajoute des composants graphiques
    canvas = Canvas(fenetre, bg="black", width=400, height=300)
    canvas.pack(padx=5, pady=5)
    # on met des données courantes en globales
    c_width = canvas.winfo_reqwidth()
    c_height = canvas.winfo_reqheight()
    center_x = c_width // 2
    center_y = c_height // 2
    # bouton 'jouer'
    bouton_jouer = Button(fenetre)
    bouton_jouer.pack(side=LEFT, padx=50, pady=5)
    # bouton 'quitter'
    Button(
        fenetre, text="Quitter", command=fenetre.destroy
    ).pack(side=RIGHT, padx=5, pady=5)
    # on affiche une présentation du jeu
    presenter_jeu()
    # et on lance la
    # boucle événementielle principale
    fenetre.mainloop()
# end def

def presenter_jeu ():
    "on affiche ici une présentation du jeu"
    # on commence toujours par effacer le canevas graphique
    # qui nous fait office d'écran de jeu
    canvas.delete(ALL)
    # on affiche un titre
    # par rapport au centre de l'écran de jeu
    canvas.create_text(
        center_x, center_y - 100,
        text="Terrain miné",
        font="sans 16 bold",
        fill="navajowhite2",        # couleur du texte
    )
    # on affiche des règles du jeu succinctes
    canvas.create_text(
        center_x, center_y + 30,
        text="""\
Règles du jeu:

Vous devez déplacer une grosse boule vers un carré placé en bas de l'écran.
Malheureusement pour vous, le terrain est miné !
Saurez-vous atteindre votre but sans vous faire exploser ?
Utilisez les flèches du clavier pour vous déplacer.
        """,
        justify=LEFT,
        font="sans 10 bold italic",
        fill="Pale Goldenrod",
        width=0.8 * c_width,        # 80% de la largeur totale
    )
    # on s'assure que le joueur pourra (re)jouer
    bouton_jouer.configure(
        text="Jouer !", command=nouvelle_partie, state=NORMAL
    )
# end def

def nouvelle_partie ():
    "on réinitialise une nouvelle partie ici"
    # init variables globales
    global tid_joueur, tid_mines
    # on autorise le joueur à arrêter la partie quand il le souhaite
    bouton_jouer.configure(
        text="Stop !", command=arreter_partie, state=NORMAL
    )
    # on efface le canevas graphique
    canvas.delete(ALL)
    # on crée l'avatar du joueur (boule)
    creer_joueur()
    # on crée le carré d'arrivée
    creer_carre_final()
    # on mine le terrain
    miner_terrain()
    # on associe les touches fléchées du clavier
    # à nos propres fonctions de gestion du mouvement
    fenetre.bind_all("<Up>", deplacer_haut)
    fenetre.bind_all("<Down>", deplacer_bas)
    fenetre.bind_all("<Left>", deplacer_gauche)
    fenetre.bind_all("<Right>", deplacer_droite)
    # c'est ici qu'on lance les boucles inscrites dans le temps
    tid_joueur = fenetre.after(100, boucle_joueur)
    # les mines aussi vont avoir leur propre cycle de vie
    tid_mines = fenetre.after(1000, boucle_mines)
# end def

def creer_joueur ():
    """
        on crée l'avatar du joueur;
        ici le joueur est représenté par une grosse boule;
        on conserve l'identifiant de l'objet sur le canevas;
        ça nous servira plus tard;
        on prend des coordonnées au hasard;
    """
    # init variables globales
    global diametre_boule, rayon
    global boule_x, boule_y
    global sens_x, sens_y, pas
    global boule_joueur
    # inits
    diametre_boule = 20         # diamètre de la boule
    rayon = diametre_boule // 2
    boule_x = diametre_boule + random.randint(0, c_width - diametre_boule)
    boule_y = diametre_boule + random.randint(0, 10)
    sens_x, sens_y = (0, 0)     # sens de déplacement initial
    pas = random.randint(2, 5)  # quantité de déplacement (pixels)
    # on dessine l'avatar joueur (boule)
    boule_joueur = canvas.create_oval(
        boule_x - rayon, boule_y - rayon,
        boule_x + rayon, boule_y + rayon,
        outline="ivory2",       # couleur du contour
        width=1,                # épaisseur du trait de contour (pixels)
        fill="light sky blue",  # couleur du remplissage
    )
# end def

def creer_carre_final ():
    """
        on crée le carré final (carré d'arrivée);
        on conserve l'identifiant de l'objet sur le canevas;
        ça nous servira plus tard;
        on prend des coordonnées au hasard;
    """
    # init variables globales
    global taille_carre, demi_carre
    global carre_x, carre_y
    global carre_final
    # on crée le carré d'arrivée
    taille_carre = diametre_boule + 6
    demi_carre = taille_carre // 2
    carre_x = 10 + random.randint(0, c_width - taille_carre - 10)
    carre_y = c_height - taille_carre - random.randint(5, 20)
    # on dessine le carré final (arrivée)
    carre_final = canvas.create_rectangle(
        carre_x - demi_carre, carre_y - demi_carre,
        carre_x + demi_carre, carre_y + demi_carre,
        outline="ivory",        # couleur du contour
        width=1,                # épaisseur du trait de contour (pixels)
        fill="palegreen1",      # couleur du remplissage
    )
# end def

def miner_terrain ():
    "on mine le terrain au début d'une partie"
    # on choisit un nombre au hasard
    nombre_mines = random.randint(10, 20)
    # on boucle pour poser autant de mines
    for i in range(nombre_mines):
        # on pose une mine au hasard
        poser_mine()
    # end for
# end def

def poser_mine ():
    """
        on pose une mine au hasard, mais jamais dans le voisinage
        immédiat du joueur;
    """
    # init variables locales
    tailles = [8, 10, 12]
    couleurs = ["sandy brown", "peru", "sienna1", "coral1"]
    couleur_contour = "burlywood1"
    # on boucle tant que ce n'est pas bon
    # ici, on bouclera cent fois (par précaution)
    # et on abandonnera si on n'y arrive pas
    for i in range(100):
        # on choisit de nouvelles coordonnées au hasard
        mine_x = random.randint(0, c_width)
        mine_y = random.randint(0, c_height)
        # les mines ont une taille variable;
        taille_mine = random.choice(tailles)
        # on recherche les collisions avec d'autres objets
        collisions = canvas.find_overlapping(
            *b_rect(mine_x, mine_y, taille_mine)
        )
        # aucun objet dans le voisinage ?
        if not collisions:
            # on choisit une couleur parmi une palette
            color = random.choice(couleurs)
            # on peut poser notre mine !
            canvas.create_oval(
                b_rect(mine_x, mine_y, taille_mine//2),
                outline=couleur_contour,
                width=1,        # épaisseur de trait de contour (pixels)
                fill=color,     # couleur du remplissage
            )
            # on remonte la boule joueur
            # au premier plan d'affichage
            canvas.tag_raise(boule_joueur, ALL)
            # c'est bon, on a posé notre mine
            # on peut quitter la boucle
            break
        # end if
    # end for
# end def

def b_rect (x, y, size):
    """
        retourne les coordonnées (top, left, bottom, right) d'un
        rectangle de délimitation autour d'un point P(x, y);
    """
    # rectangle d'influence (bounding rectangle)
    return (x - size, y - size, x + size, y + size)
# end def

def boucle_joueur ():
    "boucle temporelle qui gère les mouvements du joueur"
    # init variables globales
    global boule_x, boule_y
    global tid_joueur
    # le joueur a atteint le carré final ?
    if carre_x - demi_carre < boule_x < carre_x + demi_carre and \
            carre_y - demi_carre < boule_y < carre_y + demi_carre:
        # bravo ! c'est gagné !
        return bravo()
    # end if
    # on recherche des collisions
    collisions = canvas.find_overlapping(*canvas.bbox(boule_joueur))
    # le joueur a heurté autre chose que le carré final ?
    if len(collisions) > 1 and carre_final not in collisions:
        # aïe ! dommage !
        return game_over()
    # end if
    # tout est OK on déplace le joueur
    boule_x = (boule_x + sens_x * pas) % c_width
    boule_y = (boule_y + sens_y * pas) % c_height
    canvas.coords(
        boule_joueur,
        boule_x - rayon, boule_y - rayon,
        boule_x + rayon, boule_y + rayon,
    )
    # on boucle à nouveau dans le temps
    tid_joueur = fenetre.after(50, boucle_joueur)
# end def

def boucle_mines ():
    "boucle temporelle qui gère la vie des mines"
    # init variables globales
    global tid_mines
    # on pose une mine de temps en temps
    poser_mine()
    # prochaine mine dans... (millisecondes)
    delai = random.randint(1000, 2000)
    # on relance la boucle après ce délai
    tid_mines = fenetre.after(delai, boucle_mines)
# end def

def bravo ():
    "super ! le joueur a réussi !"
    # on affiche l'écran final
    ecran_final(
        titre="BRAVO",
        sous_titre="C'est gagné !",
        couleur_titre="lemon chiffon",
        couleur_sous_titre="pale green",
    )
# end def

def game_over ():
    "c'est ballot ! le joueur a perdu !"
    # on affiche l'écran final
    ecran_final(
        titre="GAME OVER",
        sous_titre="C'est perdu !",
        couleur_titre="firebrick1",
        couleur_sous_titre="floral white",
    )
# end def

def arreter_partie ():
    "le joueur souhaite arrêter la partie"
    # on affiche l'écran final
    ecran_final(
        titre="ABANDON",
        sous_titre="Partie annulée !",
        couleur_titre="gold",
        couleur_sous_titre="light grey",
    )
# end def

def ecran_final (**kw):
    "on effectue ici des opérations communes à tous les écrans finaux"
    # on bloque les clics intempestifs sur le bouton 'jouer'
    bouton_jouer.configure(state=DISABLED)
    # on stoppe les boucles temporelles qui pourraient
    # éventuellement être encore en cours d'exécution
    arreter_boucles()
    # on efface le canevas graphique
    canvas.delete(ALL)
    # on récupère le titre et sa couleur
    titre = kw.get("titre") or ""
    couleur = kw.get("couleur_titre") or "white"
    # on affiche le titre
    canvas.create_text(
        center_x, center_y - 40,
        text=titre,
        font="sans 36 bold",
        fill=couleur,
    )
    # on récupère le sous-titre et sa couleur
    sous_titre = kw.get("sous_titre") or ""
    couleur = kw.get("couleur_sous_titre") or "white"
    # on affiche le sous-titre
    canvas.create_text(
        center_x, center_y,
        text=sous_titre,
        font="sans 16 bold italic",
        fill=couleur,
    )
    # on relance presenter_jeu() après @delai
    # avec toutefois un minimum de 1 seconde
    delai = kw.get("delai") or 2000     # valeur par défaut
    fenetre.after(max(1000, delai), presenter_jeu)
# end def

def arreter_boucles ():
    "on arrête les boucles temporelles susceptibles de tourner encore"
    # init variables globales
    global tid_joueur, tid_mines
    # stooop !
    fenetre.after_cancel(tid_joueur)
    fenetre.after_cancel(tid_mines)
    # RAZ thread ids
    tid_joueur = tid_mines = 0
# end def

def deplacer_haut (event=None):
    "on déplace l'avatar du joueur vers le haut"
    # init variables globales
    global sens_x, sens_y
    # grâce à la boucle du jeu,
    # nous n'avons pas besoin de plus que ça
    sens_x, sens_y = (0, -1)
# end def

def deplacer_bas (event=None):
    "on déplace l'avatar du joueur vers le bas"
    # init variables globales
    global sens_x, sens_y
    # grâce à la boucle du jeu,
    # nous n'avons pas besoin de plus que ça
    sens_x, sens_y = (0, 1)
# end def

def deplacer_gauche (event=None):
    "on déplace l'avatar du joueur vers la gauche"
    # init variables globales
    global sens_x, sens_y
    # grâce à la boucle du jeu,
    # nous n'avons pas besoin de plus que ça
    sens_x, sens_y = (-1, 0)
# end def

def deplacer_droite (event=None):
    "on déplace l'avatar du joueur vers la droite"
    # init variables globales
    global sens_x, sens_y
    # grâce à la boucle du jeu,
    # nous n'avons pas besoin de plus que ça
    sens_x, sens_y = (1, 0)
# end def

# ------------------- FIN DU PROGRAMME ---------------------------------

# ce script est automatiquement lancé grâce à ceci :

# /!\ à connaître par coeur /!\
if __name__ == "__main__":
    # lancer le programme
    debut_jeu()
# end if

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

# on définit une fermeture
def key_pad (key_value):
    # on définit ici la vraie fonction qui fait le traitement attendu;
    # comme cette fonction sera appelée par le bouton cliquable
    # elle ne prend AUCUN ARGUMENT dans sa définition;
    # en revanche, elle va se servir des arguments stockés dans
    # la fermeture (c'est tout l'intérêt du truc);
    def mon_traitement ():
        # on exploite l'argument stocké par la fermeture
        # touche pavé numérique '0' à '9':
        if key_value in range(10):
            # on ajoute un chiffre à l'affichage
            display.set(display.get() + str(key_value))
        # touche 'AC' - 'All Clear' - tout effacer
        elif key_value == 'AC':
            # on efface tout
            display.set("")
        # ...etc...
        # end if
    # end def
    # retourne une fonction en résultat
    return mon_traitement
# end def

# on crée la fenêtre principale
fenetre = Tk()
fenetre.title("Calculette")
fenetre.resizable(width=False, height=False)

# on ajoute des widgets
display = StringVar()
Label(
    fenetre,
    textvariable=display,
    anchor=E,
    bg="pale green",
    font="sans 14 bold",
    relief=SUNKEN,
    width=10,
).pack(padx=5, pady=5)

# on crée un conteneur à boutons
frame = Frame(fenetre)
frame.pack(padx=5, pady=5)

# options de grid()
opts = dict(sticky=NW+SE)

# on ajoute les boutons utilisant la fermeture
Button(
    frame,
    text="C",
    command=key_pad('C')
).grid(row=0, column=0, **opts)

Button(
    frame,
    text="AC",
    command=key_pad('AC')
).grid(row=0, column=1, columnspan=2, **opts)

Button(frame, text="9", command=key_pad(9)).grid(row=1, column=2, **opts)
Button(frame, text="8", command=key_pad(8)).grid(row=1, column=1, **opts)
Button(frame, text="7", command=key_pad(7)).grid(row=1, column=0, **opts)
Button(frame, text="6", command=key_pad(6)).grid(row=2, column=2, **opts)
Button(frame, text="5", command=key_pad(5)).grid(row=2, column=1, **opts)
Button(frame, text="4", command=key_pad(4)).grid(row=2, column=0, **opts)
Button(frame, text="3", command=key_pad(3)).grid(row=3, column=2, **opts)
Button(frame, text="2", command=key_pad(2)).grid(row=3, column=1, **opts)
Button(frame, text="1", command=key_pad(1)).grid(row=3, column=0, **opts)

Button(
    frame,
    text="0",
    command=key_pad(0)
).grid(row=4, column=0, columnspan=2, **opts)

Button(
    frame,
    text=".",
    command=key_pad('.')
).grid(row=4, column=2, **opts)

# on ajoute un bouton quitter
Button(
    fenetre,
    text="Quitter",
    command=fenetre.destroy,
).pack(padx=5, pady=5)

# on lance la boucle principale
fenetre.mainloop()

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

# on définit une fermeture
def fermeture (valeur):
    # on définit ici la vraie fonction qui fait le traitement attendu;
    # comme cette fonction sera appelée par le bouton cliquable
    # elle ne prend AUCUN ARGUMENT dans sa définition;
    # en revanche, elle va se servir des arguments stockés dans
    # la fermeture (c'est tout l'intérêt du truc);
    def mon_traitement ():
        # on exploite l'argument stocké par la fermeture
        resultat.set("Vous avez cliqué sur le bouton '{}'".format(valeur))
    # end def
    # retourne une fonction en résultat
    return mon_traitement
# end def

# on crée la fenêtre principale
fenetre = Tk()
fenetre.title("Rigolure")
fenetre.resizable(width=False, height=False)

# on ajoute des widgets
resultat = StringVar()
resultat.set("Cliquez sur un bouton au choix")
Label(fenetre, textvariable=resultat).pack(padx=5, pady=10)
Label(fenetre, text="Adieu...").pack(anchor=W, padx=5)

# on crée un conteneur à boutons (pour la présentation)
frame = Frame(fenetre)
frame.pack(pady=10)

# on ajoute les boutons utilisant la fermeture
Button(
    frame,
    text="Veaux",
    command=fermeture('Veaux'),
).pack(side=LEFT, padx=5)

Button(
    frame,
    text="Vaches",
    command=fermeture('Vaches'),
).pack(side=LEFT, padx=5)

Button(
    frame,
    text="Cochons",
    command=fermeture('Cochons'),
).pack(side=LEFT, padx=5)

# on ajoute un bouton quitter
Button(
    fenetre,
    text="Quitter",
    command=fenetre.destroy,
).pack(side=RIGHT, padx=5, pady=5)

# on lance la boucle principale
fenetre.mainloop()

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

# on définit une fonction qui fait le traitement voulu
def mon_traitement (valeur):
    # traitement attendu :
    resultat.set("Vous avez cliqué sur le bouton '{}'".format(valeur))
# end def

# on crée la fenêtre principale
fenetre = Tk()
fenetre.title("Rigolure")
fenetre.resizable(width=False, height=False)

# on ajoute des widgets
resultat = StringVar()
resultat.set("Cliquez sur un bouton au choix")
Label(fenetre, textvariable=resultat).pack(padx=5, pady=10)
Label(fenetre, text="Adieu...").pack(anchor=W, padx=5)

# on crée un conteneur à boutons (pour la présentation)
frame = Frame(fenetre)
frame.pack(pady=10)

# on ajoute les boutons utilisant la fonction lambda
Button(
    frame,
    text="Veaux",
    command=lambda: mon_traitement('Veaux'),
).pack(side=LEFT, padx=5)

Button(
    frame,
    text="Vaches",
    command=lambda: mon_traitement('Vaches'),
).pack(side=LEFT, padx=5)

Button(
    frame,
    text="Cochons",
    command=lambda: mon_traitement('Cochons'),
).pack(side=LEFT, padx=5)

# on ajoute un bouton quitter
Button(
    fenetre,
    text="Quitter",
    command=fenetre.destroy,
).pack(side=RIGHT, padx=5, pady=5)

# on lance la boucle principale
fenetre.mainloop()

ma_fonction = lambda paramètres: valeur_retour

def ma_fonction (paramètres):
    return valeur_retour

cube = lambda x: x**3 # correspond à def cube(x): return x**3
print(cube(10))

somme = lambda x, y: x + y # correspond à def somme(x, y): return x + y
print(somme(3, 4))

somme_serie = lambda n: n * (n + 1) / 2 # somme de la série 1+2+3+...+n
print(somme_serie(100))

1000
7
5050.0

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

# on crée une fonction de dispatch
def dispatch_yview (*args):
    """
        cette fonction dispatche les commandes de la scrollbar
        VERTICALE entre les deux canevas;
    """
    canvas1.yview(*args)
    canvas2.yview(*args)
# end def

# on crée la fenêtre principale
fenetre = Tk()

# on ajoute des widgets

# options de texte
txt_options = dict(
    text="Hello, world!",
    font="sans 16 bold",
    fill="indian red",
)

# canvas 1
canvas1 = Canvas(fenetre, bg="pale goldenrod", width=200, height=200)
canvas1.create_text(100, 100, **txt_options)
canvas1.grid(row=0, column=0, sticky=NW+SE)

# canvas 2
canvas2 = Canvas(fenetre, bg="sky blue", width=200, height=200)
canvas2.create_text(100, 100, **txt_options)
canvas2.grid(row=0, column=1, sticky=NW+SE)

# horizontal scrollbar canvas 1
hbar1 = Scrollbar(fenetre, orient=HORIZONTAL)
hbar1.grid(row=1, column=0, sticky=EW)

# horizontal scrollbar canvas 2
hbar2 = Scrollbar(fenetre, orient=HORIZONTAL)
hbar2.grid(row=1, column=1, sticky=EW)

# VERTICAL scrollbar
vbar = Scrollbar(fenetre, orient=VERTICAL)
vbar.grid(row=0, column=2, sticky=NS)

# on rend les canevas redimensionnables
fenetre.rowconfigure(0, weight=1)
fenetre.columnconfigure(0, weight=1)
fenetre.columnconfigure(1, weight=1)

# on connecte les scrollbars aux canevas
canvas1.configure(
    xscrollcommand=hbar1.set,
    yscrollcommand=vbar.set,
    scrollregion=(0, 0, 800, 600),
)
canvas2.configure(
    xscrollcommand=hbar2.set,
    yscrollcommand=vbar.set,
    scrollregion=(0, 0, 800, 600),
)
hbar1.configure(command=canvas1.xview)
hbar2.configure(command=canvas2.xview)

# on relie la fonction de dispatch ici
vbar.configure(command=dispatch_yview)

# on lance la boucle principale
fenetre.mainloop()

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

# on crée la fenêtre principale
fenetre = Tk()
fenetre.rowconfigure(0, weight=1)

canvas = Canvas(fenetre, bg="white", width=200, height=100)
canvas.create_text(100, 50, text="Hello good people!")
canvas.grid(row=0, column=0, sticky=NW+SE)

vbar = Scrollbar(fenetre, orient=VERTICAL)
vbar.grid(row=0, column=1, sticky=NS)

# connexion canvas - scrollbar

canvas.configure(
    yscrollcommand=vbar.set,
    scrollregion=(0, 0, 200, 300),
)

vbar.configure(command=canvas.yview)

# on lance la boucle principale
fenetre.mainloop()

vbar.configure(command=canvas.yview)

canvas.yview(tkinter.MOVETO, ratio)

canvas.yview(tkinter.SCROLL, n, what)

# l'utilisateur clique dans le creux (zone grisée) d'une Scrollbar
canvas.yview(tkinter.SCROLL, 1, tkinter.PAGES)

# l'utilisateur clique sur la flèche d'une Scrollbar
canvas.yview(tkinter.SCROLL, 1, tkinter.UNITS)

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *

def my_yview (*args):
    """
        cette fonction s'intercale entre l'objet Scrollbar() et
        l'objet Canvas() afin d'étudier ce qui se passe lorsque
        l'utilisateur manipule l'objet Scrollbar();
    """
    # on affiche dans la console les arguments passés
    # normalement au callback canvas.yview
    print(*args)
    # on relaie l'info au canvas
    # pour s'assurer du bon fonctionnement
    canvas.yview(*args)
# end def

# on crée la fenêtre principale
fenetre = Tk()
fenetre.rowconfigure(0, weight=1)

canvas = Canvas(fenetre, bg="white", width=200, height=100)
canvas.create_text(100, 50, text="Hello good people!")
canvas.grid(row=0, column=0, sticky=NW+SE)

vbar = Scrollbar(fenetre, orient=VERTICAL)
vbar.grid(row=0, column=1, sticky=NS)

# connexion canvas - scrollbar

canvas.configure(
    yscrollcommand=vbar.set,
    scrollregion=(0, 0, 200, 300),
)

vbar.configure(command=my_yview)

# on lance la boucle principale
fenetre.mainloop()

# on crée une fonction de dispatch
def dispatch_yview (*args):
    """
        cette fonction dispatche les commandes de la scrollbar
        VERTICALE entre tous les canevas concernés;
    """
    canvas1.yview(*args)
    canvas2.yview(*args)
    canvas3.yview(*args)
    …
    canvasN.yview(*args)
# end def

…code…

# on relie la fonction de dispatch ici
vbar.configure(command=dispatch_yview)

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from Tkinter import *
import ttk

# on crée la fenêtre principale
fenetre = Tk()

# on crée un conteneur pour bien présenter
frame = Frame(fenetre)
frame.pack(expand=1, fill=BOTH, padx=2, pady=2)

# on ajoute des widgets
canvas = Canvas(frame, bg="white", width=200, height=150)
canvas.create_text(100, 75, text="Hello good people!")
hbar = ttk.Scrollbar(frame, orient=HORIZONTAL)
vbar = ttk.Scrollbar(frame, orient=VERTICAL)

# on ajoute une petite poignée de redimensionnement
# histoire de faire joli
sizegrip = ttk.Sizegrip(frame)

# on connecte les scrollbars au canevas
canvas.configure(
    xscrollcommand=hbar.set,
    yscrollcommand=vbar.set,
    scrollregion=(0, 0, 800, 600),
)
hbar.configure(command=canvas.xview)
vbar.configure(command=canvas.yview)

# on place les widgets avec grid()
canvas.grid(row=0, column=0, sticky=NW+SE)
hbar.grid(row=1, column=0, sticky=EW)
vbar.grid(row=0, column=1, sticky=NS)
sizegrip.grid(row=1, column=1)

# on rend le canevas redimensionnable
frame.rowconfigure(0, weight=1)
frame.columnconfigure(0, weight=1)

# on lance la boucle principale
fenetre.mainloop()

Code source et fichier à télécharger

Cacher/Afficher le codeSélectionnez

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

from tkinter import *
from tkinter import ttk

# on crée la fenêtre principale
fenetre = Tk()

# on crée un conteneur pour bien présenter
frame = Frame(fenetre)
frame.pack(expand=1, fill=BOTH, padx=2, pady=2)

# on ajoute des widgets
canvas = Canvas(frame, bg="white", width=200, height=150)
canvas.create_text(100, 75, text="Hello good people!")
hbar = ttk.Scrollbar(frame, orient=HORIZONTAL)
vbar = ttk.Scrollbar(frame, orient=VERTICAL)

# on ajoute une petite poignée de redimensionnement
# histoire de faire joli
sizegrip = ttk.Sizegrip(frame)

# on connecte les scrollbars au canevas
canvas.configure(
    xscrollcommand=hbar.set,
    yscrollcommand=vbar.set,
    scrollregion=(0, 0, 800, 600),
)
hbar.configure(command=canvas.xview)
vbar.configure(command=canvas.yview)

# on place les widgets avec grid()
canvas.grid(row=0, column=0, sticky=NW+SE)
hbar.grid(row=1, column=0, sticky=EW)
vbar.grid(row=0, column=1, sticky=NS)
sizegrip.grid(row=1, column=1)

# on rend le canevas redimensionnable
frame.rowconfigure(0, weight=1)
frame.columnconfigure(0, weight=1)

# on lance la boucle principale
fenetre.mainloop()

>>> import ttk

>>> import tkinter.ttk