Python - cours intensif pour les scientifiques

Python - cours intensif pour les scientifiques
Partie 2 : Modules NumPy et SciPy
Par Rick Muller - Raphaël Seban (traducteur)
Date de publication : 2 août 2014
Pour de nombreux scientifiques, Python est LE langage de programmation par excellence,
car il offre de grandes possibilités en analyse et modélisation de données scientifiques avec
relativement peu de charge de travail en termes d'apprentissage, d'installation ou de temps
de développement. C'est un langage que vous pouvez intégrer en un week-end, puis utiliser
une vie durant.
Retrouvez la première partie de cet article :
•Partie 1 : Présentation de Python
Les commentaires et les suggestions d'amélioration sont les bienvenus, alors, après votre
lecture, n'hésitez pas.
En complément sur Developpez.com
•Condensé Python pour les scientifiques - Partie 1
•Tutoriel Matplotlib

Python - cours intensif pour les scientifiques par Rick Muller
- 2 -
Le contenu de cet article est rédigé par Rick Muller et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les
Mêmes Conditions 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.
http://python.developpez.com/tutoriels/cours-intensif-scientifique/module-numpy-scipy/
I - Introduction..............................................................................................................................................................3
II - Tableaux et matrices..............................................................................................................................................3
III - Espace linéaire, fonctions matricielles et tracés...................................................................................................5
IV - Opérations sur les matrices................................................................................................................................. 6
V - Solveurs matriciels.................................................................................................................................................7
VI - Exemple : différences finies..................................................................................................................................8
VII - Oscillateur harmonique unidimensionnel utilisant les différences finies..............................................................9
VIII - Fonctions spéciales.......................................................................................................................................... 11
IX - Résolution par les moindres carrés................................................................................................................... 14
X - Monte Carlo, nombres aléatoires et calcul de Pi................................................................................................19
XI - Intégrales............................................................................................................................................................ 23
XII - Transformée de Fourier rapide et traitement du signal.....................................................................................24
XIII - Remerciements................................................................................................................................................. 25
XIV - Remerciements Developpez............................................................................................................................ 26

Python - cours intensif pour les scientifiques par Rick Muller
- 3 -
Le contenu de cet article est rédigé par Rick Muller et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les
Mêmes Conditions 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.
http://python.developpez.com/tutoriels/cours-intensif-scientifique/module-numpy-scipy/
I - Introduction
La librairie Numpy contient des fonctions essentielles pour traiter les tableaux, les matrices et les opérations de type
algèbre linéaire avec Python. La librairie Scipy contient des fonctions supplémentaires pour l'optimisation de calculs,
des fonctions spéciales, etc. Les deux comprennent des modules écrits en C et en Fortran de manière à les rendre
aussi rapides que possible. Utilisées ensemble, ces librairies offrent au langage Python, à peu de chose près, les
mêmes capacités que Matlab™. Les habitués de ce logiciel trouveront sans doute un grand intérêt à lire le guide
Numpy à l'attention des utilisateurs Matlab™.
Cette partie est consultable également au format « notebook » en suivant le lien : Notes: Partie
2 - Modules NumPy et SciPy .
II - Tableaux et matrices
L'un des points communs fondamentaux de Numpy et de Scipy est leur aptitude à gérer les tableaux et les matrices.
Vous pouvez créer des tableaux à partir de listes Python (list ou []) grâce à la fonction objet array():
In :
array([1,2,3,4,5,6])
Out :
array([1, 2, 3, 4, 5, 6])
Vous pouvez passer en second argument de la fonction array() le type numérique souhaité. Vous trouverez une liste
exhaustive de ces types à cet endroit. Certains types ont un équivalent qui se résume en une seule lettre. Les plus
courants sont 'd' (nombre à virgule flottante à double précision), 'D' (nombre complexe à double précision) et 'i' (int32,
entier signé et codé sur 32 bits, valeurs allant de -2 147 483 648 à [phone]).
Exemples :
In :
array([1,2,3,4,5,6],'d')
Out :
array([ 1., 2., 3., 4., 5., 6.])
In :
array([1,2,3,4,5,6],'D')
Out :
array([ 1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j])
In :
array([1,2,3,4,5,6],'i')
Out :
array([1, 2, 3, 4, 5, 6], dtype=int32)
Pour créer une matrice, vous pouvez utiliser array() avec des listes de listes Python :

