Le document présente les bases de la programmation en Python 3 à l'aide de la plateforme Anaconda et de l'EDI Spyder, ainsi que l'utilisation des bibliothèques scientifiques comme SciPy et NumPy. Il couvre des thèmes tels que la création et la manipulation de matrices, ainsi que l'utilisation d'outils de visualisation avec Matplotlib. Les lecteurs sont guidés à travers divers tutoriels pour apprendre à utiliser efficacement ces outils et bibliothèques dans un contexte de calcul scientifique.

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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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