1. from tkinter import *
3. def changecoul():
4.     global c
5.     if c==0:
6.         feu1= can.create_oval(35, 45, 45, 55, fill=coul[0])
7.         feu2= can.create_oval(155, 45, 165, 55, fill=coul[1])
8.         feu1= can.create_oval(155, 145, 165, 155, fill=coul[0])
9.         feu1= can.create_oval(35, 145, 45, 155, fill=coul[1])
10.         c=1
11.     else:
12.         feu1= can.create_oval(35, 45, 45, 55, fill=coul[1])
13.         feu2= can.create_oval(155, 45, 165, 55, fill=coul[0])
14.         feu1= can.create_oval(155, 145, 165, 155, fill=coul[1])
15.         feu1= can.create_oval(35, 145, 45, 155, fill=coul[0])
16.         c=0
18. #variables
19. coul=['red', 'green']       #liste des couleurs
20. c= 0                        #variable d'inversion
22. #programme
23. fen=Tk()
25. can= Canvas(fen, width=200, height=200, bg='light grey')
26. can.pack()
28. can.create_rectangle(50, 0, 150, 200, fill="grey" )
29. can.grid(rowspan=3, column=2)
31. #on crée le passage piéton
32. i, x=0, 52.5
33. while i<7:
34.     can.create_rectangle(x, 60, x+10, 140, fill="white" )
35.     i+=1
36.     x+=14
37.    
38. #les feux
39. feu1= can.create_oval(35, 45, 45, 55, fill=coul[1])
40. feu2= can.create_oval(155, 45, 165, 55, fill=coul[0])
41. feu1= can.create_oval(155, 145, 165, 155, fill=coul[1])
42. feu1= can.create_oval(35, 145, 45, 155, fill=coul[0])
44. bou= Button(fen, text="Changer", command=changecoul)
45. bou.grid(row=4, column=2, sticky=E)
47. fen.mainloop()

1. for i in range(0,7): (voir edit)

1. import tkinter
2. tkinter.Canvas (...)