Python - cours intensif pour les scientifiques par Rick Muller
- 4 -
Le contenu de cet article est rédigé par Rick Muller et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les
Mêmes Conditions 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.
http://python.developpez.com/tutoriels/cours-intensif-scientifique/module-numpy-scipy/
In :
array([[0,1],[1,0]],'d')
Out :
array([[ 0., 1.],
[ 1., 0.]])
Vous pouvez aussi générer des matrices vides (remplies de zéros) de tailles arbitraires, y compris des tableaux
unidimensionnels que Numpy traitera comme des tableaux à une seule ligne grâce à la fonction objet zeros():
In :
zeros((3,3),'d')
Out :
array([[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])
Le premier argument de la fonction est un tuple (m_lignes, n_colonnes) et le second argument définit le type de
données à utiliser, comme pour la fonction objet array(). Ainsi, vous pouvez initialiser un tableau simple (une ligne)
de cette façon :
In :
zeros(3,'d')
Out :
array([ 0., 0., 0.])
In :
zeros((1,3),'d')
Out :
array([[ 0., 0., 0.]])
ou des tableaux en colonne :
In :
zeros((3,1),'d')
Out :
array([[ 0.],
[ 0.],
[ 0.]])
Il y a aussi la fonction objet identity() qui produit, comme vous pourriez vous y attendre :
In :
identity(4,'d')
Out :
array([[ 1., 0., 0., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 0., 0., 1.]])
de même que la fonction objet ones() qui fait la même chose que zeros(), sauf qu'elle initialise la matrice avec des
uns (1).

Python - cours intensif pour les scientifiques par Rick Muller
- 5 -
Le contenu de cet article est rédigé par Rick Muller et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les
Mêmes Conditions 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.
http://python.developpez.com/tutoriels/cours-intensif-scientifique/module-numpy-scipy/
III - Espace linéaire, fonctions matricielles et tracés
La fonction objet linspace(start, end) crée un tableau espace linéaire de points de valeurs comprises entre start
(inclus) et end (inclus).
In :
linspace(0,1)
Out :
array([ 0. , 0.02040816, 0.04081633, 0.06122449, 0.08163265,
0.10204082, 0.12244898, 0.14285714, 0.16326531, 0.18367347,
0.20408163, 0.2244898 , 0.24489796, 0.26530612, 0.28571429,
0.30612245, 0.32653061, 0.34693878, 0.36734694, 0.3877551 ,
0.40816327, 0.42857143, 0.44897959, 0.46938776, 0.48979592,
0.51020408, 0.53061224, 0.55102041, 0.57142857, 0.59183673,
0.6122449 , 0.63265306, 0.65306122, 0.67346939, 0.69387755,
0.71428571, 0.73469388, 0.75510204, 0.7755102 , 0.79591837,
0.81632653, 0.83673469, 0.85714286, 0.87755102, 0.89795918,
0.91836735, 0.93877551, 0.95918367, 0.97959184, 1. ])
Si vous fournissez un troisième argument à linspace(start, end, nb_points), celui-ci définira le nombre de points à
calculer dans cet espace linéaire. Si vous omettez ce troisième argument, il prend par défaut la valeur nb_points=50.
In :
linspace(0,1,11)
Out :
array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
La fonction objet linspace() est un moyen bien pratique de générer des valeurs de coordonnées pour un graphique
(NdT : pour un intervalle d'abscisses, par exemple). Les fonctions de la librairie Numpy — qui sont toutes intégrées
d'office dans l'interface IPython Notebook — peuvent traiter un tableau entier (ou même une matrice) de points en
une seule fois.
Exemple :
In :
x = linspace(0,2*pi)
sin(x)
Out :
array([ 0.00000000e+00, 1.27877162e-01, 2.53654584e-01,
3.75267005e-01, 4.90717552e-01, 5.98110530e-01,
6.95682551e-01, 7.81831482e-01, 8.55142763e-01,
9.14412623e-01, 9.58667853e-01, 9.87181783e-01,
9.99486216e-01, 9.95379113e-01, 9.74927912e-01,
9.38468422e-01, 8.86599306e-01, 8.20172255e-01,
7.40277997e-01, 6.48228395e-01, 5.45534901e-01,
4.33883739e-01, 3.15108218e-01, 1.91158629e-01,
6.40702200e-02, -6.40702200e-02, -1.91158629e-01,
-3.15108218e-01, -4.33883739e-01, -5.45534901e-01,
-6.48228395e-01, -7.40277997e-01, -8.20172255e-01,
-8.86599306e-01, -9.38468422e-01, -9.74927912e-01,
-9.95379113e-01, -9.99486216e-01, -9.87181783e-01,
-9.58667853e-01, -9.14412623e-01, -8.55142763e-01,
-7.81831482e-01, -6.95682551e-01, -5.98110530e-01,
-4.90717552e-01, -3.75267005e-01, -2.53654584e-01,
-1.27877162e-01, -2.44929360e-16])
En alliant Numpy à la puissance de Matplotlib, nous obtenons de grandes capacités pour tracer des graphiques
facilement :