TSI1 CQFR IPT fin de 1e année TSI1->TSI2 I- Quelques manipulations sur les listes
Attention à ne pas confondre :
for i in liste:
on utilise
à chaque itération un élément de la liste
for i in range(len(liste)):
on utilise
à chaque itération un index compris entre 0 et len(liste)-1
1) Proposer une ou plusieurs méthodes permettant de générer la liste 𝐿 = [0,1,2,3,4,5].
2) Proposer un algorithme utilisant une boucle for permettant de calculer la somme des éléments de 𝐿. Reprendre cet algorithme avec une boucle while.
3) Proposer un algorithme itératif permettant de calculer le résultat du produit entre les éléments de 𝐿[1: ]. Reprendre cet algorithme avec une boucle while.
4) Proposer un programme permettant de connaître le nombre d’occurrence d’un nombre (par exemple le nombre 20 dans la liste [11,10,15,20,20,15,20])
5) Soit une suite 𝑢𝑛+1= 𝑢𝑛+ 2. Proposer un algorithme donnant la liste des 10 premières valeurs de cette liste. 𝑢0= 2
II- Fonctions : Ecritures et exemples
g=9.81
def chute(t) :
"""documentation que l'on peut obtenir en faisant
help(z)"""
assert t>0 h=10
return -0.5*g*t**2+h
𝑔 est un float définit en dehors du corps de la fonction : c’est une variable globale qui peut être lue mais ne peut pas être modifiée lors de l’exécution d’une fonction (en revanche des listes peuvent être modifiées si elles sont modifiées dans le corps de la fonction)
𝑑𝑒𝑓 _𝑛𝑜𝑚_𝑓𝑜𝑛𝑐𝑡𝑖𝑜𝑛(𝑎𝑟𝑔𝑢𝑚𝑒𝑛𝑡1, 𝑎𝑟𝑔𝑢𝑚𝑒𝑛𝑡2, . . ) Doc string : renseignement sur la fonction ℎ𝑒𝑙𝑝(𝑐ℎ𝑢𝑡𝑒) permet d’avoir ces docs
𝑎𝑠𝑠𝑒𝑟𝑡 impose une condition sur l’argument 𝑡 ℎ est une variable locale qui n’est lu que lors de l’exécution de la fonction
𝑟𝑒𝑡𝑢𝑟𝑛 est un mot facultatif qui, s’il est rencontré met fin à l’instruction et renvoie la valeur qui le suit
temps = 1
hauteur = chute(temps) ℎ𝑎𝑢𝑡𝑒𝑢𝑟 est affectée à la valeur retournée par la fonction pour une valeur d’argument de 1 1) Ecrire une fonction 𝑓𝑎𝑐𝑡𝑜𝑟𝑖𝑒𝑙𝑙𝑒( ) prenant pour agument un entier
𝑛 et retournant le calcul de 𝑛!
2) Ecrire une fonction 𝑚𝑜𝑦𝑒𝑛𝑛𝑒( ) prenant pour argument une liste 𝐿 et permettant de calculer la valeur moyenne des éléments d’une liste de nombres.
3) Ecrire une fonction 𝑣𝑎𝑟𝑖𝑎𝑛𝑐𝑒( ) qui prend pour argument une liste et qui calcule sa variance donnée par < ∑𝑛−1𝑖=0 𝐿𝑖2> −< ∑𝑛−1𝑖=0 𝐿𝑖>2. 4) Ecrire une fonction 𝑟𝑒𝑐𝑡𝑎𝑛𝑔𝑒_𝑔𝑎𝑢𝑐ℎ𝑒( ) permettant de calculer l’intégrale d’une fonction 𝑓, entre 𝑎 et 𝑏 et prenant pour argument 𝑓, 𝑎, 𝑏, 𝑁. L’argument 𝑁 étant le nombre d’intervalles utilisés pour cette méthode des rectangles à gauche. Tester votre fonction pour 𝑓(𝑥) = 3𝑥2 pour 𝑥𝜖[0,10] et vérifier que l’erreur de quadrature est linéaire avec 𝑁.
5) Reprendre votre calcul d’intégrale avec la méthode des trapèzes et vérifier que l’erreur est en 𝑁2.
III- Algorithmes de recherche
1) Proposer une fonction 𝑅𝑒𝑐ℎ𝑒𝑟𝑐ℎ𝑒1( ) qui prend pour argument une liste 𝐿 et un élément 𝑒 et qui renvoie 𝑇𝑟𝑢𝑒 si l’élément 𝑒 est dans la liste, 𝐹𝑎𝑙𝑠𝑒 dans le cas contraire. Cette fonction utilisera, entre autres, une boucle 𝑓𝑜𝑟.
2) Proposer une fonction 𝑅𝑒𝑐ℎ𝑒𝑟𝑐ℎ𝑒2( ) qui prend pour argument une liste 𝐿 et un élément 𝑒 et qui renvoie 𝑇𝑟𝑢𝑒 si l’élément 𝑒 est dans la liste, 𝐹𝑎𝑙𝑠𝑒 dans le cas contraire. Cette fonction renverra également la ou les positions où se trouve l’élément 𝑒 dans 𝐿 3) Proposer une fonction 𝑚𝑎𝑥𝑖𝑚𝑢𝑚( ) qui prend pour argument une
liste 𝐿 de nombres et qui renvoie la valeur et la position du plus grand nombre de 𝐿.
4) Proposer une fonction 𝑑𝑖𝑐ℎ𝑜𝑡𝑜𝑚𝑖𝑒( ) qui prend pour argument une liste 𝐿 de nombres triés par ordre croissant et un nombre 𝑒. Cette fonction repose sur une démarche dichotomique et renvoie la position de 𝑒 dans 𝐿 si 𝑒 est dans 𝐿. Un message d’erreur est renvoyé si 𝑒 n’est pas dans la liste.
TSI1 CQFR IPT fin de 1e année TSI1->TSI2 5) On souhaite trouver un mot 𝑀 dans une chaîne de caractères.
Pour cela, on parcourt la chaîne 𝑆. À chaque étape, on regarde si on a trouvé le bon motif. Si ce n’est pas le cas, on recommence avec l’élément suivant de la chaîne de caractères. Écrire une fonction recherche() qui renvoie 𝐹𝑎𝑙𝑠𝑒 si 𝑀 n’est pas dans 𝑆, et la position de la première lettre de la chaîne de caractères 𝑀 si 𝑀 est présent dans 𝑆.
IV- Terminaison, correction et complexité d’algorithme itératif Terminaison : Est-ce que mon algorithme se termine ? Pour boucle 𝑓𝑜𝑟 :
La terminaison est évidente car le nombre d’itérations est borné.
Pour une boucle 𝑊ℎ𝑖𝑙𝑒 :
Il faut trouver un variant de boucle (entier positif) qui décroit à chaque itération et qui converge vers la condition d’arrêt
Correction :
Est-ce que la valeur renvoyée par mon algorithme est bonne ? On effectue une démonstration par invariant de boucle (dont les deux premières étapes s’apparentent à démarche par récurrence) : - Initialisation : On vérifie que l’invariant de boucle est vrai
juste avant de rentrer dans la boucle.
- Continuité : on suppose l’invariant vrai à l’itération 𝑖 et on démontre qu’il est encore vrai l’itération 𝑖 + 1.
- Terminaison : La condition de boucle est fausse, l’invariant de boucle est toujours vrai et sa valeur doit permettre de démontrer que le résultat est bon.
Complexité 𝑇(𝑛) :
Peut-on estimer de combien le temps d’exécution sera augmenté si je double la taille 𝑛 de la grandeur d’entrée ?
On cherche l'ordre de grandeur du nombre d'opérations élémentaires effectuées dans le pire des cas. Les opérations élémentaires sont les opérations arithmétiques, évaluations de fonctions, comparaison, affectation…
𝑇(𝑛) = 𝑂(log2(𝑛)) => 𝑐𝑜𝑚𝑝𝑙𝑒𝑥𝑖𝑡é 𝑙𝑜𝑔𝑎𝑟𝑖𝑡ℎ𝑚𝑖𝑞𝑢𝑒 𝑇(𝑛) = 𝑂(𝑛) => 𝑐𝑜𝑚𝑝𝑙𝑒𝑥𝑖𝑡é 𝑙𝑖𝑛é𝑎𝑖𝑟𝑒
𝑇(𝑛) = 𝑂(𝑛𝑙𝑜𝑔2(𝑛)) => 𝑐𝑜𝑚𝑝𝑙𝑒𝑥𝑖𝑡é 𝑞𝑢𝑎𝑠𝑖 − 𝑙𝑖𝑛é𝑎𝑖𝑟𝑒 𝑇(𝑛) = 𝑂(𝑛2) => 𝑐𝑜𝑚𝑝𝑙𝑒𝑥𝑖𝑡é 𝑞𝑢𝑎𝑑𝑟𝑎𝑡𝑖𝑞𝑢𝑒
On donne la somme des éléments d’une liste : def somme(L):
resultat =0 i=len(L)-1 while i !=0:
resultat = resultat + L[i]
i=i-1
return resultat print(somme([0,1,2,3,4]))
1) Démontrer que ce programme se termine 2) Trouver l’invariant de boucle.
3) Démontrer que ce programme retourne la bonne valeur 4) Exprimer sa complexité
V- Tableaux numpy : utilisation pour le traitement photo
L’exemple ci-dessous (visant à sommer éléments par éléments les valeurs de deux tableaux) résume assez bien la différence de comportement entre les listes et les tableaux numpy :
Avec boucles for Avec la notation vectorielle
A=[[1,2,3],[4,5,6],[7,8,9]]
B=[[9,8,7],[6,5,4],[3,2,1]]
C=[[],[],[]]
for i in range (3):
for j in range (3):
C[i].append(A[i][j]+B[i][j]) print(C)
A=np.array([[1,2,3],[4,5,6],[7,8,9]]) B=np.array([[9,8,7],[6,5,4],[3,2,1]]) C=np.zeros((3,3))
C[:, :]=A[:, :]+B[:, :]
On rappelle les fonctions suivantes :
l,c=np.shape((T)) #renvoie un tuple(nbre lignes, nbre colonnes du tableau T)
T=np.linspace(0,4,5)#(départ,fin inclue,nbre de points) T=np.arange(0,5,1)#(départ,fin exclue,incrément)
np.meshgrid(X,Y) : renvoie deux tableaux de dimension (X*Y), un contenant toutes les valeurs de X et l’autre de Y
np.mean(a) : renvoie la valeur moyenne
TSI1 CQFR IPT fin de 1e année TSI1->TSI2 1) Créer le tableau numpy 𝑡𝑎𝑏 ci-
contre (10 lignes, 10 colonnes avec une tache grise en centre) modélisant une portion de tableau associé à une image
« noir et blanc ».
2) Créer un autre tableau 𝑚𝑎𝑠𝑘 de même taille que 𝑡𝑎𝑏, et dont les éléments sont faux s’ils sont placés aux mêmes index que les pixels dont la valeur est supérieure « 200 » et vrai sinon.
3) Utiliser ce 𝑚𝑎𝑠𝑘 afin de trouver l’index moyen des lignes et des colonnes ou l’image est grise.
4) On reprend le tableau 𝑡𝑎𝑏 pour lequel on souhaite mettre en évidence le contour de la tache centrale. L’algorithme permettant de mettre en évidence le contour transforme chaque pixel suivant la formule suivante :
𝑇𝑎𝑏[𝑖, 𝑗] = |𝑇𝑎𝑏[𝑖 − 1, 𝑗] + 𝑇𝑎𝑏[𝑖 + 1, 𝑗] + 𝑇𝑎𝑏[𝑖, 𝑗 − 1] + 𝑇𝑎𝑏[𝑖, 𝑗 + 1] − 4𝑇𝑎𝑏[𝑖, 𝑗]|
Obtenir un nouveau tableau obtenu à partir de 𝑡𝑎𝑏 et vérifiant la relation précédente.
VI- Les graphiques
1) Tracer la fonction 𝑥(𝑡) = cos (2𝜋𝑡) où 𝑡 est un tableau numpy à une dimension 𝑡 = 𝑛𝑝. 𝑙𝑖𝑛𝑠𝑝𝑎𝑐𝑒(0,10,1000)
2) Tracer sur le graphe précédent 𝑦(𝑡) = sin (2𝜋𝑡)
3) Obtenir sur un même graphe 𝑦(𝑥) = 𝑎𝑥2 pour 𝑎[1,2,3,4] et 𝑥 ∈ [−5,5].
VII- Méthode de résolution des équations différentielles
On se limite aux équations différentielles d’ordre 1 que l’on écrit sous la forme : 𝑑𝑠(𝑡)
𝑑𝑡 = 𝑓(𝑠(𝑡), 𝑡)
On peut approximer la dérivée par une formule de différence finie progressive (erreur de troncature d’ordre un en 𝑇𝑒): 𝑑𝑠(𝑡)
𝑑𝑡 ≈𝑠𝑖+1−𝑠𝑖
𝑇𝑒
Euler explicite Euler implicite
𝑓(𝑠(𝑡), 𝑡) → 𝑓(𝑠(𝑡𝑖), 𝑡𝑖) 𝑓(𝑠(𝑡), 𝑡) → 𝑓(𝑠(𝑡𝑖+1), 𝑡𝑖+1) Schéma potentiellement instable
si 𝑇𝑒 trop « grand » Toujours stable mais la précision reste liée à la valeur de 𝑇𝑒
1) Résoudre l’équation différentielle 𝑑𝑠
𝑑𝑡= −𝑠(𝑡) avec une méthode d’Euler explicite, une formule de différence finie progressive et un pas 𝑇𝑒= 0.1, 𝑡 ∈ [0,10] ainsi que 𝑠(0) = 1.
2) Résoudre l’équation précédente avec un schéma d’Euler implicite.
3) Superposer vos solutions ainsi que la solution analytique sur un même graphique.
VIII- Résolution d’équations non linéaires On cherche à résoudre : 𝑓(𝑥) = 0
𝑓(𝑥) est une fonction monotone, dérivable qui, dans un intervalle [𝑎, 𝑏]
donné ne présente qu’une racine 𝑥0.
Dichotomie Newton
On se fixe une précision 𝜀 sur la valeur de la racine.
def dicho(f,a,b,epsilon):
while abs(a-b)>epsilon:
c=(a+b)/2
if f(a)*f(c)<0:
b=c else : a=c return c
On se fixe une précision sur 𝑓(𝑥 ≈ 𝑥0) ≈ 𝜀
def newton(f,a,epsilon,der):
x=a
while abs(f(x))>epsilon:
x=x-f(x)/der(x) i=i+1
return x
1) Proposer une estimation de la valeur de 𝜋 avec 3 chiffres significatifs certains en cherchant à résoudre sin(𝑥) = 0 pour 𝑥 ∈ [3; 3,5] avec la méthode de la dichotomie. Obtenir également le nombre d’itérations pour obtenir ce résultat.
2) Proposer une estimation de la valeur de 𝜋 avec 3 chiffres significatifs certains en cherchant à résoudre sin(𝑥) = 0 pour 𝑥 ∈ [3; 3,5] avec la méthode de Newton. Obtenir également le nombre d’itérations pour obtenir ce résultat.
