Programmer en Python Documents de formation


La programmation Python, introduite par le programme de Seconde 2017, a fait l’objet de formations disciplinaires réparties sur une journée en ce qui concerne les mathématiques dans l’Académie de Rouen. Cet article présente les documents de formation.

La programmation Python au lycée

PDF - 975.4 ko
Livret de formation Python
PDF - 119.6 ko
Memento Python

Proposition de correction de certaines activités du livret de formation

I - Python : prise en main

A) EduPython : un éditeur parmi d’autres
B) L’interface d’EduPython
C) Premiers programmes

1. Notion de fonction

script

  1. def discr(a, b, c) :
  2.   return b**2 - 4*a*c
  3.  
  4. def x_sommet(a, b, c) :
  5.   return -b / (2 * a)

Télécharger

console

discr(5, 3, 1)

x_sommet(5, 3, 1)

2. Appeler une fonction ; instruction conditionnelle

script

  1. def nombre_racines_trinome(a, b, c) :
  2.   if discr(a, b, c) < 0 :
  3.     message = "Pas de solution"
  4.   if discr(a, b, c) = 0 :
  5.     message = "Une solution unique"
  6.   if discr(a, b, c) > 0 :
  7.     message = "Deux solutions"
  8.   return message

Télécharger

console

discr(5, 3, 1)

3. Utiliser des bibliothèques

4. Boucles Pour et Tant_que

script Application 1

  1. def fibo(k):
  2.     # Initialisation de la liste
  3.     L = [1, 1]
  4.     for compteur in range (2 , k) :
  5.         n = L[compteur - 2] + L[compteur - 1]
  6.         L.append(n)
  7.     return L

Télécharger

console

fibo(10)

script

  1. def fibo(k, u0, u1):
  2.     # Initialisation de la liste
  3.     L = [u0, u1]
  4.     for compteur in range (2, k) :
  5.         n = L[compteur - 2] + L[compteur - 1]
  6.         L.append(n)
  7.     return L

Télécharger

console

fibo(10,0,1)

script Application 2

  1. from math import sqrt
  2.  
  3. def liste_des_termes() :
  4.     liste = [7]
  5.     u = 7
  6.     while (abs(u - sqrt(5)) > 10**-6) :
  7.         u = 1 / 2 * (u + 5 / u)
  8.         liste.append(u)
  9.     return(liste)

Télécharger

console

liste_des_termes()
D) Suite de Syracuse et représentations graphiques

1. Suite de Syracuse : calcul des termes

script

  1. def syracuse(u) :
  2.     liste = [u]
  3.     while u != 1 :
  4.         if u % 2 == 0 :
  5.             u = u // 2
  6.         else :
  7.             u = u * 3 + 1
  8.         liste.append(u)
  9.     return liste

Télécharger

console

syracuse(17)

2. Représentation graphique d’une suite de Syracuse

script

  1. import matplotlib.pyplot as plt
  2.  
  3. def syracuse(u) :
  4.     liste = [u]
  5.     while u != 1 :
  6.         if u % 2 == 0 :
  7.             u = u // 2
  8.         else :
  9.             u = u * 3 + 1
  10.         liste.append(u)
  11.     return liste
  12.  
  13. def graph_syracuse(u) :
  14.     Y_liste = syracuse(u)
  15.     X_liste = range(len(Y_liste))
  16.     plt.plot(X_liste , Y_liste , "b.")
  17.     plt.show()
  18.  
  19. def graph_double_syracuse(u,v) :
  20.     Yu_liste = syracuse(u)
  21.     Xu_liste = range(len(Yu_liste))
  22.     Yv_liste = syracuse(v)
  23.     Xv_liste = range(len(Yv_liste))
  24.     plt.plot(Xu_liste , Yu_liste , "b.")
  25.     plt.plot(Xv_liste , Yv_liste , "r*")
  26.     plt.show()

Télécharger

console

graph_syracuse(17)

graph_double_syracuse(17, 13)

II - Premières applications de Python

A) Python dès la seconde

1. Applications rapides en géométrie repérée

