Vous êtes ici : Accueil > Dans la classe > Ressources Lycée > Documents de formation Python 2017 > II - Premières applications de Python

Par : Pôle math

Publié : 6 décembre 2017

II - Premières applications de Python

Voici les corrections, ou des corrections possibles, des activités de la partie II - Premières applications de Python du livret "Programmer en lycée avec Python".
Ce livret a été distribué à l’ensemble des professeurs de mathématiques de lycée de l’académie de Rouen, dans le cadre des formations de novembre 2017.

Table des matières

Retour au sommaire général

A) Python dès la seconde
1. Applications rapides en géométrie repérée
2. Déterminer l’équation d’une droite passant par deux points
3. Petit jeu « Devine le nombre auquel je pense »
4. Statistiques
5. Instruction conditionnelle
6. Arithmétique en seconde : pgcd et théorème de Césaro

B) Python en prolongement de Scratch et de la calculatrice
1. La Tortue Python en prolongement de Scratch
2. Autour des courbes de fonctions
3. Méthode de Monte-Carlo

A) Python dès la seconde

retour

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

script

def milieu(xA,yA,xB,yB) :
    return [(xA+xB)/2 , (yA+yB)/2]

def parallélogramme(A,B,C,D) :   # A,B,C,D sont des listes
    if milieu(A[0],A[1],C[0],C[1]) == milieu(B[0],B[1],D[0],D[1]) :
        return "ABCD est un parallélogramme"
    else :
        return "ABCD n'est pas un parallélogramme"

console

milieu(1,1,3,5)

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

retour

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

script

def coeff(x1,y1,x2,y2):
    a = (y1-y2) / (x1-x2)
    return a

def ord_origine(x1,y1,a) :
    b = y1 - a*x1
    return b

def equation(x1,y1,x2,y2) :
    a = coeff(x1,y1,x2,y2)
    b = ord_origine(x1,y1,a)
    if b > 0 :
        msg = "L'équation de votre droite est : y=" + str(a) + "x+" + str(b)
    elif b < 0 :
        msg = "L'équation de votre droite est : y=" + str(a) + "x" + str(b)
    else :
        msg = "L'équation de votre droite est : y=" + str(a) + "x"
    return(msg)

console

equation(1,1,3,5)

retour

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

script

from random import *

def jeu(n) :
    nb = randint(1,n)
    ch = nb + 1 # ch est à coup sûr différent de nb au départ
    compteur = 1
    print("Je pense à un nombre entier entre 1 et 100, à vous de deviner lequel...")
    while nb != ch :
        ch = int(input("Votre proposition ?"))
        if ch < nb :
            print("Trop petit")
        if ch > nb :
            print("Trop grand")
        compteur = compteur + 1
    return "Bravo, le nombre était " + str(ch) + " , vous avez gagné au bout de " + str(compteur) +  " essais"

console

jeu(100)

retour

4. Statistiques

script

from random import *
import matplotlib.pyplot as plt    # (partie graphique)

# Création d'une série de 20 valeurs aléatoires entre 1 et 100
serie = [randint(1,100) for i in range(20)]

# Statistiques - indicateurs position et dispersion

def moyenne(L) :
    somme = 0
    for compteur in range(len(L)) :
        somme = somme + L[compteur]
    return somme / len(L)


