# data[].attributes.headline
Exemples de programmes complexes permettant de résoudre des exercices

# data[].attributes.subject
Exemples de programmes complexes permettant de résoudre des exercices

# data[].attributes.attachment_link.readable_text
À partir de la rentrée 2017, l' algorithmique et la programmation avec le langage Python sont au programme du cours de mathématiques dans les filières générales au lycée.

Attention

Ce tutoriel ne s'adresse pas directement aux élèves, mais plutôt à leurs professeurs. Cependant, une bonne maîtrise de la lecture et des bases de l'algorithmique (c'est-à-dire un bon niveau de fin de collège) peut suffire à un élève pour tirer partie de ce site.

Ce site propose au collègues de mathématiques :

de découvrir l'esprit qui anime le langage Python ;

d'apprendre à utiliser ce langage, à un niveau suffisant pour avoir un certain recul ;

quelques exercices et activités pour les élèves.

Pour les élèves les plus faibles, il peut être souhaitable d'attendre la classe de première voire de terminale pour atteindre un niveau suffisant en algorithmique pour mieux comprendre Python, qui comporte quelques écueils (bientôt une page à ce sujet). En attendant, MicroAlg peut être un langage intermédiaire intéressant.

Note

C'est la version 3 de Python qui est présentée sur ce site, comme recommandé par l'inspection.

Débuter avec Python au lycée de Kamel Naroun et Christophe Gragnic est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Partage des Conditions Initiales à l'Identique 3.0 Unported

# data[].attributes.attachment_link.description
Tutoriel destiné principalement aux professeurs de mathématiques, pour l'apprentissage de Python dans le cadre de l'algorithmique au programme de mathématiques du lycée (seconde, première et terminale).

# data[].attributes.attachment_link.readable_text
﻿# Créé par isabelle, le 20/03/2019 en Python 3.4
import matplotlib.pyplot as plt
from math import *
from random import *
n=int(input("entrer la valeur de n"))
liste=[randint(1,6) for i in range(n)]
print(liste)
print(liste.count(1))
print(liste.count(2))
print(liste.count(3))
print(liste.count(4))
print(liste.count(5))
print(liste.count(6))
freq_1=liste.count(1)/n
print(freq_1)
freq_2=liste.count(2)/n
print(freq_2)
freq_3=liste.count(3)/n
print(freq_3)
freq_4=liste.count(4)/n
print(freq_4)
freq_5=liste.count(5)/n
print(freq_5)
freq_6=liste.count(6)/n
print(freq_6)
x = [1,2,3,4,5,6]
height = [freq_1,freq_2,freq_3,freq_4,freq_5,freq_6]
width = 0.5
plt.bar(x, height, width, color='b' )
plt.title("fréquences d'apparition des faces lors d'un lancer de dés")
plt.xlabel("numéro sur la face")
plt.ylabel("fréquence")
plt.axis([0, 7, 0, 0.6])
plt.show()


# data[].attributes.attachment_link.readable_text
﻿# Créé par Moi, le 31/03/2019 en Python 3.4
from math import *
print("Cet algorithme calcule la moyenne, les quartiles, la variance  et l'écart-type d'une série statistique discrète.")
print("Entrer les valeurs des effectifs, fin pour terminer la saisie.")
#on définit la liste xi
xi = []
x = "0"
xi[:] = [] # vide la liste
ECCi = []
ECC = "0"
ECCi[:] = [] # vide la liste
bi = []
b = "0"
bi[:] = [] # vide la liste
#on définit la liste bi
ni = []
n = "0"
ni[:] = [] # vide la liste
k=0
ECC=0
l=input ("Nombre d'effectifs à saisir :")
for i in range(int(l)) :
    k=k+1
    print("Ligne ",k)
    n=input ("entrer une valeur de n :")
    ECC=ECC+float(n)
    ni.append(float(n))
    ECCi.append(float(ECC))
print ("vous avez entré",len(ni),"valeurs ")
k=0
for i in range(len(ni)+1) :
    k=k+1
    print("Ligne ",k)
    b=input ("entrer les bornes des intervalles :")
    bi.append(float(b))

for i in range(len(ni)) :
    xi.append((bi[i]+bi[i+1])/2)

#on définit la liste ni*xi
nixi = []
nixi[:] = [] # vide la liste
for i in range(len(ni)) :
  nixi.append(xi[i]*ni[i])

#on définit la fonction  moyenne
def moyenne():
    moyenne = round(sum(nixi)/sum(ni),3)
    return  moyenne

#on définit la liste ni*xi²
nixicarre = []
nixicarre[:] = [] # vide la liste
for i in range(len(ni)) :
  nixicarre.append(xi[i]**2*ni[i])

#on définit la fonction  variance
def variance():
    variance = round(sum(nixicarre)/sum(ni)-moyenne()**2,3)
    return  variance

#on définit la fonction  ecart type
def ecarttype():
    ecarttype = round(sqrt(variance()),3)
    return  ecarttype
#on affiche le résultat
print("la moyenne est", moyenne())
#on affiche le résultat
print("la variance est", variance())
#on affiche le résultat
print("L'écart type est", ecarttype())
for j in range (3):
    W=sum(ni)*(j+1)/4
    i=0
    while ECCi[i]<W:
        i=i+1
        if i>=1:
            Q=(W-ECCi[i-1])*(bi[i+1]-bi[i])/(ECCi[i]-ECCi[i-1])+bi[i]
        else:
            Q=W*(bi[1]-bi[0])/ECCi[1]+bi[0]
    if j==0:
        S=Q
    if j==1:
        T=Q
    if j==2:
        U=Q
R=bi[0]
V=bi[len(ni)]
print("Le minimum vaut ",R)
print("La première quartile vaut ",S)
print("La médiane vaut ", T)
print("La troisième quartile vaut ",U)
print("Le maximum vaut ", V)
print("L'écart interquartile vaut ",U-S)
print("L'étendue vaut ",V-R)

# data[].attributes.attachment_link.readable_text
from math import *
print("Cet algorithme calcule la moyenne, les quartiles, la variance  et l'écart-type d'une série statistique discrète.")
#on définit la liste xi
xi = []
x = "0"
xi[:] = [] # vide la liste
#on définit la liste ni
ni = []
n = "0"
fi = []
k=1
ni[:] = [] # vide la liste
#on entre les données de la variable xi
#tant que le nombre entré est différent de "fin"
#on transforme les données en nombre réel
fi[:] = [] # vide la liste
print("Ligne ",k)
x=input ("entrer une valeur de x ou le mot <fin> :")
while x!="fin":
      n=input ("entrer une valeur de n :")
      k=k+1
      xi.append(float(x))
      ni.append(float(n))
      print("Ligne ",k)
      x=input ("entrer une valeur de x ou le mot <fin> :")
#on détermine le nombre de données entrées
print ("vous avez entré",len(xi),"valeurs ")
#on détermine la liste des fréquences fi
for i in range(len(xi)) :
    fi.append(ni[i]/sum(ni))
#on définit la liste ni*xi
nixi = []
nixi[:] = [] # vide la liste
for i in range(len(xi)) :
  nixi.append(xi[i]*ni[i])

  #on définit la fonction  moyenne
def moyenne():
    moyenne = round(sum(nixi)/sum(ni),3)
    return  moyenne
#on affiche le résultat
print("la moyenne est", moyenne())
#on définit la liste ni*xi²
nixicarre = []
nixicarre[:] = [] # vide la liste
for i in range(len(xi)) :
  nixicarre.append(xi[i]**2*ni[i])
  #on définit la fonction  variance
def variance():
    variance = round(sum(nixicarre)/sum(ni)-moyenne()**2,3)
    return  variance
#on affiche le résultat
print("la variance est", variance())

#on définit la fonction  ecart type
def ecarttype():
    ecarttype = round(sqrt(variance()),3)
    return  ecarttype
#on affiche le résultat
print("L'écart type est", ecarttype())
def Med(X,F):
    n=len(X)
    i=0
    s=0
    while s<0.5:
        s+=F[i]
        i=i+1
    if s==0.5:
        return (X[i-1]+X[i])/2
    else:
        return X[i-1]
def Q1(X,F):
    n=len(X)
    i=0
    s=0
    while s<0.25:
        s+=F[i]
        i=i+1
    return X[i-1]
def Q3(X,F):
    n=len(X)
    i=0
    s=0
    while s<0.75:
        s+=F[i]
        i=i+1
    return X[i-1]
print("La première quartile vaut ",Q1(xi,fi))
print("La médiane vaut ",Med(xi,fi))
print("La troisième quartile vaut ",Q3(xi,fi))

# data[].attributes.attachment_link.readable_text
﻿# Créé par Moi, le 23/03/2019 en Python 3.4
import matplotlib.pyplot as plt

def g(x):
    '''la fonction qu'on veut représenter'''
    return(2*x**3-3*x**2-6*x)

def graphe(f,a,b,N):
    '''trace le graphe de la fonction f entre a et b avec N segments'''
    lx = [a+i*(b-a)/N for i in range(N+1)]
    ly = [f(x) for x in lx]
    plt.plot(lx,ly)
    plt.show()  # affichage

print("Veuillez saisir l'intervalle d'étude")
s=eval(input("xmin"))
t=eval(input("xmax"))
# programme principal
graphe(g,s,t,100)

# data[].attributes.attachment_link.readable_text
﻿# Créé par Moi, le 23/03/2019 en Python 3.4
import matplotlib.pyplot as plt
valeur=[]
tab=[]
def g(x):
    '''la fonction pour laquelle on cherche les variations'''
    return(2*x**3-3*x**2-6*x)
def dg(x):
    return((g(x+0.0000000001)-g(x))/0.0000000001)
def dicho(a,b,prec):
    while (b-a>prec):
        c=(a+b)/2
        if (dg(a)*dg(c)<=0):
            b=c
        else:
            a=c
    return a
print("Veuillez saisir l'intervalle d'étude")
s=eval(input("xmin"))
t=eval(input("xmax"))
pas=(t-s)/33
for i in range(34):
    n1deriv=dg(s+i*pas)
    n2deriv=dg(s+(i+1)*pas)
    if (n1deriv*n2deriv<0):
        valeur.append(s+i*pas)
        valeur.append(s+(i+1)*pas)
tab.append(s)
for i in range(int(len(valeur)/2)):
    tab.append(dicho(valeur[int(2*i)],valeur[int(2*i+1)],0.0001))
tab.append(t)
for i in range(int(len(tab)-1)):
    print("Pour x allant de ",tab[i]," à ",tab[i+1]," :")
    if (dg((tab[i]+tab[i+1])/2)>=0):
        print("La fonction est croissante, ses valeurs varient entre ",g(tab[i])," à ",g(tab[i+1]))
        print("")
        print("")
    else:
        print("La fonction est décroissante,  ses valeurs varient entre ",g(tab[i])," à ",g(tab[i+1]))
        print("")
        print("")
print("Fin du programme")

# data[].attributes.attachment_link.description
EduPython est un environnement de développement Python gratuit permettant une prise en main rapide, qui simplifier la programmation en Python pour les élèves et les débutants.