script

  1. def milieu(xA, yA, xB, yB) :
  2.     return [(xA + xB) / 2 , (yA + yB) / 2]
  3.  
  4. def parallélogramme(A, B, C, D) :   # A,B,C,D sont des listes
  5.     if milieu(A[0], A[1], C[0], C[1]) == milieu(B[0], B[1], D[0], D[1]) :
  6.         return "ABCD est un parallélogramme"
  7.     else :
  8.         return "ABCD n'est pas un parallélogramme"

Télécharger

console

milieu(1, 1, 3, 5)

parallélogramme([1, 1], [2, 4], [3, 5], [4, 6])

2. Déterminer l’équation d’une droite passant par deux points

script

  1. def coeff(x1, y1, x2, y2):
  2.     a = (y1 - y2) / (x1 - x2)
  3.     return a
  4.  
  5. def ord_origine(x1, y1, a) :
  6.     b = y1 - a*x1
  7.     return b
  8.  
  9. def equation(x1, y1, x2, y2) :
  10.     a = coeff(x1, y1, x2, y2)
  11.     b = ord_origine(x1, y1, a)
  12.     if b > 0 :
  13.         msg = "L'équation de votre droite est : y=" + str(a) + "x+" + str(b)
  14.     elif b < 0 :
  15.         msg = "L'équation de votre droite est : y=" + str(a) + "x" + str(b)
  16.     else :
  17.         msg = "L'équation de votre droite est : y=" + str(a) + "x"
  18.     return(msg)

Télécharger

console

equation(1, 1, 3, 5)

3. Petit jeu « Devine le nombre auquel je pense »

script

  1. from random import *
  2.  
  3. def jeu(n) :
  4.     nb = randint(1, n)
  5.     ch = nb + 1 # ch est à coup sûr différent de nb au départ
  6.     compteur = 1
  7.     print("Je pense à un nombre entier entre 1 et 100, à vous de deviner lequel...")
  8.     while nb != ch :
  9.         ch = int(input("Votre proposition ?"))
  10.         if ch < nb :
  11.             print("Trop petit")
  12.         if ch > nb :
  13.             print("Trop grand")
  14.         compteur = compteur + 1
  15.     return "Bravo, le nombre était " + str(ch) + " , vous avez gagné au bout de " + str(compteur) +  " essais"

Télécharger

console

jeu(100)

4. Statistiques

