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 = [02, 0.12, 0.22, …, 9.82, 9.92, 102]. 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 PCSI – IPT G. Monod # temps nécessaire pour effectuer le bloc d’instructions entre t1 et t2 TP_complexite1.docx 1/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 = [100, 101, … , 106]. 3.3. Que peut-on conclure quant à la complexité temporelle de ces fonctions en observant les graphes ? PCSI – IPT G. Monod TP_complexite1.docx 2/2