Q1. Question à faire sur papier. On dispose d'une liste L = [8, 3, 4, 7, 5, 1, 2]
.
Donner et commenter sans utiliser l'ordinateur le résultat des instructions L[2 : ]
, L[ : 4]
, L[1 : 5]
, L[ : ]
, L[ : : 2 ]
, L[ : : 3 ]
,
L[ : : -1 ]
et L[ : : -2 ]
.
L = [8, 3, 4, 7, 5, 1, 2]
print(L[2 : ])
print(L[ : 4])
print(L[1 : 5])
print(L[ : ])
print(L[ : : 2 ])
print(L[ : : 3 ])
print(L[ : : -1 ])
print(L[ : : -2 ])
[4, 7, 5, 1, 2] [8, 3, 4, 7] [3, 4, 7, 5] [8, 3, 4, 7, 5, 1, 2] [8, 4, 5, 2] [8, 7, 2] [2, 1, 5, 7, 4, 3, 8] [2, 5, 4, 8]
Q2. Ecrire une fonction somme(n)
qui reçoit en entrée un entier n
et renvoie la somme des entiers de 1
à n
.
Par exemple somme(10)
doit renvoyer 55
.
def somme(n) :
s = 0
for k in range(1,n+1) : # k va de 1 à n
s = s+k
return s
print(somme(10))
55
Q3. Ecrire une fonction seuil(K)
qui reçoit en entrée un flottant K
et renvoie le plus petit entier n
tel que le carré de la somme des entiers de 1
à n
dépasse K
.
Par exemple seuil(76200)
doit renvoyer 24
.
On pourra utiliser la fonction de Q2 ainsi qu'une boucle while.
def seuil(K) :
n = 0
while somme(n)**2 <= K :
n = n+1
return n
seuil(76200)
24
Q4. Ecrire une fonction sommeV2(L)
qui renvoie la somme des éléments d'une liste L
de nombres.
Par exemple sommeV2([1, 2, 3, 4, 5])
doit renvoyer 15
.
def sommeV2(L) :
s = 0
for x in L :
s = s+x
return s
print(sommeV2([1, 2, 3, 4, 5]))
15
Q5. Ecrire une fonction occurrence(chaine, c)
qui renvoie la le nombre d'occurrences du caractère c
dans la chaîne de caractères chaine
.
Par exemple occurrence('eabceabce', 'e')
doit renvoyer 3
.
def occurrence(chaine, c) :
compteur = 0
for caractere in chaine :
if caractere == c :
compteur = compteur+1
return compteur
print(occurrence('eabceabce', 'e'))
3
En mathématiques une suite récurrente est définie par la donnée de son premier terme $u_0$ et par une formule de récurrence $u_{n+1}=f(u_n)$.
Par exemple $u_0=1$ et $u_{n+1}=n\times u_n$.
En python on peut calculer $u_{10}$ ainsi:
n = 10
u = 1
for k in range(1, n+1):
u = k*u
print(u)
Notez notamment que tous les termes de la suite sont enregistrés les uns après les autres dans la même variable u
.
La ligne u = k*u
doit être comprise comme u_nouveau = k * u_ancien
.
Q6. On définit une suite par $u_0=a$ et $u_{n+1}=\frac{1}{2}\left(u_n+\frac{a}{u_n}\right)$.
Ecrire une fonction heron(n, a)
qui prend en argument un entier n
et un flottant a
et renvoie la valeur de $u_n$.
Cette méthode décrite dans un livre par Héron au 19e siècle permet de calculer une très bonne valeur approchée de $\sqrt{a}$. On pense qu'elle était déjà connue des mathématiciens égyptiens.
def heron(n, a) :
u = a # cas n=0
for k in range(1, n+1) :
u = (u+a/u)/2
return u
print(heron(10, 2))
1.414213562373095
Q7. Ecrire une fonction sans argument test(epsilon)
qui renvoie le plus petit entier n
tel que la différence entre:
a=2
donnée par la méthode de Héron (cf Q6)et:
sqrt(2)
donnée par le module math
soit inférieur au flottant epsilon
.
Par exemple test(10**(-10))
doit renvoyer 4
: $u_4$ est une valeur approchée de $\sqrt{2}$ avec une précision d'au moins $10^{-10}$.
from math import sqrt
def test(epsilon) :
n = 0
while abs( heron(n, 2) - sqrt(2) ) > epsilon :
n = n+1
return n
print(test(10**(-10)))
4
Q8. Dans un célèbre article, le mathématicien Français B. Mandelbrot, père de la géométrie fractale, a montré que de nombreuses structures obéissent à des règles de construction mathématiques : plantes, coquillages, polymères, colloïdes, ... vous allez le montrer sur un exemple simple !
On pose $(x_0,y_0)=(0.5,0.)$ et: $$(x_{n+1},y_{n+1})=\left\{\begin{array}{ll} ( 0.05\times x_n,0.6\times y_n)&\hbox{avec une probabilité de }10\%\\ ( 0.05\times x_n,-0.5\times y_n+1.0)&\hbox{avec une probabilité de }10\%\\ ( 0.46\times x_n-0.32\times y_n,0.39\times x_n+0.38\times y_n+0.6)&\hbox{avec une probabilité de }20\%\\ ( 0.47\times x_n-0.15\times y_n,0.17\times x_n+0.42\times y_n+1.1)&\hbox{avec une probabilité de }20\%\\ ( 0.43\times x_n+0.28\times y_n,-0.25\times x_n+0.45\times y_n+1.0)&\hbox{avec une probabilité de }20\%\\ ( 0.42\times x_n+0.26\times y_n,-0.35\times x_n+0.31\times y_n+0.7)&\hbox{avec une probabilité de }20\%\end{array}\right.$$
Pour le choix aléatoire, on tire au hasard un réel r
de l'intervalle $[0,1]$ avec l'instruction uniform(0,1)
du module random
. Si $0 < r \leq 0.1$, c'est la première de ces équations
qui est retenue, sinon si $0.1 < r \leq 0.2$, ce sera la seconde, $\dots$ etc.
Les valeurs $x_0$, $x_1$, $\dots$, $x_n$ sont stockés dans une liste ${\tt abscisses}$ et les valeurs $y_0$, $y_1$, $\dots$, $y_n$ dans une liste ${\tt ordonnees}$.
Avec $30\,000$ points on obtient la figure suivante:
Compléter le code suivant pour obtenir cette figure:
from random import uniform
import matplotlib.pyplot as plt
x= 0.5
y= 0.
ordonnees=[]
abscisses=[]
for i in range( 1 , 30000 ):
r = uniform(0, 1) #génération d'un nombre au hasard
if r<=0.1:
x, y = x*0.05 , 0.6*y
elif r>0.1 and r<=0.2:
x, y = 0.05*x , -0.5*y+1.0
elif r>0.2 and r<=0.4 :
x, y = 0.46*x-0.32*y ,0.39*x+0.38*y+0.6
elif r>0.4 and r<=0.6 :
x, y = 0.47*x-0.15*y ,0.17*x+0.42*y+1.1
elif r>0.6 and r<=0.8 :
x, y = 0.43*x+0.28*y ,-0.25*x+0.45*y+1.0
else:
x, y = 0.42*x+0.26*y ,-0.35*x+0.31*y+0.7
abscisses.append(x)
ordonnees.append(y)
#affichage des points
ax=plt.gca() # on créer des axes
ax.set_xticks([]); ax.set_yticks([]) # on enlève la graduation des axes
plt.plot(abscisses,ordonnees,'g.') # on affiche les points à partir des listes abscisses et ordonnées
plt.show() # on affiche la figure
Q9.
Considérons le signal continu $m(t)$ échantillonné à la fréquence $f_e = 1/T_e$. La qualité du signal peut être nettement améliorée en réalisant une opération de filtrage de $m(t)$ par un filtre afin « d’isoler » le signal du bruit.
Le filtrage
de la séquence discrète $(m_i)_{i=0,\dots,M-1}$ par le filtre numérique de coefficients $(b_i)_{i=0,\dots,N−1}$ est le résultat $(s_i)_{i=0,\dots,M-1}$ du traitement défini par les expressions
suivantes:
$$s_n=0\hbox{ pour }n=0,\dots,N-2$$
et:
$$s_n=\sum_{i=0}^{N-1}b_i\times m_{n-i}\hbox{ pour }n=N-1,\dots,M-1$$
Dans cette expression nous avons :
Ecrire une fonction filtrage(b, m)
qui a pour arguments d’entrée la liste des coefficients du filtre b
et la séquence des échantillons m
, et qui renvoie la liste s
.
def filtrage(b, m):
N = len(b)
M = len(m)
s = [0]*M
for n in range(N-1, M):
for i in range(N):
s[n] += b[i]*m[n-i]
return s