script

  1. from random import *
  2. import matplotlib.pyplot as plt    # (partie graphique)
  3.  
  4. # Création d'une série de 20 valeurs aléatoires entre 1 et 100
  5. serie = [randint(1, 100) for i in range(20)]
  6.  
  7. # Statistiques - indicateurs position et dispersion
  8.  
  9. def moyenne(L) :
  10.     somme = 0
  11.     for compteur in range(len(L)) :
  12.         somme = somme + L[compteur]
  13.     return somme / len(L)
  14.  
  15.  
  16. def quartiles(L) :
  17.     L.sort()     # Tri de la liste L
  18.     if len(L)%2 == 0 :
  19.         mediane = (L[len(L) // 2 - 1] + L[len(L) // 2]) / 2
  20.     else :
  21.         mediane = L[len(L) // 2]
  22.     if len(L)%4 == 0 :
  23.         Q1 = L[len(L) // 4 - 1]
  24.     else :
  25.         Q1 = L[len(L) // 4]
  26.     if (3*len(L))%4 == 0 :
  27.         Q3 = L[(3 * len(L)) // 4 - 1]
  28.     else:
  29.         Q3 = L[(3 * len(L)) // 4]
  30.     return [Q1, mediane, Q3]
  31.  
  32.  
  33. # Statistiques - Echantillonnage
  34.  
  35.  
  36. univers=[1, 2, 2, 4, 5, 6]
  37. # Choisir au hasard un nombre dans la liste univers
  38. choice(univers)
  39.  
  40.  
  41. def echantillon(L,n) :
  42.     echant = []
  43.     for compteur in range(n) :
  44.         echant.append(choice(L))
  45.     return echant
  46.  
  47. def frequence(L,issue) :
  48.     effectif = 0
  49.     for compteur in range(len(L)) :
  50.         if L[compteur] == issue :
  51.             effectif = effectif + 1
  52.     return effectif / len(L)
  53.  
  54.  
  55.  
  56. def frequencegraph(L,issue) :    # necessite matplotlib.pyplot
  57.     effectif = 0
  58.     X_liste = []
  59.     Y_liste = []
  60.     for compteur in range(len(L)) :
  61.         if L[compteur] == issue:
  62.             effectif = effectif + 1
  63.         X_liste.append(compteur)
  64.         Y_liste.append(effectif/(compteur + 1))
  65.     plt.plot(X_liste,Y_liste, "b.")
  66.     plt.show()

Télécharger

console

serie = [randint(1, 100) for i in range(20)]

serie

moyenne(serie)

quartiles(serie)


univers=[1, 2, 2, 4, 5, 6]

ech = echantillon(univers, 10)

ech

frequence(ech, 4)

frequencegraph(ech, 4)

5. Instruction conditionnelle

script

  1. #Calcul du pgcd avec l'algorithme des différences
  2. def pgcd(a,b) :
  3.     while a != b :    # a différent de b
  4.         if a > b :
  5.             a = a - b
  6.         else :
  7.             b = b - a
  8.     return a
  9.  
  10. def irreductible(num,denum) :
  11.     d = pgcd(num,  denum)     # Appel à la fonction pgcd
  12.     if d == 1 :   # d égal à 1
  13.         retour = "la fraction est irréductible"
  14.     else :
  15.         num2 = num // d   # Division entière
  16.         denum2 = denum // d
  17.         msg = "la fraction " + str(num) + "/" + str(denum) + " se simplifie en " + str(num2) + "/" + str(denum2)
  18.     return(msg)    

Télécharger

console

irreductible(25,15)

6. Arithmétique en seconde : pgcd et théorème de Césaro

script

  1. from random import *
  2.  
  3. def pgcd(a,b) :
  4.     while b > 0 :
  5.         r = a % b
  6.         a = b
  7.         b = r
  8.     return a
  9.  
  10. # question 1 :
  11.  
  12. def simulation_cesaro(n):
  13.     f = 0
  14.     for i in range(n) :
  15.         a = randint(1, 100)
  16.         b = randint(1, 100)
  17.         if pgcd(a,b) == 1 :
  18.             f = f + 1
  19.     f = f / n
  20.     return f
  21.  
  22. # question 2 :
  23.  
  24. def proba_cesaro() :
  25.     num = 0
  26.     for a in range(1, 101) :
  27.         for b in range(1, 101) :
  28.             if pgcd(a,b) == 1 :
  29.                 num = num + 1
  30.     p = num / (100**2)
  31.     return p

Télécharger

console

simulation_cesaro(100)

proba_cesaro()
B) Python en prolongement de Scratch et de la calculatrice

1. La Tortue Python en prolongement de Scratch

ATTENTION  : étrangement, une fois sur deux, la console répondra par un message d’erreur finissant sur :

turtle.Terminator

Il suffit de relancer la commande dans la console ...

script

  1. from turtle import *
  2.  
  3. # Triangle équilateral
  4. def triangle_equi(longueur) :
  5.     pensize(2)
  6.     up()
  7.     clear()
  8.     setheading(0)
  9.     goto(-100, -100)
  10.     down()
  11.     for i in range(3) :
  12.         forward(longueur)    # La tortue avance de longueur
  13.         left(120)    # La tortue tourne à gauche de 120°
  14.     up()
  15.     mainloop()
  16.  
  17. # 1. Polygone régulier à n côtés
  18. def poly_reg(n, longueur) :
  19.     for i in range(n) :
  20.         forward(longueur)    # La tortue avance de longueur
  21.         left(360 / n)    # La tortue tourne à gauche de 360°/n
  22.  
  23. # Programme d'application du polygone régulier
  24. def trace_poly_reg(n,longueur) :
  25.     pensize(2)
  26.     up()
  27.     clear()
  28.     setheading(0)
  29.     goto(-100, -100)
  30.     down()
  31.     poly_reg(n, longueur)
  32.     up()
  33.     mainloop()

Télécharger

console

triangle_equi(200)

trace_poly_reg(20, 50)

script à rajouter à la suite du script précédent

  1. # 2. Rosace
  2. def rosace() :
  3.     up()
  4.     clear()
  5.     for compteur in range(6) :
  6.         setheading(60 * compteur)
  7.         goto(0, 0)
  8.         down()
  9.         poly_reg(6, 100)
  10.     up()
  11.     mainloop()

Télécharger

console

rosace()

script à rajouter à la suite du script précédent

  1. # 3. Pour aller plus loin
  2.  
  3. from math import sqrt
  4.  
  5. def prochain_point(u, v) :
  6.     return [u[0] + (v[0] - u[0]) / 4, u[1] + (v[1] - u[1]) / 4]
  7.  
  8. def carre(n) :   # n : nb étapes avec carré de côté 300
  9.     speed(0)
  10.     color("black")
  11.     up()
  12.     clear()
  13.     goto(-200, -200)
  14.     down()
  15.     for compteur in range(n) :
  16.         setheading(18.43494882 * compteur)
  17.         poly_reg(4, 300 * (sqrt(10)/4)**compteur)
  18.         forward((300 * (sqrt(10) / 4)**compteur) / 4)
  19.     up()
  20.  
  21. def trace_figure(n) :
  22.     carre(n)
  23.     mainloop()
  24.  
  25. def fourmi(n) :   # n : nb étapes avec carré de côté 300
  26.     carre(n)
  27.     longueur = 0
  28.     u = [-200, -200]
  29.     v = [-125, -200]
  30.     goto(-200, -200)
  31.     down()
  32.     color("red")
  33.     for compteur in range(n) :
  34.         setheading(18.43494882 * compteur)
  35.         forward((300 * (sqrt(10) / 4)**compteur) / 4)
  36.         longueur +=(300 * (sqrt(10) / 4)**compteur) / 4
  37.         u, v = v, prochain_point(u, v)
  38.     write(longueur)
  39.     up()
  40.     mainloop()

Télécharger

console

trace_figure(10)

fourmi(10)

2. Autour des courbes de fonctions

script

  1. from math import *
  2. import matplotlib.pyplot as plt
  3.  
  4.  
  5. # Exploration des fonctions de variable réelle avec Python
  6. def f(x) :
  7.     return x**2 - exp(x / 2)
  8.  
  9.  
  10. def courbe(f,a,b) :
  11.     X = []
  12.     Y = []
  13.     for k in range(a, b + 1) :
  14.         X.append(k)
  15.         Y.append(f(k))
  16.     plt.plot(X,Y,"b-")
  17.     plt.show()
  18.  
  19. def courbe_pas(f, a, b, pas) :
  20.     X = []
  21.     Y = []
  22.     while a < b :
  23.         X.append(a)
  24.         Y.append(f(a))
  25.         a = a + pas
  26.     plt.plot(X,Y,"b-")
  27.     plt.show()

Télécharger

console

# Mise en oeuvre : courbe de la fonction f definie au debut, pas de 0.1
courbe_pas(f,-2, 10, 0.1)

# Mise en oeuvre : courbe de la fonction f definie au debut, pas de 0.1
courbe_pas(f,-2, 10, 0.1)

script

  1. from math import *
  2. import matplotlib.pyplot as plt
  3.  
  4.  
  5. # Application à la parabole
  6. def abscisse_minmax(a, b, c) :
  7.     return -b/(2 * a)
  8.  
  9.  
  10. def image(a, b, c, x) :
  11.     return a* x**2 + b*x + c
  12.  
  13. def tracer_courbe(a, b, c, pas) :
  14. # Calcul des coordonneées du min/max
  15. # pour définir un intervalle l'incluant
  16.     x_minmax = abscisse_minmax(a, b, c)
  17.     y_minmax = image(a, b, c, x_minmax)
  18.     debut = x_minmax - 5
  19.     fin = x_minmax + 5
  20.     X_liste = []
  21.     Y_liste = []
  22.     curseur = debut
  23.     while curseur < fin :
  24.         X_liste.append(curseur)
  25.         Y_liste.append(image(a, b, c, curseur))
  26.         curseur = curseur + pas
  27.     plt.plot(X_liste , Y_liste , "r-")
  28.     # Un point bleu pour le sommet
  29.     plt.plot(x_minmax , y_minmax , "b.")
  30.     plt.grid() # Affichage de la grille
  31.     plt.show()

Télécharger

console

tracer_courbe(1, 2, 3, 0.1)

3. Méthode de Monte-Carlo

script

  1. from random import *
  2. from math import *
  3. import matplotlib.pyplot as plt
  4.  
  5. def montecarlo(n) :  # n étant le nombre de tirages de points aléatoires à effectuer
  6.     nb_points_endessous = 0
  7.     for compteur in range(n) :
  8.         x = random()   # x prend une valeur aléatoire entre 0 et 1 selon la loi uniforme sur [0;1]
  9.         y = random()
  10.         if y < sqrt(1 - x**2) :
  11.             nb_points_endessous = nb_points_endessous + 1
  12.     # Gare à la double indentation !
  13.     f = nb_points_endessous / n
  14.     return f
  15.  
  16.  
  17. def montecarlo2(n) :         # n étant le nombre de tirages de points aléatoires à effectuer
  18.    
  19.     plt.axis("equal")      # repère orthonormé
  20.     plt.grid()
  21.    
  22.     ## initialisation des variables
  23.     nb_points_endessous = 0
  24.     X_liste_rouge = []
  25.     Y_liste_rouge = []
  26.     X_liste_bleu = []
  27.     Y_liste_bleu = []
  28.    
  29.     for compteur in range(n) :
  30.         x = random()           # x prend une valeur aléatoire entre 0 et 1 selon la loi uniforme sur [0;1]
  31.         y = random()
  32.         if y < sqrt(1-x**2) :
  33.             nb_points_endessous = nb_points_endessous + 1
  34.             X_liste_rouge.append(x)   # le point est en-dessous, il est rouge
  35.             Y_liste_rouge.append(y)   # On stocke ses coordonnées dans les listes "rouges"
  36.         else :
  37.             X_liste_bleu.append(x)   # le point est en-dessous, il est rouge
  38.             Y_liste_bleu.append(y)   # On stocke ses coordonnées dans les listes "bleues"
  39.     f = nb_points_endessous / n
  40.    
  41.     # Tracé du graphique : les 2 tableaux de valeurs
  42.     # Premier tableau : les points rouges
  43.     plt.plot(X_liste_rouge , Y_liste_rouge , "r.")
  44.     # Second tableau : les points bleus
  45.     plt.plot(X_liste_bleu , Y_liste_bleu , "b.")
  46.     # Affichage du graphique
  47.     plt.show()
  48.    
  49.     # renvoi de la fréquence
  50.     return f

Télécharger

console

montecarlo(1000)

montecarlo2(1000)

III - Python : pour aller plus loin

A) Manipulations plus expertes

1. Fonction exponentielle et courbe d’Euler

script

  1. def methode_euler(x,y,h,n) :
  2.     X_liste=[x]
  3.     Y_liste=[y]
  4.  
  5.     for i in range(n) :
  6.         x = x+h
  7.         y = y+y*h
  8.         X_liste.append(x)
  9.         Y_liste.append(y)
  10.     return X_liste,Y_liste
  11.  
  12.  
  13.  
  14. import matplotlib.pyplot as plt
  15.  
  16. # Configuration des axes
  17. ax=plt.gca()
  18. ax.spines["bottom"].set_position("zero") # axe positionné à 0
  19. ax.spines["left"].set_position("zero")   # axe positionné à 0
  20. ax.spines["right"].set_color("none")   # pas de couleur à  droite
  21. ax.spines["top"].set_color("none")     # pas de couleur en haut
  22. ax.xaxis.set_ticks_position("bottom") # Position des abscisses en dessous
  23. ax.yaxis.set_ticks_position("left")   # Position des ordonnées à gauche
  24. plt.grid()  # grille activée
  25.  
  26. # Partie de la courbe pour x > 0
  27. X_liste1, Y_liste1 = methode_euler(0, 1, 0.1, 20)
  28. # Partie de la courbe pour x < 0
  29. X_liste2, Y_liste2 = methode_euler(0, 1, -0.1, 20)
  30.  
  31. # Concaténation des listes
  32. X_liste = X_liste1 + X_liste2
  33. Y_liste = Y_liste1 + Y_liste2
  34.  
  35. # Tracé du graphique
  36. plt.plot(X_liste,Y_liste,"b.")
  37.  
  38. # Affichage du graphique
  39. plt.show()

Télécharger

2. Algorithme de Kaprekar

script de la version 1

  1. def grand(n) :
  2.     chiffre_unite = n % 10
  3.     chiffre_dizaine = (n % 100) // 10
  4.     chiffre_centaine = n // 100
  5.     maxi = max(chiffre_centaine,chiffre_dizaine,chiffre_unite)
  6.     mini = min(chiffre_centaine,chiffre_dizaine,chiffre_unite)
  7.     moyen = (chiffre_centaine+chiffre_dizaine+chiffre_unite)-(maxi+mini)
  8.     s = maxi*100 + moyen*10 + mini
  9.     return s
  10.  
  11. def petit(n) :
  12.     chiffre_unite = n % 10
  13.     chiffre_dizaine = (n % 100) // 10
  14.     chiffre_centaine = n // 100
  15.     maxi = max(chiffre_centaine,chiffre_dizaine,chiffre_unite)
  16.     mini = min(chiffre_centaine,chiffre_dizaine,chiffre_unite)
  17.     moyen = (chiffre_centaine+chiffre_dizaine+chiffre_unite)-(maxi+mini)
  18.     s = mini*100 + moyen*10 + maxi
  19.     return s
  20.  
  21. def kaprekar(n) :
  22.     u = n
  23.     liste_valeurs = [u]
  24.     while u != 495 :
  25.         u = grand(u) - petit(u)
  26.         liste_valeurs.append(u)
  27.     return liste_valeurs

Télécharger

console

kaprekar(217)

script de la version 2

  1. # Dans toutes ces fonctions : la première ligne ("assert") est optionnelle.
  2. # Elle sert à vérifier que le "n" entré est de type entier.
  3.  
  4. def petit_chaine(n) :
  5.     assert type(n) == int , "n n'est pas entier"
  6.     chaine = str(n)               # Conversion de n en chaine
  7.     liste_triee = sorted(chaine)  # Tri de la chaine ; le résultat est une liste
  8.     chaine = "".join(liste_triee) # Concaténation de la liste en une chaine
  9.     return int(chaine)            # On retourne la chaine convertie en entier
  10.  
  11.  
  12.  
  13. def inversion(n) :
  14.     assert type(n) == int , "n n'est pas entier"
  15.     chaine = str(n)                   # Conversion de n en chaine
  16.     longueur = len(chaine)            # Longueur de la chaine
  17.     r = ""                            # Initialisation de la variable de retour (chaine)
  18.     for k in range(longueur):         # Reconstruction de la chaine
  19.         r = r + chaine[longueur-1-k]  #   en partant du dernier caractère
  20.     return int(r)
  21.  
  22.  
  23. # Variante pour seulement 3 chiffres à inverser
  24. def inversion_trois_chiffres(n):  # n entier à 3 chiffres
  25.     assert type(n) == int , "n n'est pas entier"
  26.     N = str(n)
  27.     L = [N[2],N[1],N[0]]
  28.     return int("".join(L))
  29.  
  30.  
  31. def kaprekar(n) :
  32.     assert type(n) == int, "n n'est pas entier"
  33.     u = n
  34.     liste_valeurs = [u]
  35.     while u != 495 :
  36.         u = petit_chaine(u)
  37.         u = inversion(u)-u
  38.         liste_valeurs.append(u)
  39.     return liste_valeurs

Télécharger

console

kaprekar(436)

script de la version 3

  1. # Dans toutes ces fonctions : la première ligne ("assert") est optionnelle.
  2. # Elle sert à vérifier que le "n" entré est de type entier.
  3.  
  4. def petit_par_minimum(n) :
  5.     assert type(n) == int , "n n'est pas entier"
  6.     liste = list(str(n))       # Conversion de n en chaine, puis en liste
  7.     k = len(liste)             # Longueur de la liste
  8.     r = ""                     # Initialisation de la variable de retour (chaine)
  9.     while k > 0 :              # Tant que la liste n'est pas vide
  10.         mini = min(liste)      # Trouver le plus petit élément de la liste
  11.         liste.remove(mini)     # L'enlever
  12.         r = r + mini           # Le placer dans la chaine résultat
  13.         k = k - 1              # La taille de la liste décroit
  14.     return int(r)              # On retourne la chaine convertie en entier
  15.  
  16.  
  17. # Variante sans calcul de la longueur de la liste
  18. def petit_par_minimum_variante(n) :   # n entier à 3 chiffres
  19.     assert type(n) == int,  "n n'est pas entier"
  20.     N1 = str(n)
  21.     L1 = [N1[0], N1[1], N1[2]]
  22.     L2 = []
  23.     while L1 != [] :
  24.         element = min(L1)
  25.         L1.remove(element)
  26.         L2.append(element)
  27.     return int("".join(L2))
  28.  
  29. def inversion(n) :
  30.     assert type(n) == int , "n n'est pas entier"
  31.     chaine = str(n)                   # Conversion de n en chaine
  32.     longueur = len(chaine)            # Longueur de la chaine
  33.     r = ""                            # Initialisation de la variable de retour (chaine)
  34.     for k in range(longueur) :        # Reconstruction de la chaine
  35.         r = r + chaine[longueur - 1 - k]  #   en partant du dernier caractère
  36.     return int(r)
  37.  
  38.  
  39. # Variante pour seulement 3 chiffres à inverser
  40. def inversion_trois_chiffres(n) :  # n entier à  3 chiffres
  41.     N = str(n)
  42.     L = [N[2], N[1], N[0]]
  43.     return int("".join(L))
  44.  
  45.  
  46. def kaprekar(n) :
  47.     assert type(n) == int , "n n'est pas entier"
  48.     u = n
  49.     liste_valeurs = [u]
  50.     while u != 495 :
  51.         u = petit_par_minimum(u)
  52.         u = inversion(u) - u
  53.         liste_valeurs.append(u)
  54.     return liste_valeurs

Télécharger

console

kaprekar(517)

3. La traversée du pont

script

  1. import matplotlib.pyplot as plt
  2. from random import *
  3.  
  4. def traversee_une_fois() :
  5.  
  6.     # Réglages d'appoint de la fenêtre graphique
  7.     ax = plt.gca()
  8.     ax.spines["bottom"].set_position("zero")
  9.     plt.grid(True)
  10.     plt.plot([0, 10], [-2, -2], "-b") # Trace des
  11.     plt.plot([0, 10], [2,2], "-b")   # bords du pont
  12.     plt.axis([0, 10, -3, 3])
  13.  
  14.     # Initialisation des listes
  15.     # des abscisses et ordonnées du marcheur
  16.  
  17.     X = [0]
  18.     Y = [0]
  19.  
  20.     while X[-1] < 10 and abs(Y[-1]) <= 2 :
  21.         de = randint(0,2)
  22.         X.append(X[-1] + 1)
  23.         Y.append(Y[-1] + de - 1)
  24.     plt.plot(X, Y, "-or")
  25.     plt.show()
  26.  
  27.     if abs(Y[-1]) <= 2 and X[-1] == 10 :
  28.         s = 1
  29.     else :
  30.         s = 0
  31.     return s
  32.  
  33.  
  34. def traversee_une_fois_sans_graphe() :
  35.     X = [0]
  36.     Y = [0]
  37.  
  38.     while X[-1] < 10 and abs(Y[-1]) <= 2 :
  39.         de = randint(0, 2)
  40.         X.append(X[-1] + 1)
  41.         Y.append(Y[-1] + de - 1)
  42.  
  43.     if abs(Y[-1]) <= 2 and X[-1] == 10 :
  44.         s = 1
  45.     else :
  46.         s = 0
  47.     return s
  48.  
  49.  
  50. def traversee_multiple(n):   # n traversées
  51.     effectif = 0
  52.     for compteur in range(n) :
  53.         if traversee_une_fois_sans_graphe() == 1 :
  54.             effectif = effectif + 1
  55.     return effectif / n
  56.  
  57.  
  58. def explore_chemin(n, y) :
  59.     r = 0
  60.     if n == 0 :
  61.         if abs(y) <= 2 :
  62.             r = 1
  63.         else :
  64.             r = 0
  65.     else :
  66.         if abs(y) <= 2 :
  67.             for p in [-1, 0, 1] :
  68.                 r = r + explore_chemin(n - 1, y + p)
  69.     return r

Télécharger

console

traversee_une_fois()

traversee_multiple(10)

explore_chemin(3, 0)
B) Albums de vignettes et rareté ressentie : le problème du collectionneur

1. Écriture d’un algorithme en Python modélisant le problème

script

  1. from random import *
  2. from math import *
  3. import matplotlib.pyplot as plt
  4.  
  5. ######################################
  6. # Ecriture d'un algorithme en Python modélisant le problème
  7. ######################################
  8.  
  9. def collection() :
  10.     ALBUM = []
  11.     FREQ = []
  12.     for compteur in range(480) :
  13.         ALBUM.append(0)
  14.     while min(ALBUM) == 0 :
  15.         ALBUM[randint(0, 479)] += 1
  16.     for compteur in range(480) :
  17.         FREQ.append(ALBUM[compteur] / sum(ALBUM))
  18.     p = 1 / 480
  19.     freq_mini = p - 1.96 * sqrt(p * (1 - p) / sum(ALBUM))
  20.     freq_maxi = p + 1.96 * sqrt(p * (1 - p) / sum(ALBUM))
  21.     return max(ALBUM), sum(ALBUM), freq_mini, freq_maxi, FREQ

Télécharger

console

collection()

2. Taille de la collection variable

script à rajouter à la suite du script précédent

  1. ######################################
  2. # Taille de la collection variable
  3. ######################################
  4.  
  5. def album(n) :  # n taille de la collection
  6.     ALBUM = []
  7.     for compteur in range(n) :
  8.         ALBUM.append(0)
  9.     while min(ALBUM) == 0 :
  10.         ALBUM[randint(0, n - 1)] += 1
  11.     return sum(ALBUM)
  12.  
  13. def achats_moyen(n,e) :   # n taille collection, e nombre d'essais
  14.     nb_achats = 0
  15.     for compteur in range(e) :
  16.         nb_achats = nb_achats + album(n)
  17.     return nb_achats / e
  18.  
  19. def album_graph() :
  20.     X_liste = []
  21.     Y_liste = []
  22.     for compteur in range(1, 480+1) :
  23.         X_liste.append(compteur)
  24.         Y_liste.append(achats_moyen(compteur, 10))
  25.     plt.plot(X_liste, Y_liste,"b.")
  26.     plt.show()

Télécharger

console

album_graph()

3. Nombre de collectionneurs variable

script à rajouter à la suite du script précédent

  1. ######################################
  2. # Nombre de collectionneurs variables
  3. ######################################
  4.  
  5. def album_echange(n,p) :   # n taille collection, p collectionneurs
  6.     ALBUM = []
  7.     for compteur in range(n) :
  8.         ALBUM.append(0)
  9.     while min(ALBUM) < p :
  10.         ALBUM[randint(0,n-1)] += 1
  11.     return sum(ALBUM)
  12.  
  13. def achats_moyen2(n, p, e) :   # n taille collection, p collectionneurs, e nombre d'essais
  14.     nb_achats = 0
  15.     for compteur in range(e) :
  16.         nb_achats = nb_achats + album_echange(n, p)
  17.     return (nb_achats / e) / p
  18.  
  19. def album_graph2(n, p, e) :    # n taille collection, p collectionneurs, e nombre d'essais
  20.     X_liste = []
  21.     Y_liste = []
  22.     for compteur in range(1, p + 1) :
  23.         X_liste.append(compteur)
  24.         Y_liste.append(achats_moyen2(n,compteur,e))
  25.     plt.plot(X_liste, Y_liste,"b.")
  26.     plt.show()

Télécharger

console

album_graph2(200, 20, 100)

album_graph2(480, 2, 10)   # Si votre ordinateur le permet ...

Annexe 1 - Python : ressources académiques complémentaires

Annexe 2 - Ressources en ligne sur la programmation Python

Annexe 3 - Installation de Python sous diverses plates-formes (Windows, GNU/Linux...)

Partager

Imprimer cette page (impression du contenu de la page)