Algorithmique_et_programmation_part3_V2

224 vues

Publié le

0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
224
Sur SlideShare
0
Issues des intégrations
0
Intégrations
9
Actions
Partages
0
Téléchargements
3
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Algorithmique_et_programmation_part3_V2

  1. 1. LES BASES DE LA PROGRAMMATION AVEC PYTHON 3 Plateforme ANACONDA : Programmation avec l’EDI Spyder et les bibliothèques scientifiques Scipy Support de cours est rédigé par Dr. Emeric Tapachès. C’est une compilation de tutoriels disponibles sur http://pythonhosted.org/spyder/ et http://www.scipy-lectures.org/index.html Algorithmique et Programmation Partie III
  2. 2. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 1 | P a g e E m e r i c T a p a c h è s CONTENU Préambule ............................................................................................................................................... 2 1 Syper : Environnement de Développement Intégré ....................................................................... 2 2 Les bibliothèques scientifiques ScyPY............................................................................................. 3 3 NumPy ............................................................................................................................................. 4 3.1 Création de matrice à partir de fonctions............................................................................... 4 3.1.1 La fonction array() :......................................................................................................... 4 3.1.2 Les fonctions arange() et linspace() :............................................................................... 5 3.1.3 Autres fonctions permettant de créer des matrices....................................................... 6 3.2 Manipulation des matrices...................................................................................................... 6 3.2.1 Indexation........................................................................................................................ 6 3.2.2 Redimensionnement ....................................................................................................... 8 3.2.3 Calculs sur élément ......................................................................................................... 9 3.2.4 Calculs sur les lignes et les colonnes ............................................................................. 10 3.2.5 Calculs matriciels........................................................................................................... 11 4 Matplotlib...................................................................................................................................... 13
  3. 3. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 2 | P a g e E m e r i c T a p a c h è s PREAMBULE Tout d’abord, dans la première partie de ce cours l’histoire de l’informatique, l’architecture d’un ordinateur, la représentation de l’information et l’abstraction du langage machine ont été abordées. Ensuite, la deuxième partie a été consacrée aux bases de la programmation en Python « pure » à partir de l’invite de commande de Windows. Enfin, cette troisième partie du cours est consacrée à la programmation dans l’Environnement de Développement Intégré (IDE) Spyder et à la découverte des bibliothèques scientifiques SciPy. Pour suivre ce cours, il faut au préalable installer la plateforme ANACONDA (voir partie II du cours). 1 SYPER : ENVIRONNEMENT DE DEVELOPPEMENT INTEGRE D’après https://fr.wikipedia.org/wiki/Environnement_de_d%C3%A9veloppement , http://pythonhosted.org/spyder/. Un Environnement de Développement Intégré (EDI), ou IDE (Integrated Development Environment) est un ensemble d'outils destinés à programmer dans un langage donné, qui sont distribués ensemble. Il permet de manipuler les outils de programmation depuis une interface graphique simplifiée. Un EDI comporte au moins:  Une interface graphique qui permet notamment de sélectionner les fichiers, définir les options, lancer les opérations.  Un éditeur de code source avec coloration syntaxique.  La configuration d'un compilateur.  D'un éditeur de liens.  Un constructeur (outil make intégré). Il passe les commandes au compilateur et à l'éditeur de lien avec les fichiers sources ou les modules objets en paramètres.  Un outil de déboguage. Spyper est un EDI pour langage Python dédié aux calculs scientifiques. Certaines bibliothèques scientifiques de SciPy sont importées par défaut au lancement de l’EDI :  Numpy : import numpy as np  Matplotlib : from matplotlib import pyplot as plt / import matplotlib.pyplot as plt Vous pouvez tapez help(np) et help(plt) pour découvrir les fonctions associées à ces modules. Dans la suite de ce cours nous allons apprendre à utiliser certaines de ces fonctions. Par défaut, lors de son ouverture l’interface graphique de Spyder se compose de trois volets. Il a y :  L’éditeur de scripts Pyhton qui permet l’élaboration de programme de façon assisté (syntaxe automatique, identification des erreurs de syntaxe, aide dynamique, coloration spécifique du code, indentation automatique, analyse du code, débogage…).  L’explorateur qui permet d’explorer :
  4. 4. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 3 | P a g e E m e r i c T a p a c h è s o Les variables en mémoires en indiquant leur nom, leur type, leur taille et leur contenu. o Les fichiers et gérer leur emplacement.  La console ou l’invite de commande qui permet d’écrire les instructions à exécuter. La console IPython est proposée par défaut. Cette invite commande améliorée offre des possibilités de programmation assistée similaire à l’éditeur de scripts. FIGURE 1 : INTERFACE GRAPHIQUE DE SPYDER 2 LES BIBLIOTHEQUES SCIENTIFIQUES SCYPY Les bibliothèques sont en fait des modules comme vu dans la partie II de ce cours. Ces modules ou bibliothèques regroupent des fonctions optimisées liées à un même domaine. Ces modules ont été créés par d’autres développeurs avant vous. Cela permet d’utiliser et de ne pas réécrire des morceaux de code qui ont déjà écrit, très souvent, mieux par d’autres. D’après https://openclassrooms.com/courses/apprenez-a-programmer-en-python/qu-est-ce-que- python. Scipy est une communauté de développeurs qui ont décidé de réunir dans des packages des bibliothèques dédiées spécifiquement aux domaines des mathématiques, des sciences et de l’ingénierie. Scipy propose six packages principaux :
  5. 5. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 4 | P a g e E m e r i c T a p a c h è s FIGURE 2 : PRINCIPAUX PACKAGES DE SCIPY  NumPy est dédié principalement à l’algèbre linéaire et plus particulièrement aux calculs matriciels.  SciPy library est dédié à l’analyse. Ce package regroupe des outils permettant de faire, par exemple, du traitement de signal, de l’optimisation, des statistique…  Matplotlib offre de nombreux outils pour la visualisation/représentation de données en 2D et 3D.  Pandas offre des outils pour gérer et analyser des quantités importantes de données en les structurant de façon efficace.  SymPy permet de faire du calcul formel.  IPython : invite de commande interactive. 3 NUMPY D’après http://www.scipy-lectures.org/intro/numpy/index.html. La bibliothèque NumPy est déjà importée par défaut à l’ouverture de Spyder. Toutefois, si vous devez importer NumPy l’instruction courante est : >>> import numpy as np Les fonctions NumPy permettent de manipuler de façon optimisée des tableaux à n-dimension de nombres (entiers, décimaux, complexes…). 3.1 CREATION DE MATRICE A PARTIR DE FONCTIONS 3.1.1 LA FONCTION ARRAY() : 1-dimension : >>> a = np.array([0, 1, 2, 3]) >>> a array([0, 1, 2, 3]) >>> print(a) [0 1 2 3] >>> a.ndim 1 >>> a.shape (4,) >>> a.dtype dtype('int32')
  6. 6. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 5 | P a g e E m e r i c T a p a c h è s ndim permet de connaitre la dimension du tableau (la matrice). shape permet de connaitre la taille de la du tableau (la matrice). dtype permet de connaitre le type des éléments du tableau. 2-dimension : >>> b = np.array([[0., 1., 2.], [3., 4., 5.]]) >>> b array([[ 0., 1., 2.], [ 3., 4., 5.]]) >>> print(b) [[ 0. 1. 2.] [ 3. 4. 5.]] >>> b.ndim 2 >>> b.shape (2, 3) >>> b.dtype dtype('float64') 3-dimension : >>> c = np.array([ [ [1,1] , [2,2] ] , [ [3,3] , [4,4] ] , [ [5,5] , [6,6] ] ]) >>> c array([[[1, 1], [2, 2]], [[3, 3], [4, 4]], [[5, 5], [6, 6]]]) >>> c.ndim 3 >>> c.shape (3, 2, 2) 3.1.2 LES FONCTIONS ARANGE() ET LINSPACE() : arange() est analogue à la fonction range() (voir partie II du cours). Cette fonction permet de générer une progression arithmétique sous forme d’un vecteur. >>> a = np.arange(10) >>> print(a) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> >>> b = np.arange(1, 9, 2) # début, fin (exclu), pas >>> print(b) [1, 3, 5, 7] linspace() permet de générer un nombre fini de points régulièrement espacés entre deux bornes. >>> c = np.linspace(0, 1, 6 >>> print(c) [0. , 0.2, 0.4, 0.6, 0.8, 1. ] >>>
  7. 7. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 6 | P a g e E m e r i c T a p a c h è s >>> d = np.linspace(0, 1, 5, endpoint=False) #5 éléments, hormis la borne de fin >>> print(d) [ 0. , 0.2, 0.4, 0.6, 0.8] 3.1.3 AUTRES FONCTIONS PERMETTANT DE CREER DES MATRICES ones() permet de générer une matrice remplie avec la valeur 1 en format float. >>> a = np.ones((3, 3)) >>> print(a) [[ 1. 1. 1.] [ 1. 1. 1.] [ 1. 1. 1.]] zeros() permet des générer une matrice remplie avec la valeur 0 en format float. >>> b = np.zeros((2, 2)) >>> print(b) [[ 0. 0.] [ 0. 0.]] eyes() permet de générer une matrice identité (matrice carrée par conséquent). c = np.eye(3) >>> print(c) [[ 1. 0. 0.] [ 0. 1. 0.] [ 0. 0. 1.]] diag() permet de générer une matrice diagonale (matrice carrée par conséquent). >>> d = np.diag(np.array([1, 2, 3, 4])) >>> print(d) [[1 0 0 0] [0 2 0 0] [0 0 3 0] [0 0 0 4]] random.rand() permet de générer un vecteur avec des nombres aléatoires entre 0 et 1 selon une loi uniforme. >>> a = np.random.rand(4) >>> a [ 0.95799151, 0.14222247, 0.08777354, 0.51887998] 3.2 MANIPULATION DES MATRICES 3.2.1 INDEXATION >>> a = np.arange(10) >>> print(a)
  8. 8. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 7 | P a g e E m e r i c T a p a c h è s [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> a[0], a[2], a[-1] (0, 2, 9) >>> >>> a[2:9:3] # [début:fin:pas] array([2, 5, 8]) >>> >>> a[:4] array([0, 1, 2, 3]) >>> >>> a[1:3] array([1, 2]) >>> >>> a[::2] array([0, 2, 4, 6, 8]) >>> >>> a[3:] array([3, 4, 5, 6, 7, 8, 9]) Même logique que pour les chaines de caractères (voir partie II) du cours. >>> a = np.diag(np.arange(3)) >>> print(a) [[0 0 0] [0 1 0] [0 0 2]] >>> a[1, 1] # élément de la deuxième ligne, deuxième colonne 1 >>> a[2, 1] = 10 # modification de l’élément en troisième ligne, deuxième colonne >>> >>> print(a) [[ 0, 0, 0], [ 0, 1, 0], [ 0, 10, 2]] >>> >>> a[1] # deuxième ligne [0, 1, 0] Exemple par l’image :
  9. 9. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 8 | P a g e E m e r i c T a p a c h è s FIGURE 3 : INDEXATION DE TABLEAU (SOURCE : SCIPY) 3.2.2 REDIMENSIONNEMENT Passez d’une matrice à un vecteur avec la fonction ravel() : >>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> print(a) [[1 2 3] [4 5 6]] >>> >>> a.ravel() array([1, 2, 3, 4, 5, 6]) >>> print(a) #la fonction ravel ne modifie pas les dimension de a [[1 2 3] [4 5 6]] >>> >>> a = a.ravel() #a a été passé en vecteur >>> print(a) [1 2 3 4 5 6] Modifiez les dimensions d’une matrice avec la fonction reshape() : >>> a = np.array( [[1,2,3],[4,5,6]] ) >>> a.shape (2, 3) >>> print(a) [[1 2 3] [4 5 6]] >>> print(a.reshape(3,2)) [[1 2] [3 4] [5 6]] >>> print(a.reshape(6,1)) [[1]
  10. 10. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 9 | P a g e E m e r i c T a p a c h è s [2] [3] [4] [5] [6]] Concaténer des matrices avec la fonction np.concatenate() : >>> a array([[1, 1], [1, 1]]) >>> b array([[2, 2], [2, 2]]) >>> >>> c = np.concatenate((a,b),axis=1) >>> print(c) [[1 1 2 2] [1 1 2 2]] >>> c = np.concatenate((a,b),axis=0) >>> print(c) [[1 1] [1 1] [2 2] [2 2]] 3.2.3 CALCULS SUR ELEMENT Opération sur les éléments : >>> a = np.array([1, 2, 3, 4]) >>> a + 1 array([2, 3, 4, 5]) >>> 2**a array([ 2, 4, 8, 16]) >>> b = np.ones(4) + 1 >>> a - b array([-1., 0., 1., 2.]) >>> a * b array([ 2., 4., 6., 8.]) >>> a = np.arange(5) >>> print(np.sin(a)) [ 0. , 0.84147098, 0.90929743, 0.14112001, -0.7568025 ] >>> >>> print(np.log(a)) [ -inf, 0. , 0.69314718, 1.09861229, 1.38629436] >>> >>> print(np.exp(a)) [ 1. , 2.71828183, 7.3890561 , 20.08553692, 54.59815003] Test sur les éléments: La fonction nonzeros() est très utile pour tester les éléments d’une matrice. Cette fonction retourne l’indice des éléments qui satisfassent la condition :
  11. 11. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 10 | P a g e E m e r i c T a p a c h è s >>> a = np.random.rand(25).reshape(5,5) >>> print(a) [[ 0.12069897 0.35463466 0.22703164 0.49814117 0.55222531] [ 0.01628109 0.84083704 0.0994604 0.47515089 0.70177187] [ 0.79003425 0.96155964 0.73164089 0.04653678 0.60433922] [ 0.71714583 0.49786245 0.11338165 0.10164041 0.28502373] [ 0.46506279 0.3845595 0.75339083 0.99563566 0.3884443 ]] >>> >>> ind = np.nonzero( a >= 0.5 ) >>> >>> print(ind) (array([0, 1, 1, 2, 2, 2, 2, 3, 4, 4], dtype=int64), array([4, 1, 4, 0, 1, 2, 4, 0, 2, 3], dtype=int64)) >>> >>> a[ind[0], ind[1]] array([ 0.55222531, 0.84083704, 0.70177187, 0.79003425, 0.96155964, 0.73164089, 0.60433922, 0.71714583, 0.75339083, 0.99563566]) Autre solution : l’indexation conditionnelle. >>> a = np.random.rand(25).reshape(5,5) >>> print(a) [[ 0.12069897 0.35463466 0.22703164 0.49814117 0.55222531] [ 0.01628109 0.84083704 0.0994604 0.47515089 0.70177187] [ 0.79003425 0.96155964 0.73164089 0.04653678 0.60433922] [ 0.71714583 0.49786245 0.11338165 0.10164041 0.28502373] [ 0.46506279 0.3845595 0.75339083 0.99563566 0.3884443 ]] >>> >>> ind = np.nonzero( a >= 0.5 ) >>> >>> a[(a>=0.5)] array([ 0.55222531, 0.84083704, 0.70177187, 0.79003425, 0.96155964, 0.73164089, 0.60433922, 0.71714583, 0.75339083, 0.99563566]) >>> >>> a >= 0.5 array([[False, False, False, False, True], [False, True, False, False, True], [ True, True, True, False, True], [ True, False, False, False, False], [False, False, True, True, False]], dtype=bool) 3.2.4 CALCULS SUR LES LIGNES ET LES COLONNES Somme : >>> a = np.arange(25).reshape((5,5)) >>> print(a) [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14] [15 16 17 18 19] [20 21 22 23 24]] >>> >>> np.sum(a) 300
  12. 12. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 11 | P a g e E m e r i c T a p a c h è s >>> >>> np.sum(a, axis=0) array([50, 55, 60, 65, 70]) >>> np.sum(a, axis=1) array([ 10, 35, 60, 85, 110]) La syntaxe est la même pour les fonctions suivantes :  max() retourne le plus grand nombre d’une matrice ou de chaque ligne ou de chaque colonne,  min() retourne le plus petit nombre d’une matrice ou de chaque ligne ou de chaque colonne,  mean() retourne la moyenne d’une matrice ou de chaque ligne ou de chaque colonne,  median() retourne la médiane d’une matrice ou de chaque ligne ou de chaque colonne,  std() retourne l’écart-type d’une matrice ou de chaque ligne ou de chaque colonne,  argmin() retourne l’indice de la valeur minimum d’une matrice ou de chaque ligne ou de chaque colonne,  argmax() retourne l’indice de la valeur maximum d’une matrice ou de chaque ligne ou de chaque colonne. 3.2.5 CALCULS MATRICIELS Exercice : A l’aide de boucle « for », créer une fonction permettant de faire le produire de deux matrices et de retourner le résultat de ce produit. La fonction permettant de faire le produit matriciel existe déjà dans NumPy, c’est la fonction np.dot() : >>> a = np.arange(6).reshape(2,3) >>> print(a) [[0 1 2] [3 4 5]] >>> >>> b = np.arange(15).reshape(3,5) >>> print(b) [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]] >>> >>> c = np.dot(a,b) >>> print(c) [[ 25 28 31 34 37] [ 70 82 94 106 118]] >>> >>> c = a.dot(b) #autre syntaxe >>> print(c) [[ 25 28 31 34 37] [ 70 82 94 106 118]] >>> >>> c = b.dot(a) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: shapes (3,5) and (2,3) not aligned: 5 (dim 1) != 2 (dim 0)
  13. 13. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 12 | P a g e E m e r i c T a p a c h è s La transposé d’une matrice s’obtient avec la fonction np.tanspose() ou a.T : >>> a = np.arange(15).reshape(3,5) >>> print(a) [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]] >>> >>> a.T array([[ 0, 5, 10], [ 1, 6, 11], [ 2, 7, 12], [ 3, 8, 13], [ 4, 9, 14]]) >>> >>> a array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]]) >>> >>> np.transpose(a) array([[ 0, 5, 10], [ 1, 6, 11], [ 2, 7, 12], [ 3, 8, 13], [ 4, 9, 14]]) >>> >>> a array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]]) Le déterminant d’une matrice s’obtient avec la fonction np.linalg.det() : >>> a = np.arange(4) + 1 >>> a = a.reshape(2,2) >>> print(a) [[1 2] [3 4]] >>> np.linalg.det(a) -2.0000000000000004 L’inverse d’une matrice inversible s’obtient avec la fonction np.linalg.inv() : >>> a = np.arange(4) + 1 >>> a = a.reshape(2,2) >>> print(a) [[1 2] [3 4]] >>> np.linalg.inv(a) array([[-2. , 1. ], [ 1.5, -0.5]]) Résolution d’un système matriciel : Par exemple, résolution du système suivant :
  14. 14. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 13 | P a g e E m e r i c T a p a c h è s 0 1 0 1 3 9 (S) 2 8 x x a x b x x          >>> a = np.array([[3,1], [1,2]]) >>> b = np.array([9,8]) >>> x = np.linalg.solve(a, b) >>> x array([ 2., 3.]) D’où 0 2.0x  et 1 3.0x  . 4 MATPLOTLIB Matplotlib offre plusieurs fonctionnalités pour créer des graphiques 2-D et 3-D. L’instruction pour appeler ce package est : from matplotlitb import pyplot as plt Tracer une courbe revient à tracer une série de points repérés par des coordonnées. Traçons les fonctions sinus et cosinus entre –PI et PI. D’abord, il faut définir le vecteur correspondant aux abscisses (première dimension). X = np.linspace(-np.pi, np.pi, 100) #vecteur de 100 éléments entre –PI et PI Puis, l’on créé le vecteur correspondant aux ordonnées (deuxième dimension), tel que X  cos(X) et X  sin(X) : C, S = np.cos(X), np.sin(X) #C, S sont deux vecteurs de 100 éléments Ensuite, nous utilisons la fonction plt.plot() pour tracer les valeurs des ordonnées en fonction des valeurs des abscisses, tel que : >>> plt.plot(X, C) >>> plt.plot(X, S) La figure suivante doit apparaitre :
  15. 15. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 14 | P a g e E m e r i c T a p a c h è s La figure apparait avec des paramètres d’affichage par défaut (taille, couleur, épaisseurs des traits…). Il est possible de modifier ces paramètres d’affichage. Changez la couleur, l’épaisseur et le style du trait… >>> plt.plot(X, C, color="black", linewidth=2.5, linestyle="-") >>> plt.plot(X, S, color="red", linewidth=4, linestyle="-") Pour changer l’affichage des courbes, il faut changer les valeurs des paramètres par défaut à l’aide de mots-clés. Voici la liste des mots-clés : FIGURE 4 : PROPRIÉTÉS D'AFFICHAGE DES LIGNES Il y a plusieurs styles de lignes. Pour y accéder il faut indiquer l’un des symboles présentés sur la première ligne de la figure suivante :
  16. 16. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 15 | P a g e E m e r i c T a p a c h è s FIGURE 5 : STYLE DE LIGNE De même pour les marqueurs : FIGURE 6 : LES MARQUEURS Il est possible de modifier les limites d’affichage, par exemple : >>> plt.xlim(0,np.pi) >>> plt.ylim(0,1) >>> >>> # ou >>> >>> plt.xlim(X.min() * 1.1, X.max() * 1.1) >>> plt.ylim(C.min() * 1.1, C.max() * 1.1)
  17. 17. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 16 | P a g e E m e r i c T a p a c h è s Il est possible de contrôler les valeurs affichées en abscisse et en ordonnées : >>> plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi]) >>> plt.yticks([-1, 0, +1]) ou de mettre du texte : >>> plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi], [r'$-pi$', r'$-pi/2$', r'$0$', r'$+pi/2$', r'$+pi$']) >>> >>> plt.yticks([-1, 0, +1], [r'$-1$', r'$0$', r'$+1$']) Il est possible de modifier la position des axes : >>> ax = plt.gca() # gca stands for 'get current axis' >>> ax.spines['right'].set_color('none') >>> ax.spines['top'].set_color('none') >>> ax.xaxis.set_ticks_position('bottom') >>> ax.spines['bottom'].set_position(('data',0)) >>> ax.yaxis.set_ticks_position('left') >>> ax.spines['left'].set_position(('data',0)) Pour ajouter une légende, il faut d’abord associer à chaque courbe une chaine de caractères à la propriété « label » : plt.plot(X, C, color="blue", linewidth=2.5, linestyle="-", label="cosinus") plt.plot(X, S, color="red", linewidth=2.5, linestyle="-", label="sinus") Ensuite, il faut appeler la fonction « legend » : plt.legend(loc='upper left') Le paramètre « loc » pour « location » permet d’indiquer la position de la légende.
  18. 18. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 17 | P a g e E m e r i c T a p a c h è s L’on peut afficher plusieurs graphiques sur une même figure à l’aide de la fonction plt.subplot(), par exemple pour : >>> def f(t): ... return np.exp(-t) * np.cos(2*np.pi*t) ... >>> t1 = np.arange(0.0, 5.0, 0.1) >>> t2 = np.arange(0.0, 5.0, 0.02) >>> >>> plt.figure(1) >>> plt.subplot(211) >>> plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k') >>> >>> plt.subplot(212) >>> plt.plot(t2, np.cos(2*np.pi*t2), 'r--') >>> plt.show() >>> L’on obtient : Disposition des graphiques avec plt.subplot() : La fonction plt.imshow() permet d’afficher une fonction à deux variables ou les valeurs d’un tableau, par exemple : >>> def f(x, y): ... return (1 - x / 2 + x ** 5 + y ** 3) * np.exp(-x ** 2 - y ** 2) ... >>> n = 10 >>> x = np.linspace(-3, 3, 4 * n) >>> y = np.linspace(-3, 3, 3 * n)
  19. 19. A l g o r i t h m i q u e e t p r o g r a m m a t i o n – P a r t i e I I 18 | P a g e E m e r i c T a p a c h è s >>> X, Y = np.meshgrid(x, y) >>> plt.imshow(f(X, Y)) >>> plt.show() L’on obtient : D’autres exemples de graphiques sont présentés sur le lien suivant : http://www.scipy- lectures.org/intro/matplotlib/matplotlib.html#other-types-of-plots-examples-and-exercises

×