TP Python Complexité temporelle 1/2

PCSI – IPT G. Monod TP_complexite1.docx 1/2
TP Python Complexité temporelle 1/2
Graphes avec Python - Module matplotlib.pyplot (à suivre…) Savoir-faire
Tracé minimal 2D
import matplotlib.pyplot as plt # chargement du module sous l’alias (nom court) "plt"
abscisses = une liste
ordonnees1 = une liste
plt.plot(abscisses, ordonnees1)
plt.show() # facultatif
Pour tracer deux courbes on ajoute une instruction
plt.plot(abscisses, ordonnees2) .
Pour des tracés en couleur :
plt.plot(abscisses, ordonnees1, color='red')
plt.plot(abscisses, ordonnees2, color='blue')
1. Graphe de f(x) = x**2 et g(x) = x**(1/2)
1.1. Créer une liste Lx = [0, 0.1, 0.2, …, 9.8, 9.9, 10] (on définira cette liste par compréhension…).
Attention les valeurs start, stop, step dans range(start, stop, step) ne peuvent être qu’entières.
1.2. Créer la liste Ly_car constituée des nombres précédents élevés au carré : Ly_car = [0
2
, 0.1
2
, 0.2
2
, …, 9.8
2
, 9.9
2
, 10
2
].
Créer de même la liste Ly_rac des racines carrées.
1.3. Tracer les graphes de f(x) et g(x).
1.4. Ajouter l’instruction plt.ylim(ymax=15) avant plt.show() ; quel est le rôle de cette instruction ?
Étude expérimentale de la complexité
La complexité temporelle est une évaluation du nombre d’opérations effectuées par un algorithme indépendamment de la
machine sur laquelle il est exécuté. Ce nombre d’opérations est lié au temps d’exécution de l’algorithme mais ce temps est différent
pour chaque machine, voire d’une mesure à une autre pour un système multitâche.
Dans ce TP, on n’évaluera pas la complexité mais on comparera des temps d’exécution (le temps d’exécution en lui-même n’est
pas une grandeur pertinente puisqu’il dépend de la machine sur laquelle l’algorithme est exécuté) afin d’évaluer les performances de
différents algorithmes. Complément Python
Pour accéder au temps-machine, il suffit d’importer le module time puis de faire appel à la fonction clock( ) qui renvoie un flottant
représentant le temps écoulé en secondes depuis le précèdent appel de clock( ).
Résolution supérieure à une microseconde sur Windows, fonction utilisée pour les tests de rapidité sur les systèmes Unix.
On peut également utiliser la fonction time( ) qui retourne le temps écoulé depuis une origine fixée par convention mais avec
certains systèmes la précision n’est pas supérieure à une seconde.
Mesure d’un temps écoulé avec clock( )
from time import clock # chargement du module sans alias
t1 = clock()
…
Instructions
….
t2 = clock()
T = t2-t1 # temps nécessaire pour effectuer le bloc d’instructions entre t1 et t2

PCSI – IPT G. Monod TP_complexite1.docx 2/2
2. Comparaison de trois algorithmes
2.1. Taper les fonctions suivantes :
def f1(n):
td = clock()
L = []
for k in range(n):
L+=[k]
tf = clock()
return tf-td
def f2(n):
td = clock()
L = []
for k in range(n):
L.append(n)
tf = clock()
return tf-td
def f3(n):
td = clock()
[k for k in range(n)]
tf = clock()
return tf-td
2.2. Justifier que ces trois fonctions effectuent toutes le même travail.
2.3. Comparer les temps de calculs de f1(N), f2(N), f3(N) avec N = 10**6. Justifier dans la mesure du possible.
3. Complexité expérimentale
3.1. Quelle est la complexité temporelle de chacune de ces trois fonctions ?
3.2. Superposer les graphes f1(x), f2(x) et f3(x) pour x = [10
0
, 10
1
, … , 10
6
].
3.3. Que peut-on conclure quant à la complexité temporelle de ces fonctions en observant les graphes ?