Exercice 1 : Quelques manipulations sur les listes
#%% question 1 : création de listes liste1=[0,1,2,3,4]
liste2=[]
for i in range(5):
liste2.append(i) liste3=list(range(5))
liste4=[i for i in range(5)]#[f(i) for i in objet]
liste5=list() for i in range(5):
liste5.append(i)
print(liste1,liste2,liste3,liste4,liste5) liste6=list(liste1)
liste6[0]=5 print(liste1)
#%%question 2 : calcul de la somme des éléments d'une liste
"""avec une boucle for"""
def somme1_a(liste):
resultat=0
for i in range(len(liste)):
resultat=resultat+liste[i]
return resultat
print(somme1_a([0,1,2,3,4])) def somme1_b(liste):
resultat=0 for i in liste:
resultat=resultat+i return resultat
print(somme1_b([0,1,2,3,4]))
#cas particulier d'une boucle for qui ne se termine par :
#for i in liste :
#liste.append(i)
#mais en général, une boucle for ne pose pas de pb
#de terminaison : elle est bornée à sa création def somme2_a(liste):
resultat=0 N=len(liste) while N>0:
resultat=resultat+liste[N-1]
N=N-1
return resultat
print(somme2_a([0,1,2,3,4])) def somme2_b(liste):
resultat=0 i=0
while i<len(liste):
resultat=resultat+liste[i]
i=i+1
return resultat
print(somme2_b([0,1,2,3,4]))
#%%% question 3 : calcul du produit des éléments d'une liste def produit1_a(liste):
resultat=1
for i in range(1,len(liste),1):
resultat=resultat*liste[i]
return resultat
print(produit1_a([0,1,2,3,4])) def produit1_b(liste):
resultat=1
for i in liste[1:]:
resultat=resultat*i return resultat
print(produit1_b([0,1,2,3,4])) def produit2_a(liste):
resultat=1 i=1
while i<len(liste):
resultat*=liste[i]
i+=1
return resultat
print(produit2_a([0,1,2,3,4])) def produit2_b(liste):
resultat=1 N=len(liste) while N>1:
resultat*=liste[i]
N-=1
return resultat
print(produit2_a([0,1,2,3,4]))
#%% Question 4 : Nombre d'occurence d'un nombre dans une liste def occurence_a(liste,elt):
compt=0
for i in liste:
if i == elt:
compt+=1 else :
continue return compt
print(occurence_a([20,20,10],20)) def occurence_b(liste,elt):
compt=0
for i in range(len(liste)):
if liste[i] == elt:
compt+=1 else :
continue return compt
print(occurence_a([20,20,10],20))
#%% Question 5 : Calcul d'une suite def calcul_liste_a(N):
u_0=2
liste=[u_0]*N
for i in range(N-1):
liste[i+1]=liste[i]+2 return liste
print (calcul_liste_a(10)) def calcul_liste_b(N):
u_0=2
liste=[u_0]
for i in range(N-1):
liste.append(liste[i]+2) return liste
print (calcul_liste_b(10))
"""autre méthode"""
u_0=2
for i in range(10):
print(u_0) u_1=2+u_0 u_0=u_1
""" cas d'une suite avec u_n+2=u_n+1+u_n"""
def calcul_suite3(N):
u_0=0 u_1=2
liste=[u_0,u_1]
for i in range(N-2):
liste.append(liste[-1]+liste[-2]) return liste
print(calcul_suite3(10)) u_0=0
u_1=2
for i in range(10):
print(u_0) u_2=u_0+u_1 u_0=u_1 u_1=u_2
Exercice 2 :
#%%% question 1: calcul de la factorielle def factorielle1(n:int) -> int :
resultat=1 while n>0:
resultat=resultat*n n=n-1
return resultat print(factorielle1(5))
def factorielle2(n:int) -> int : resultat=1
for i in range(n,0,-1):
resultat=resultat*i return resultat
print(factorielle2(5)) def factorielle3(n):
if n ==1:
return 1 elif n ==0 : return 1 else :
return n*factorielle3(n-1) print(factorielle3(5))
#%% question 2 : Valeur moyenne d'une liste def moyenne1(liste):
somme =0 N=len(liste)
for i in range(N):
somme=somme+liste[i]
return somme/N
print(moyenne1([0,1,2,3,4]))
def moyenne2(liste):
somme =0 N=len(liste) for i in liste:
somme=somme+i return somme/N
print(moyenne2([0,1,2,3,4])) def moyenne3(liste):
somme =0 N=len(liste) while N>0:
somme=somme+liste[N-1]
N=N-1
return somme/(len(liste)) print(moyenne3([0,1,2,3,4]))
#%%question 3 calcul variance 𝑉 = 1
𝑁∑(𝐿𝑖− 𝐿𝑚𝑜𝑦)2= 1
𝑁∑(𝐿𝑖2+ 𝐿2𝑚𝑜𝑦− 2𝐿𝑖𝐿𝑚𝑜𝑦) =∑ 𝐿2𝑖
𝑁 +𝐿2𝑚𝑜𝑦− 2𝐿2𝑚𝑜𝑦
𝑁 =∑ 𝐿2𝑖 𝑁 −𝐿2𝑚𝑜𝑦
𝑁 =< ∑ 𝐿2𝑖 > −< 𝐿𝑖>2 def variance(liste):
s1=0 s2=0
for i in liste:
s1 = s1+i s2 = s2+i**2
return (s2/len(liste)-(s1/len(liste))**2) print(variance([0,1,2,3,4]))
#%% question 4 : méthode des rectangles à gauche def rectangle_gauche(N,a,b,f):
h=(b-a)/N integrale =0
for i in range(N):#la méthode range ne prend pas de pas décimaux x=a+i*h
integrale = integrale + h*f(x) return integrale
def f(x):
return 3*x**2
print(1000-rectangle_gauche(100,0,10,f)) print(1000-rectangle_gauche(1000,0,10,f)) def trapeze(N,a,b,f):
h=(b-a)/N integrale =0
for i in range(N):#la méthode range ne prend pas de pas décimaux x=a+i*h
integrale = integrale + 0.5*h*(f(x)+f(x+h)) return integrale
print(1000-trapeze(100,0,10,f)) print(1000-trapeze(1000,0,10,f))
Interpolation par morceaux de degré 0 Interpolation par morceaux de degré 1
Approximation de l’aire (rectangle à gauche):
∫ 𝑓(𝑥)𝑑𝑥 ≈ ∑ 𝑦𝑖ℎ
𝑛−1
𝑖=0 𝑏
𝑎
Approximation de l’aire :
∫ 𝑓(𝑥)𝑑𝑥 ≈ ∑(𝑦𝑖+ 𝑦𝑖+1) ℎ 2
𝑛−1
𝑖=0 𝑏
𝑎
Erreur quadratique :
∫ 𝑓(𝑥)𝑑𝑥
𝑎+ℎ
𝑎
= 𝐹(𝑎 + ℎ) − 𝐹(𝑎) Avec un DL à l’ordre 1 :
∫ 𝑓(𝑥)𝑑𝑥
𝑎+ℎ
𝑎
= 𝑓(𝑎)ℎ +𝑓′(𝜉)ℎ2 2
Donc ∫ 𝑓(𝑥)𝑑𝑥𝑎𝑏 ≈ ∑𝑛−1𝑖=0𝑦𝑖ℎ si on néglige 𝑛ℎ2
2 𝑓′(𝜉)𝑚𝑎𝑥 ≈ 𝑂(ℎ)
Erreur quadratique :
∫ 𝑓(𝑥)𝑑𝑥
𝑎+ℎ
𝑎
= 𝐹(𝑎 + ℎ) − 𝐹(𝑎) Avec un DL à l’ordre 2 :
∫ 𝑓(𝑥)𝑑𝑥
𝑎+ℎ
𝑎
= 𝑓(𝑎)ℎ +𝑓′(𝑎)ℎ2
2 +𝑓′′(𝜉)ℎ3 6 Donc
∫ 𝑓(𝑥)𝑑𝑥
𝑏
𝑎
≈ ∑ 𝑦𝑖ℎ +(𝑦𝑖+1− 𝑦𝑖)ℎ2 2ℎ
𝑛−1
𝑖=0
∫ 𝑓(𝑥)𝑑𝑥
𝑏
𝑎
≈ ∑(𝑦𝑖+ 𝑦𝑖+1)ℎ 2
𝑛−1
𝑖=0
Si on néglige 𝑛ℎ3
6 𝑓′′(𝜉)𝑚𝑎𝑥 ≈ 𝑂(ℎ2)
Exercice 3 : Algorithme de recherche
#%% question 1 détection d'un élément dans une liste def recherche1_a(liste,elt):
for i in liste : if i == elt :
return True#sortie anticipée return False
print(recherche1_a([0,1,2,3,4],4))
def recherche1_b(liste,elt):#avec une boucle while i=0
while i<len(liste) : if liste[i] == elt:
return True i=i+1
return False
print(recherche1_b([0,1,2,3,4],4))
def recherche1_c(liste,elt):#plus simplement return elt in liste
print(recherche1_c([0,1,2,3,4],4))
"""on peut aussi rechercher la 1e occurrence"""
def recherche1_d(liste,elt):#avec une boucle for for i in range(len(liste)) :
if liste[i] == elt:
return i return False
print(recherche1_d([0,1,2,3,4],4))
def recherche1_e(liste,elt):#avec une boucle while i=0
while i<len(liste) : if liste[i] == elt:
return i i = i+1 return False
print(recherche1_d([0,1,2,3,4],4))
"""on peut aussi rechercher la dernière occurrence"""
def recherche1_f(liste,elt):#avec une boucle for for i in range(len(liste)-1,-1,-1) :
if liste[i] == elt:
return i return False
print(recherche1_f([0,1,2,3,4,4],4))
def recherche1_g(liste,elt):#avec une boucle while i=len(liste)-1
while i>=0 :
if liste[i] == elt:
return i i = i-1 return False
print(recherche1_g([0,1,2,3,4,4],4))
#%% question 2
def recherche2_a(liste,elt):
position=[]
presence = False
for i in range(len(liste)) : if liste[i] == elt:
position.append(i) presence = True return presence, position
print(recherche2_a([0,1,2,3,4,4],4)) def recherche2_b(liste,elt):
position=[]
presence = False i=0
while i<len(liste) : if liste[i] == elt:
position.append(i) presence = True i=i+1
return presence, position
print(recherche2_b([0,1,2,3,4,4],4))
"""rappels de la fonction enumerate"""
for index,valeur in enumerate([5,4]):
print(index,valeur)
def recherche2_c(liste,elt):
presence = False liste_index=[]
for index,valeur in enumerate(liste):
if valeur == elt:
presence = True
liste_index.append(index) return presence, liste_index print(recherche2_c([0,1,2,3,4,4],4))
#%% question 3 : recherche d'un maximum def maximum_1(liste):
maxi=liste[0]
index=0
for i in range(1,len(liste)):
if liste[i]>maxi:
maxi=liste[i]
index=i
return (print("le maximum {0} est à l'index {1}".format(maxi,index))) maximum_1([0,1,2,3,4])
"""on peut chercher les deux premiers maximums"""
def maximum_2(liste):
max1=liste[0]
index1=0 max2=liste[1]
index2=1 if max2<max1:
max1,max2=max2,max1
index1,index2=index2,index1 for i in range(2,len(liste)):
if liste[i]>max2:
max1=max2 max2=liste[i]
index1=index2
index2=i
elif liste[i]>max1 and liste[i]<max2:
max1=liste[i]
index1=i return (print(
"le 1e maximum est {0} et est à l'index {1},le 2e maximum est {2} et est à l'index {3}".
format(max1,index1,max2,index2))) maximum_2([10,1,2,3,4])
#%%% question 4 : recherche dichotomique d'un élément dans une liste triée def dichotomie (liste,elt):
debut=0
fin = len(liste)-1
while fin-debut >=0 :#> pose problème pour les extrémités de la liste ! milieu = (fin+debut)//2
if elt == liste[milieu]:
return print("l'élément {0} est dans la liste à la position {1}".format(elt,milieu))
elif elt>liste[milieu] : debut = milieu +1 else:
fin = milieu-1
return (print("l'élément n'est pas dans la liste")) dichotomie([0,1,2,3,4],0)
#%%%question 5 : recherche d'un mot dans une chaine de caractère def recherche_mot_1(chaine,mot):#par paquet
for i in range(len(chaine)-len(mot)+1):
index=i
if chaine[i:i+len(mot)] == mot:
return (print("le mot est dans la liste à la position {}".format(index) ))
print("le mot n'est pas dans la liste")
recherche_mot_1("abcdef","ef")
def recherche_mot_2(chaine,mot):#lettre par lettre for i in range(len(chaine)-len(mot)+1):
index=i j=0
while j<len(mot) and chaine[i+j] == mot[j]:
j=j+1
if j == len(mot):
return (print("le mot est dans la liste à la position {}".format(index) )) return print("le mot n'est pas dans la liste")
recherche_mot_2("abcdef","ef") recherche_mot_1("abcdef","ef")
Le problème avec cette recherche naïve c’est qu’elle est gourmande en complexité
temporelle. Si la chaîne est "….abcd…." et que le mot recherché est "abce" alors on peut affirmer dès la 1e itération que les 3 suivantes sont fausses. En allant comparer le motif après la lettre d on apsse d’une complexité en 𝑂(𝑚𝑛) à une complexité en 𝑂(𝑛
𝑚)
Exercice 4 : Terminaison, correction et complexité d’algorithme itératif
1) On a bien un variant de boucle : 𝑖. Cette quantité diminue à chaque itération jusqu’à la condition d’arrêt 𝑖 = 0 qui stoppe la boucle. Le programme se termine bien
2) L’invariant de boucle est la quantité 𝑟𝑒𝑠𝑢𝑙𝑡𝑎𝑡 qui toujours égale à la somme des éléments lus dans la liste 𝐿[𝑙𝑒𝑛(𝐿) − 1: ∶ −1]. On a
- En entrée de boucle, la liste 𝐿2 n’est pas encore lue : 𝑟𝑒𝑠𝑢𝑙𝑡𝑎𝑡 = 0 - Si on suppose vrai 𝑟𝑒𝑠𝑢𝑙𝑡𝑎𝑡 = 𝐿[−1] + ⋯ + 𝐿[𝑖]
Alors l’itération suivante 𝑟𝑒𝑠𝑢𝑙𝑡𝑎𝑡 = 𝐿[−1] + ⋯ + 𝐿[𝑖] + 𝐿[𝑖 − 1]
La relation est donc vraie à l’itération suivante
- La boucle se termine quand toute la liste a été entièrement parcourue. Il manque un élément dans la liste dans la programme proposé (il faut prendre l’index 0) :
𝑟𝑒𝑠𝑢𝑙𝑡𝑎𝑡 = 𝐿[−1] + ⋯ + 𝐿[𝑖] + 𝐿[𝑖 − 1] + ⋯ 𝐿[0]
𝑟𝑒𝑠𝑢𝑙𝑡𝑎𝑡 = ∑ 𝐿𝑙𝑢𝑒,𝑖 𝑖=0
𝑖=𝑙𝑒𝑛(𝐿)−1
𝐶𝑒 𝑞𝑢𝑖 𝑑𝑜𝑛𝑛𝑒 𝑙𝑒 𝑏𝑜𝑛 𝑟é𝑠𝑢𝑙𝑡𝑎𝑡
𝑇(𝑛) = 1 + 3𝑛 = 𝑂(𝑛) en prenant comme unité de coût les opérations d’addition, de soustraction, de de multiplication et de comparaisons de deux nombres
Exercice 5 : Tableau numpy
#%% numpy
#question 1 : création de tableau import numpy as np
tab=np.ones((10,10))*255 tab[4:7,4:7]=100
print(tab)
#question 2 : création du mask mask = tab[:,:]<200
#question 3: slicing x=np.arange(0,10,1) y=x
X,Y=np.meshgrid(x,y) x_moy=np.mean(X[mask]) y_moy=np.mean(Y[mask]) print(x_moy,y_moy)
#question 4 : filtrage tab_new=np.copy(tab) for i in range(1,9):
for j in range(1,9):
tab_new[i,j]=abs(tab[i-1,j]+tab[i+1,j]+tab[i,j+1]+tab[i,j-1]-4*tab[i,j]) tab_new2=np.copy(tab)
tab_new2[1:-1,1:-1]=abs(tab[0:-2,1:-1]+tab[2:,1:-1]+tab[1:-1,0:-2]+tab[1:-1,2:]- 4*tab[1:-1,1:-1])
print(tab_new) print(tab_new2)
from PIL import Image
photo=Image.fromarray(tab_new) photo.show()
Exercice 6 :
#%%plot
#question 1 et 2 import numpy as np
import matplotlib.pyplot as plt t=np.linspace(0,10,1000)
x=np.cos(2*np.pi*t) y=np.sin(2*np.pi*t)
plt.plot(t,x,label='x(t)') plt.plot(t,y,label='y(t)') plt.legend()
plt.grid() plt.xlabel("t") plt.ylabel("x") plt.show()
#question 3
x=np.linspace(-5,5,100) for a in [1,2,3,4]:
plt.plot(x,a*x**2) plt.show()
Exercice 7 :
1e interprétation 2e interprétation
On utilise une formule de différence finie à droite (erreur de troncature en 𝑂(ℎ)):
𝑑𝑦
𝑑𝑡≈𝑦𝑖+1−𝑦𝑖
𝑇𝑒
Euler explicite (potentiellement instable mais facile à écrire)):
𝑓(𝑡, 𝑦(𝑡)) ≈ 𝑓(𝑡𝑖, 𝑦𝑖) 𝑦𝑖+1≈ 𝑦𝑖+ 𝑇𝑒𝑓(𝑡𝑖, 𝑦𝑖) Euler implicite :
𝑓(𝑡, 𝑦(𝑡)) ≈ 𝑓(𝑡𝑖+1, 𝑦𝑖+1) 𝑦𝑖+1≈ 𝑦𝑖+ 𝑇𝑒𝑓(𝑡𝑖+1, 𝑦𝑖+1)
𝑑𝑦
𝑑𝑡= 𝑓(𝑡, 𝑦(𝑡)) 𝑑𝑦 = 𝑓(𝑡, 𝑦(𝑡))𝑑𝑡
∫ 𝑑𝑦
𝑦𝑖+1
𝑦𝑖
= ∫ 𝑓(𝑡, 𝑦(𝑡))𝑑𝑡
𝑡𝑖+1
𝑡𝑖
Approximation à gauche (erreur d’arrondi en 𝑂(ℎ)):
𝑦𝑖+1= 𝑦𝑖+ 𝑇𝑒𝑓(𝑡𝑖, 𝑦𝑖) Approximation à droite :
𝑓(𝑡, 𝑦(𝑡)) ≈ 𝑓(𝑡𝑖+1, 𝑦𝑖+1) 𝑦𝑖+1≈ 𝑦𝑖+ 𝑇𝑒𝑓(𝑡𝑖+1, 𝑦𝑖+1)
import numpy as np
import matplotlib.pyplot as plt Te=0.1
t=np.arange(0,10+Te,Te) s=np.ones(len(t))
for i in range(len(t)-1):
s[i+1]=s[i]*(1-Te) w=np.ones(len(t))
for i in range(len(t)-1):
w[i+1]=w[i]/(Te+1)
plt.plot(t,s,t,w,t,np.exp(-t)) plt.show()
Exercice 8 :
import numpy as np def f(x):
return np.sin(x) def d(x):
return np.cos(x) def dicho(a,b,f,e):
i=0
while abs(a-b)>e:
i=i+1 c=(a+b)/2
if f(a)*f(c)>0:
a=c else : b=c return c,i
print(dicho(3,3.5,f,0.001))
def newt(a,f,d,e):
i=0
while abs(f(a))>e:
a=a-f(a)/d(a) i=i+1
return a,i
print(newt(3,f,d,0.001))