def quartiles(L) :
    L.sort()     # Tri de la liste L
    if len(L)%2 == 0 :
        mediane = (L[len(L)//2-1]+L[len(L)//2])/2
    else :
        mediane = L[len(L)//2]
    if len(L)%4 == 0 :
        Q1 = L[len(L)//4-1]
    else :
        Q1 = L[len(L)//4]
    if (3*len(L))%4 == 0 :
        Q3 = L[(3*len(L))//4-1]
    else:
        Q3 = L[(3*len(L))//4]
    return [Q1,mediane,Q3]


# Statistiques - Echantillonnage


univers=[1,2,2,4,5,6]
# Choisir au hasard un nombre dans la liste univers
choice(univers)


def echantillon(L,n) :
    echant = []
    for compteur in range(n) :
        echant.append(choice(L))
    return echant

def frequence(L,issue) :
    effectif = 0
    for compteur in range(len(L)) :
        if L[compteur] == issue :
            effectif = effectif + 1
    return effectif/len(L)



def frequencegraph(L,issue) :    # necessite matplotlib.pyplot
    effectif = 0
    X_liste = []
    Y_liste = []
    for compteur in range(len(L)) :
        if L[compteur] == issue:
            effectif = effectif + 1
        X_liste.append(compteur)
        Y_liste.append(effectif/(compteur+1))
    plt.plot(X_liste,Y_liste,"b.")
    plt.show()

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)

retour

5. Instruction conditionnelle

script

#Calcul du pgcd avec l'algorithme des differences
def pgcd(a,b) :
    while a != b :    # a différent de b
        if a > b :
            a = a - b
        else :
            b = b - a
    return a

def irreductible(num,denum) :
    d = pgcd(num,denum)     # Appel à la fonction pgcd
    if d == 1 :   # d égal à 1
        retour = "la fraction est irréductible"
    else :
        num2 = num // d   # Division entière
        denum2 = denum // d
        msg = "la fraction " + str(num) + "/" + str(denum) + " se simplifie en " + str(num2) + "/" + str(denum2)
    return(msg)

console

irreductible(25,15)

retour

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

script

from random import *

def pgcd(a,b) :
    while b > 0 :
        r = a % b
        a = b
        b = r
    return a

# question 1 :

def simulation_cesaro(n):
    f = 0
    for i in range(n) :
        a = randint(1,100)
        b = randint(1,100)
        if pgcd(a,b) == 1 :
            f = f + 1
    f = f / n
    return f

# question 2 :

def proba_cesaro() :
    num = 0
    for a in range(1,101) :
        for b in range(1,101) :
            if pgcd(a,b) == 1 :
                num = num + 1
    p = num / (100**2)
    return p

console

simulation_cesaro(100)

proba_cesaro()

retour

B) Python en prolongement de Scratch et de la calculatrice

retour

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

from turtle import *

# Triangle équilateral
def triangle_equi(longueur) :
    pensize(2)
    up()
    clear()
    setheading(0)
    goto(-100,-100)
    down()
    for i in range(3) :
        forward(longueur)    # La tortue avance de longueur
        left(120)    # La tortue tourne à gauche de 120°
    up()
    mainloop()

# 1. Polygone régulier à n côtés
def poly_reg(n,longueur) :
    for i in range(n) :
        forward(longueur)    # La tortue avance de longueur
        left(360/n)    # La tortue tourne à gauche de 360°/n

# Programme d'application du polygone régulier
def trace_poly_reg(n,longueur) :
    pensize(2)
    up()
    clear()
    setheading(0)
    goto(-100,-100)
    down()
    poly_reg(n,longueur)
    up()
    mainloop()

console

triangle_equi(200)

trace_poly_reg(20,50)

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

# 2. Rosace
def rosace() :
    up()
    clear()
    for compteur in range(6) :
        setheading(60*compteur)
        goto(0,0)
        down()
        poly_reg(6,100)
    up()
    mainloop()

console

rosace()

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

# 3. Pour aller plus loin

from math import sqrt

def prochain_point(u,v) :
    return [u[0]+(v[0]-u[0])/4 , u[1]+(v[1]-u[1])/4]

def carre(n) :   # n : nb étapes avec carré de côté 300
    speed(0)
    color("black")
    up()
    clear()
    goto(-200,-200)
    down()
    for compteur in range(n) :
        setheading(18.43494882*compteur)
        poly_reg(4,300*(sqrt(10)/4)**compteur)
        forward((300*(sqrt(10)/4)**compteur)/4)
    up()

def trace_figure(n) :
    carre(n)
    mainloop()

def fourmi(n) :   # n : nb étapes avec carré de côté 300
    carre(n)
    longueur=0
    u=[-200,-200]
    v=[-125,-200]
    goto(-200,-200)
    down()
    color("red")
    for compteur in range(n) :
        setheading(18.43494882*compteur)
        forward((300*(sqrt(10)/4)**compteur)/4)
        longueur +=(300*(sqrt(10)/4)**compteur)/4
        u,v = v,prochain_point(u,v)
    write(longueur)
    up()
    mainloop()

console

trace_figure(10)

fourmi(10)

retour

2. Autour des courbes de fonctions

script

from math import *
import matplotlib.pyplot as plt


# Exploration des fonctions de variable réelle avec Python
def f(x) :
    return x**2-exp(x/2)


def courbe(f,a,b) :
    X = []
    Y = []
    for k in range(a,b+1) :
        X.append(k)
        Y.append(f(k))
    plt.plot(X,Y,"b-")
    plt.show()

def courbe_pas(f,a,b,pas) :
    X = []
    Y = []
    while a < b :
        X.append(a)
        Y.append(f(a))
        a = a + pas
    plt.plot(X,Y,"b-")
    plt.show()

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

from math import *
import matplotlib.pyplot as plt


# Application à la parabole
def abscisse_minmax(a,b,c) :
    return -b/(2*a)


def image(a,b,c,x) :
    return a*x**2+b*x+c

def tracer_courbe(a,b,c,pas) :
# Calcul des coordonneées du min/max
# pour définir un intervalle l'incluant
    x_minmax = abscisse_minmax(a,b,c)
    y_minmax = image(a,b,c,x_minmax)
    debut = x_minmax-5
    fin = x_minmax+ 5
    X_liste = []
    Y_liste = []
    curseur = debut
    while curseur < fin :
        X_liste.append(curseur)
        Y_liste.append(image(a,b,c,curseur))
        curseur = curseur + pas
    plt.plot(X_liste , Y_liste , "r-")
    # Un point bleu pour le sommet
    plt.plot(x_minmax , y_minmax , "b.")
    plt.grid() # Affichage de la grille
    plt.show()

console

tracer_courbe(1,2,3,0.1)

retour

3. Méthode de Monte-Carlo

script

from random import *
from math import *
import matplotlib.pyplot as plt

def montecarlo(n) :  # n étant le nombre de tirages de points aléatoires à effectuer
    nb_points_endessous = 0
    for compteur in range(n) :
        x = random()   # x prend une valeur aléatoire entre 0 et 1 selon la loi uniforme sur [0;1]
        y = random()
        if y < sqrt(1-x**2) :
            nb_points_endessous = nb_points_endessous + 1
    # Gare à la double indentation !
    f = nb_points_endessous / n
    return f
  

def montecarlo2(n) :         # n étant le nombre de tirages de points aléatoires à effectuer
    
    plt.axis("equal")      # repère orthonormé
    plt.grid()
    
    ## initialisation des variables
    nb_points_endessous = 0
    X_liste_rouge = []
    Y_liste_rouge = []
    X_liste_bleu = []
    Y_liste_bleu = []
    
    for compteur in range(n) :
        x = random()           # x prend une valeur aléatoire entre 0 et 1 selon la loi uniforme sur [0;1]
        y = random()
        if y < sqrt(1-x**2) :
            nb_points_endessous = nb_points_endessous + 1
            X_liste_rouge.append(x)   # le point est en-dessous, il est rouge
            Y_liste_rouge.append(y)   # On stocke ses coordonnées dans les listes "rouges"
        else :
            X_liste_bleu.append(x)   # le point est en-dessous, il est rouge
            Y_liste_bleu.append(y)   # On stocke ses coordonnées dans les listes "bleues"
    f = nb_points_endessous / n
    
    # Tracé du graphique : les 2 tableaux de valeurs
    # Premier tableau : les points rouges
    plt.plot(X_liste_rouge , Y_liste_rouge , "r.")
    # Second tableau : les points bleus
    plt.plot(X_liste_bleu , Y_liste_bleu , "b.")
    # Affichage du graphique
    plt.show()
    
    # renvoi de la fréquence
    return f

console

montecarlo(1000)

montecarlo2(1000)

retour

Rectorat de l'académie de Normandie - Site de Rouen
- 25, rue de Fontenelle
  76 037 Rouen
- Tél. 02 32 08 90 00
  Site Web
Directions des services départementaux de l'éducation nationale
- Calvados
- Eure
- Manche
- Orne
- Seine-Maritime
Services
Ministère
- Ministère de l'éducation nationale
  Ministère de l'enseignement supérieur et de la recherche
  éduscol : portail national des professionnels de l'éducation

Mathématiques Académie de Normandie

Menu de navigation

Dans cette rubrique

Sur le même sujet

Visites

II - Premières applications de Python

Table des matières

A) Python dès la seconde

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

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

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

4. Statistiques

5. Instruction conditionnelle

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

B) Python en prolongement de Scratch et de la calculatrice

1. La Tortue Python en prolongement de Scratch

2. Autour des courbes de fonctions

3. Méthode de Monte-Carlo