1. def changecoul():
2.     global c
3.     choix = {
4.                   0: ( (35,45,45,55,0),
5.                         (155,45,165,55,1),
6.                         ...manquent deux lignes de données)
7.                   1: ( (35,45,45,55,1),
8.                         (155,45,165,55,0),
9.                         ...manquent deux lignes de données)
10.                 }
12.     feu1 = can.create_oval( choix[c][0][0], choix[c][0][1], choix[c][0][2], choix[c][0][3], fill=coul[ choix[c][0][4] )
13.     feu2 = can.create_oval( choix[c][1][0], choix[c][1][1], choix[c][1][2], choix[c][1][3], fill=coul[ choix[c][1][4] )
14.     feu3 =
15.     feu4 =
16.     (...)
18.     # pour faire alterne les valeurs de c :
19.     c = (c+1)%2

diff -r 3ce560a26ab2 swinnen.py
--- a/swinnen.py    Tue Mar 15 21:35:09 2011 +0100
+++ b/swinnen.py    Tue Mar 15 21:37:36 2011 +0100
@@ -23,10 +23,9 @@
 can.create_rectangle(50, 0, 150, 200, fill="grey" )
 can.grid(rowspan=3, column=2)
 #on cree le passage pieton
-i, x=0, 52.5
-while i<7:
+x = 52.5
+for i in range(7):
     can.create_rectangle(x, 60, x+10, 140, fill="white" )
-    i+=1
     x+=14
 
 #les feux

diff -r be63091caa07 swinnen.py
--- a/swinnen.py    Tue Mar 15 21:38:27 2011 +0100
+++ b/swinnen.py    Tue Mar 15 21:39:39 2011 +0100
@@ -23,10 +23,11 @@
 can.create_rectangle(50, 0, 150, 200, fill="grey" )
 can.grid(rowspan=3, column=2)
 #on cree le passage pieton
-x = 52.5
+OFFSET = 52.5
 for i in range(7):
-    can.create_rectangle(x, 60, x+10, 140, fill="white" )
-    x+=14
+    can.create_rectangle(OFFSET + 14*i, 60,
+                         OFFSET+14*i+10, 140,
+                         fill="white" )
 
 #les feux
 feu1= can.create_oval(35, 45, 45, 55, fill=coul[1])

from tkinter import *
 
COLORS = ['red', 'green']       #liste des couleurs
OFFSET = 52.5
 
toggle = True
 
def toggle_lights():
    global toggle
 
    can.create_oval(35, 45, 45, 55, fill=COLORS[toggle])
    can.create_oval(155, 45, 165, 55, fill=COLORS[not toggle])
    can.create_oval(155, 145, 165, 155, fill=COLORS[toggle])
    can.create_oval(35, 145, 45, 155, fill=COLORS[not toggle])
 
    toggle = not toggle
 
#programme
window = Tk()
can = Canvas(window, width=200, height=200, bg='light grey')
can.pack()
can.create_rectangle(50, 0, 150, 200, fill="grey" )
can.grid(rowspan=3, column=2)
#on cree le passage pieton
for i in range(7):
    can.create_rectangle(OFFSET + 14 * i, 60,
                         OFFSET + 14 * i + 10, 140,
                         fill="white" )
 
#les feux
toggle_lights()
Button(window, text="Changer", command=toggle_lights)\
    .grid(row=4, column=2, sticky=E)
window.mainloop()

1. #Simulation du mouvement d'une balle qui tombe
3. from tkinter import *
5. def move():
6.     "déplacement de la balle"
7.     global x1, y1, dx, v, flag
8.    
9.     xp, yp = x1, y1
10.     x1, y1 = x1+dx, y1+v
11.    
12.     if x1>280 or x1<5:       #à gauche et à droite
13.         dx = -dx     #on inverse le sens de déplacement
14.        
15.     if y1<50:      #montée
16.         v = -v
17.        
18.     if y1>=180:      #descente
19.         y1=180      #pas plus loin
20.         v = -v
22.     can1.coords(oval1, x1-10, y1-10, x1+10, y1+10)
23.    
24.     #on trace
25.     can1.create_line(x1, y1, xp, yp)
26.    
27.     v=v+dv
28.    
29.     if flag>0:
30.         fen1.after(50, move)        #boucler après 50 millisecondes
32.        
33. def stop_it():
34.     "arrêt de l'animation"
35.     global flag
36.     flag=0
38. def start_it():
39.     "démarrage de l'animation"
40.     global flag
41.     if flag==0:     #pour ne lancer qu'une seule boucle
42.         flag=1
43.         move()
44.        
45. #programme
47. #variables
48. x1, y1= 10, 45          #coordonnées initiales
49. dx = 5           #'pas' de déplacement
50. v, dv = 0, 6                   #vitesse et sa variable
51. flag=0                  #commutateur
54. #widget principal
55. fen1=Tk()
56. fen1.title("Exercice d'animation avec tkinter" )
58. #widgets enfants
59. can1= Canvas(fen1, bg='dark grey', height=200, width=300)
60. can1.pack(side=LEFT, padx=5, pady=5)
62. #Création de la balle
63. oval1= can1.create_oval(x1-10, y1-10, x1+10, y1+10, width=2, fill='red')
65. #Bouton quitter
66. bou1= Button(fen1, text='Quitter', width=8, command=fen1.quit)
67. bou1.pack(side=BOTTOM)
69. #Bouton démarrer
70. bou2= Button(fen1, text='Démarrer', width=8, command=start_it)
71. bou2.pack()
73. #Bouton arrêter
74. bou3= Button(fen1, text='Arrêter', width=8, command=stop_it)
75. bou3.pack()
77. #on lance
78. fen1.mainloop()

1. #Simulation du mouvement d'une balle qui tombe
2. #correction pour comprendre car je capte pas pourquoi mon code ne fonctionne pas. En apparence c'est la même chose.
4. from tkinter import *
6. def move():
7.     "déplacement de la balle"
8.     global x, y, v, flag, dv, dx
9.    
10.     xp, yp = x, y   #mémorisation des anciennes coordonnées
11.    
12.     if x>385 or x<15:       #à gauche et à droite
13.         dx = -dx     #on inverse le sens de déplacement
15.     x=x+dx
16.    
17.     #variation de la vitesse
18.     v = v+dv
19.    
20.     #déplacement vertical proportionnel à la vitesse
21.     y= y + v
23.     if y>240:      #niveau du sol
24.         y=240      #pas plus loin
25.         v = -v
27.     can.coords(balle, x-10, y-10, x+10, y+10)
28.    
29.     #on trace
30.     can.create_line(xp, yp, x, y, fill='light grey')
32.    
33.     if flag>0:
34.         fen1.after(50, move)        #boucler après 50 millisecondes
36.        
37. def stop_it():
38.     "arrêt de l'animation"
39.     global flag
40.     flag=0
42. def start_it():
43.     "démarrage de l'animation"
44.     global flag
45.     if flag==0:     #pour ne lancer qu'une seule boucle
46.         flag=1
47.         move()
48.        
49. #programme
51. #variables
52. x, y= 15, 15          #coordonnées initiales
53. dx = 6           #'pas' de déplacement
54. v, dv = 0, 5                   #vitesse et sa variable
55. flag=0                  #commutateur
58. #widget principal
59. fen1=Tk()
60. fen1.title("Exercice d'animation avec tkinter" )
62. #widgets enfants
63. can= Canvas(fen1, bg='dark grey', height=250, width=400)
64. can.pack(side=LEFT, padx=5, pady=5)
66. #Création de la balle
67. balle= can.create_oval(x-10, y-10, x+10, y+10, width=2, fill='red')
69. #Bouton quitter
70. bou1= Button(fen1, text='Quitter', width=8, command=fen1.quit)
71. bou1.pack(side=BOTTOM)
73. #Bouton démarrer
74. bou2= Button(fen1, text='Démarrer', width=8, command=start_it)
75. bou2.pack()
77. #Bouton arrêter
78. bou3= Button(fen1, text='Arrêter', width=8, command=stop_it)
79. bou3.pack()
81. #on lance
82. fen1.mainloop()

1. #si le serpent se recoupe, on perd
2.     for u in range(h-1):
3.         old=snake[u]    #old est la liste contenant les coordonnées d'un carré autre que celui de tête
4.         oldx=old[1]     #coordonnée x du carré
5.         oldy=old[2]     #coordonnée y du carré
6.         if newx>=oldx and newx<=oldx+t and newy>=oldy and newy<=oldy+t:
7.             loose()

1. #Jeu du serpent
3. from tkinter import *
4. from random import randrange
6. #procédure générale de déplacement
7. def move():
8.     #Déplacement du serpent
9.     global flag, points
10.    
11.     tail = snake[0]     #on prend les coords de la queue
12.     c = tail[0]         #mémorisation du nom du carré
13.    
14.     h=len(snake)-1      #on prend l'indice de la tête dans la liste
15.     head=snake[h]       #on prend les coords de la tête
16.    
17.     newx = head[1]+dx*t
18.     newy = head[2]+dy*t
19.    
20.     #si on mange une boulette de bouffe
21.     if newx+t>meatx-meatr and newx+t<meatx+meatr:
22.         if newy>meaty-meatr and newy<meaty+meatr:
23.             points+=1       #on gagne un point
24.             meatgen()       #on génère une nouvelle boulette de bouffe
25.             growsnake()     #on grossi le serpent
26.     if newy+t>meaty-meatr and newy+t<meaty+meatr:
27.         if newx>meatx-meatr and newx<meatx+meatr:
28.             points+=1       #on gagne un point
29.             meatgen()       #on génère une nouvelle boulette de bouffe
30.             growsnake()     #on grossit le serpent#on grossit le serpent
32.     displayPoints.configure(text= "Points = " + str(points))
33.    
34.     #si le serpent se recoupe, on perd
35.     for u in range(h-1):
36.         old=snake[u]    #old est la liste contenant les coordonnées d'un carré autre que celui de tête
37.         oldx=old[1]     #coordonnée x du carré
38.         oldy=old[2]     #coordonnée y du carré
39.         if newx>=oldx and newx<=oldx+t and newy>=oldy and newy<=oldy+t:
40.             loose()
41.    
42.     #si on sort du cadre on a perdu
43.     if newx<0 or newy<0 or newx>canx-t or newy>cany-t:
44.         loose()
45.    
46.     can.coords(c, newx, newy, newx+t, newy+t)   #on déplace
47.    
48.     del(snake[0])
49.    
50.     snake.append([c, newx, newy])       #nouvelle tête
51.    
52.     if flag>0:
53.         fen.after(80, move)        #boucler après 50 millisecondes
55. def meatgen():
56.     global meatx, meaty
57.    
58.     meatx=randrange(meatr, canx-meatr)    #choix d'une coord au hasard sur x
59.     meaty=randrange(meatr, cany-meatr)    #choix d'une coord au hasard sur y
60.    
61.     #on déplace la boulette de bouffe   
62.     can.coords(meat, meatx-meatr, meaty-meatr, meatx+meatr, meaty+meatr)
64. #fonction pour faire grandir le serpent à chaque boulette mangée   
65. def growsnake():
66.     global snake
67.     h=len(snake)-1      #on prend l'indice de la tête dans la liste
68.     head=snake[h]       #on prend les coords de la tête
69.     newx = head[1]+dx*t
70.     newy = head[2]+dy*t
71.     carre=can.create_rectangle(newx, newy, newx+t, newy+t, fill='green')
72.     snake.append([carre, newx, newy])
74. def loose():
75.     stop_it()
76.     can.create_text(canx/2, 20, anchor=CENTER, text='Perdu !!!', fill='red', font='Arial 14 bold')  #affichage d'un message dans le canvas
77.    
78. #Animation
79. def stop_it():
80.     "arrêt de l'animation"
81.     global flag
82.     flag=0
84. def start_it():
85.     "démarrage de l'animation"
86.     global flag, points
87.     if flag==0:     #pour ne lancer qu'une seule boucle
88.         points=0
89.         flag=1
90.         move()   
92. #gestionnaire d'évènements
93. def depl_gauche(event=None):
94.     global dx, dy
95.     dx, dy = -1, 0
97. def depl_droite(event=None):
98.     global dx, dy
99.     dx, dy = 1, 0
100.    
101. def depl_haut(event=None):
102.     global dx, dy
103.     dx, dy = 0, -1
104.    
105. def depl_bas(event=None):
106.     global dx, dy
107.     dx, dy = 0, 1
110. #Variables   
111. x, y= 50, 50        #coordonnées initiales du serpent
112. t=15                #taille d'un coté de carré du serpent
113. snake=[]            #liste avec les coordonnées du serpent
114. flag=0
116. canx, cany = 400, 400   #dimensions du canvas
118. dx, dy = 1, 0       #sens de déplacement
120. meatx, meaty, meatr = 10, 10, 10   #coords et rayon de la bouffe
122. points=0
124. #widget principal
125. fen=Tk()
126. fen.title("exercice d'animation avec tkinter" )
128. #widgets esclaves
129. can= Canvas(fen, bg='dark grey', height=canx, width=cany)
130. can.grid(row=0, columnspan=3)
132. #création du serpent
133. for i in range(4):          #on crée un serpent de 4 carré de long
134.     carre=can.create_rectangle(x, y, x+t, y+t, fill='green')
135.     snake.append([carre, x, y])
136.     x=x+t
138. #première bouffe
139. meat=can.create_oval(meatx-meatr, meaty-meatr, meatx+meatr, meaty+meatr, fill='red')
140. meatgen()
142. Button(fen, text='quitter', command=fen.quit).grid(row=2, column=2)
144. bou2= Button(fen, text='Play', width=8, command=start_it)
145. bou2.grid(row=2, column=1)
147. bou3= Button(fen, text='Stop', width=8, command=stop_it)
148. bou3.grid(row=2, column=0)
150. #Boutons de déplacement, associés aux touches fléchées du clavier
151. fen.bind("<Left>", depl_gauche)
152. fen.bind("<Right>", depl_droite)
153. fen.bind("<Up>", depl_haut)
154. fen.bind("<Down>", depl_bas)
156. #affichage perdu
157. displayPoints = Label(fen)
158. displayPoints.grid(row=1, columnspan=3)
160. #démarrage du programme
161. fen.mainloop()

1. #la phrase la plus longue
3. #on ouvre le fichier en lecture
4. fichier = open('coco', 'r')
6. t, n = fichier.readlines(), 0       #t est la liste des phrases, n est le compteur
8. while n<len(t):
9.     max, phrase=0, ''               #on retient la longueur maxi et la phrase
10.     if len(t[n])>max:
11.         max = len(t[n])
12.         phrase = t[n]
13.     n+=1
15.        
16. print(phrase)
17. fichier.close()

functools.reduce(lambda current, candidate: candidate if len(candidate) > len(current) else current, phrases, '')

1. 129  =  Traceback (most recent call last):
2.   File "C:\Users\Romain\exo_10.15.py", line 5, in <module>
3.     print (i, " = ", chr(i))
4.   File "C:\Python31\lib\encodings\cp850.py", line 19, in encode
5.     return codecs.charmap_encode(input,self.errors,encoding_map)[0]
6. UnicodeEncodeError: 'charmap' codec can't encode character '\x81' in position 0:
7. character maps to <undefined>

1. i = 128
3. while i<=256:
4.     print (i, " = ", chr(i))
5.     i+=1

1. class Satellite(object):
2.     "Simulation de satellites artificiels"
3.    
4.     def __init__(self, nom,masse = 100, vitesse = 0):
5.         self.masse = masse
6.         self.vitesse = vitesse
7.         self.nom = nom
8.        
9.     def impulsion(self, force, duree):
10.         "Pour faire varier la vitesse du satellite"
11.         self.vitesse = self.vitesse + ((force*duree)/self.masse)
12.        
13.     def affiche_vitesse(self):
14.         print("Vitesse du satellite {} : {} m/s" .format(self.nom, self.vitesse))
15.        
16.     def energie(self):
17.         "Affichage de l'énergie cinétique"
18.         return self.masse * self.vitesse**2 / 2
19.        
20. s1 = Satellite('Zoé', masse = 250, vitesse = 10)
21. s1.impulsion(500, 15)
22. s1.affiche_vitesse()
24. print(s1.energie)
26. s1.impulsion(500, 15)
27. s1.affiche_vitesse()
29. print(s1.energie())

1. Vitesse du satellite Zoé : 40.0 m/s
2. <bound method Satellite.energie of <__main__.Satellite object at 0x0000000002537
3. 940>>
4. Vitesse du satellite Zoé : 70.0 m/s
5. 612500.0

1. # Script de décomposition en produit de facteurs premiers
3. class ProduitFacteursPremiers(object):
4.     """Théorème fondamental de l'arithmétique:
5.     chaque entier strictement positif peut être écrit comme un produit de
6.     nombres premiers d'une unique façon, à l'ordre près des facteurs
7.     """
9.     def __init__(self, nb):
10.         self.nb = int(nb)    # int pour être sur que c'est un entier
12.     def nombrePremier(self, n):
13.         """Calcul du prochain nombre premier"""
14.         n+=1
15.         if n==3:  # on zappe 3 qui est premier et qui passerait le test qui suit
16.             return n
17.         while 1:
18.             # un nombre premier est uniquement divisible par lui-même ou 1
19.             if n%3==0 or n%2==0 or n%5==0:    # si oui pas premier
20.                 n+=1
21.             else:    # si premier on le renvoi
22.                 return n
25.     def decomp(self):
26.         "Décomposition de nb en produit de facteurs premiers, renvoi une liste"
27.         diviseur =2
28.         facteur =[]    #liste pour stocker les facteurs premiers
30.         while 1:
31.         # on s'arrête si le nombre premier au carré est
32.         # supérieur au nombre à tester
33.             if self.nb<diviseur**2:
34.                 facteur.append(int(self.nb))    # on ajoute le reste
35.                 return facteur
37.             elif self.nb%diviseur==0:
38.                 self.nb = self.nb/diviseur
39.                 facteur.append(diviseur)    #ajout d'un facteur à la liste
41.             else:
42.                 diviseur = self.nombrePremier(diviseur)# prochain nombre premier
44. if __name__ == '__main__':
45.     nb = input("Entre un nombre positif :" )
46.     a = ProduitFacteursPremiers(nb)
47.     liste = a.decomp()
48.     print(liste)

1. self.nb = int(nb)    # int pour être sur que c'est un entier

1. def eratosthene(limite):
2.     """Calcule les nombres premiers entre 2 et limite"""
3.     liste = []
4.     for i in range(2, limite,1):
5.         liste.append(i)
6.     while len(liste) > 0:
7.         L = liste des entiers de L non multiples du premier

1. l = range(2, LIMIT)

1. def prochainNombrePremier(self, n):
2.         """Calcul du prochain nombre premier"""
3.         n+= 1
4.         if n == 3:  # on zappe 3 qui est premier et qui passerait le test qui suit
5.             return n
6.         if n == 7:    #pareil qu'au dessus
7.             return n
8.         while 1:
9.             # un nombre premier est uniquement divisible par lui-même ou 1
10.             if n%3 == 0 or n% 2== 0 or n%5 == 0 or n%7 == 0:    # si oui pas premier
11.                 n+= 1
12.             else:    # si premier on le renvoi
13.                 return n

1. liste[ nombre*2 :: nombre ] = [0] * ((N // nombre) - 1)

1. # Script de décomposition en produit de facteurs premiers
3. class ProduitFacteursPremiers(object):
4.     """Théorème fondamental de l'arithmétique:
5.     chaque entier strictement positif peut être écrit comme un produit de
6.     nombres premiers d'une unique façon, à l'ordre près des facteurs
7.     """
9.     def __init__(self, nb):
10.         self.nb = int(nb)    # int pour être sur que c'est un entier
11.         self.liste_premiers = self.eratosthene(nb)
13.     def eratosthene(self, limite):
14.         """Calcule les nombres premiers de 2 à limite"""
15.         #liste des entiers de 2 à limite
16.         liste = list(range(2, int(limite)+1))
17.         # liste vide pour accueillir les nombres premiers
18.         liste_premiers = []
19.         #tant qu'il y a des éléments dans la liste
20.         while liste:
21.             liste_premiers.append(liste[0])    # on ajoute le premier élément
22.             # on vire de la liste les multiples du premier élément
23.             liste = list(filter(lambda x: x%liste[0], liste))
24.         return liste_premiers
26.     def decomp(self):
27.         "Décomposition de nb en produit de facteurs premiers, renvoi une liste"
28.         c = 0
29.         diviseur = self.liste_premiers[c]
30.         facteur = []    #liste pour stocker les facteurs premiers
32.         while 1:
33.         # on s'arrête si le nombre premier au carré est
34.         # supérieur au nombre à tester
35.             if self.nb < diviseur**2:
36.                 facteur.append(int(self.nb))    # on ajoute le reste
37.                 return facteur
39.             elif self.nb%diviseur == 0:
40.                 self.nb = self.nb/diviseur
41.                 facteur.append(diviseur)    #ajout d'un facteur à la liste
43.             else:
44.                 c += 1
45.                 diviseur = self.liste_premiers[c]
47. if __name__ == '__main__':
48.     nb = input("Entre un nombre positif :" )
49.     a = ProduitFacteursPremiers(nb)
50.     liste = a.decomp()
51.     print(liste)

1. from math import sqrt
3. def reduitFraction(fraction):
4.     """Réduit une fraction"""
5.     fraction = fraction.split("/" )    # transforme fraction en liste
6.     fraction[1] = fraction[1].strip("\r" )    #vire le \r de la fin
8.     numerateur = decomp(int(fraction[0]))
9.     denominateur = decomp(int(fraction[1]))
11.     new_num = 1
12.     new_denom = 1
14.     n = 0
15.     d = 0
17.     while 1:
19.         if n >= len(numerateur)-1 or d >= len(denominateur)-1:
20.             break
21.         if numerateur[n] == denominateur[d]:
22.             n += 1
23.             d += 1
24.         elif numerateur[n] > denominateur[d]:
25.             new_denom = new_denom * denominateur[d]
26.             d += 1
27.         elif numerateur[n] < denominateur[d]:
28.             new_num *= new_num * numerateur[d]
29.             n += 1
31.     while len(numerateur)-1>=n:
32.         new_num *= numerateur[n]
33.         n += 1
34.     while len(denominateur)-1>=d:
35.         new_denom *= denominateur[d]
36.         d += 1
39.     fractionReduite = ("{}/ {}" ).format(new_num, new_denom)
41.     return fractionReduite
43. def eratosthene(limite):
44.     """Calcule les nombres premiers de 2 à limite"""
45.         #liste des entiers de 2 à limite
46.     liste = list(range(2, int(limite)+1))
47.         # liste vide pour accueillir les nombres premiers
48.     liste_premiers = []
49.         #tant qu'il y a des éléments dans la liste
50.     while liste:
51.         liste_premiers.append(liste[0])    # on ajoute le premier élément
52.             # on vire de la liste les multiples du premier élément
53.         liste = list(filter(lambda x: x%liste[0], liste))
54.     return liste_premiers
56. def decomp(nb):
57.     "Décomposition de nb en produit de facteurs premiers, renvoi une liste"
58.     liste_premiers = eratosthene(sqrt(nb))    #liste des nombres premiers nécessaires
60.     c = 0
61.     diviseur = liste_premiers[c]
62.     facteur = []    #liste pour stocker les facteurs premiers
64.     while 1:
65.         # on s'arrête si le nombre premier au carré est
66.         # supérieur au nombre à tester
67.         if nb < diviseur**2:
68.             facteur.append(int(nb))    # on ajoute le reste
69.             return facteur
71.         elif nb%diviseur == 0:
72.             nb = nb/diviseur
73.             facteur.append(diviseur)    #ajout d'un facteur à la liste
75.         else:
76.             c += 1
77.             diviseur = liste_premiers[c] #on change de nombre premier
79. fraction = input("Entre une fraction : " )
80. result = reduitFraction(fraction)
81. print(result)

1. def all_perms(str):
2.     if len(str) <=1:
3.         yield str
4.     else:
5.         for perm in all_perms(str[1:]):
6.             for i in range(len(perm)+1):
7.                 yield perm[:i] + str[0:1] + perm[i:]
9. for p in all_perms(['a','b','c']):
10.     print(p)

1. # Jeu Pong
2. # Python 3
4. from tkinter import *
6. class Raquette(object):
7.     """Créer un rectangle (la raquette) et inclus la méthode de déplacement
8.     Il faut donner un parametre si on veut jouer à deux. Par défaut, le
9.     jeu se fait contre un mur.
10.     """
11.     def __init__(self, boss, x, y):
12.         self.boss = boss    # la ref de la fenêtre
13.         #création d'une raquette
14.         self.x = x
15.         self.y = y
16.         self.raq = boss.create_rectangle(self.x , self.y,
17.                                          self.x+10, self.y+60, fill='white')
19.         self.filet = boss.create_line(400, 0, 400, 480, fill='light grey',
20.                                       dash=(20, 10))
22.     def monter(self, depl):
23.         self.y -=10
24.         if self.y <=0:    # on contrôle que l'on ne sort pas du tableau
25.             self.y =0
26.         self.boss.coords(self.raq, self.x, self.y, self.x+10, self.y+60)
28.     def descendre(self, depl):
29.         self.y +=10
30.         if self.y >=420:    # on contrôle que l'on ne sort pas du tableau
31.             self.y =420
32.         self.boss.coords(self.raq, self.x, self.y, self.x+10, self.y+60)
34. class Balle(object):
35.     """Créer la balle et sa méthode de déplacement"""
36.     def __init__(self, boss, player1, player2,
37.                  compteur, scorep1, scorep2):
38.         self.boss = boss    #ref de la fenêtre
40.         self.player1 = player1
41.         self.player2 = player2
43.         # coordonnées initiales
44.         self.x, self.y = 400, 240
45.         self.rayon = 10    # rayon de la balle
46.         # création de la balle
47.         self.balle = boss.create_oval(self.x-self.rayon,
48.                                       self.y-self.rayon,
49.                                       self.x+self.rayon,
50.                                       self.y+self.rayon, fill='white')
51.         # déplacement initial
52.         self.dx, self.dy = 10, 10
54.         #compteur
55.         self.compteur = compteur
56.         self.scorep1 = scorep1
57.         self.scorep2 = scorep2
60.     def move(self):
61.         "Déplacement de la balle"
63.         flag =1    # pour controler l'anim'
65.         self.x += self.dx
66.         self.y += self.dy
68.         # On regarde si la balle tape à gauche où à droite
69.         if self.x <= 0:
70.             self.x =400    # balle au centre
71.             self.dx = -self.dx    # renvoi de l'autre côté
72.             self.scorep2 += 1    # on ajoute un point à p2
73.             compt = str(self.scorep1) + "   " + str(self.scorep2)
74.             self.boss.itemconfigure (self.compteur, text=compt)
75.         if self.x >= 800:
76.             self.x =400
77.             self.dx = -self.dx
78.             self.scorep1 += 1
79.             compt = str(self.scorep1) + "   " + str(self.scorep2)
80.             self.boss.itemconfigure (self.compteur, text=compt)
82.         # contrôle pour mettre fin à la partie
83.         if self.scorep1 ==5 or self.scorep2 ==5:
84.             flag =0
85.             self.boss.create_text(400, 240, text="Game over", fill='white',
86.                                   font=("Arial", "22" ))
88.         # Contrôles pour que la balle reste dans la zone (rebonds haut et bas)
89.         if self.y+self.rayon >=480 or self.y-self.rayon <= 0:
90.             self.dy = -self.dy
92.         # pour le rebond sur la raquette de player1
93.         if self.x-self.rayon <= 30:
94.             if self.y-self.rayon >= self.player1.y and\
95.             self.y+self.rayon <= self.player1.y+60:
96.                 self.dx = -self.dx
98.         # pour le rebond sur la raquette de player2
99.         if self.x+self.rayon >= 770:
100.             if self.y-self.rayon >= self.player2.y and\
101.                     self.y+self.rayon <= self.player2.y+60:
102.                 self.dx = -self.dx
104.         self.boss.coords(self.balle,
105.                          self.x-self.rayon,
106.                          self.y-self.rayon,
107.                          self.x+self.rayon,
108.                          self.y+self.rayon)
110.         # Récursivité pour animer la balle
111.         if flag == 1:
112.             self.boss.after(40, self.move)
115. class Application(Frame):
116.     """Fenêtre principale de l'application"""
117.     def __init__(self):
118.         Frame.__init__(self)
119.         self.master.title(">>> Pong <<<" )
120.         self.pack()
121.         self.jeu = Canvas(self, width =800, height =480, background ='black')
122.         self.jeu.pack()
124.         self.compteur = self.jeu.create_text(400, 20, text="0   0", fill='white',
125.                                              font=("Arial", "22" ))
127.         self.y = 210
129.         # score des joueurs
130.         self.scorep1 = 0
131.         self.scorep2 = 0
133.         player1 = Raquette(self.jeu, 20, self.y)
134.         player2 = Raquette(self.jeu, 770, self.y)
136.         balle = Balle(self.jeu, player1, player2,
137.                       self.compteur, self.scorep1, self.scorep2)
138.         # animation de la balle
139.         balle.move()
141.         # on guette les touches a et z pour déplacer la raquette
142.         self.bind_all("a", player1.monter)
143.         self.bind_all("z", player1.descendre)
145.         self.bind_all("k", player2.monter)
146.         self.bind_all("m", player2.descendre)
148. if __name__ == '__main__':
149.     Application().mainloop()