.. _chapter_numpy:
Le calcul scientifique
######################
Python dispose d'un environnement scientifique très puissant reférencé sous le nom de **SciPy (Scientific Python) stack** avec trois modules principaux:
- `NumPy `__ : package apportant une structure de données de plus grande efficacité algorithmique que les listes (Numpy array) et les opérations permettant de manipuler très efficacement cette structure de données (indexing, sorting, reshaping, vectorisation, etc...)
- `SciPy `_ : package contenant un grand nombre d'algorithmes scientifiques utilisant les structures de données de NumPy.
- `Matplotlib `_ : package contenant des fonctions de tracé de figures scientifiques.
Ce chapitre présente le strict minimum des packages `NumPy `__ et `Matplotlib `_.
Numpy
=====
Les listes de Python sont des containers hétérogènes très efficaces pour les opérations courantes. Leur universalité est cependant incompatible avec une grande efficacité algorithmique. Numpy introduit la notion de tableau multi dimensionnel homogène, en ce sens qu'il ne peut contenir que des données numériques de même nature. Ces données sont indexées par un :class:`tuple` d'entiers positifs. Il y a autant d'entiers que de dimensions dans le tableau. Dans la terminologie Numpy, les dimensions s'appellent des axes. Le nombre d'axes définit le rang du tableau.
Le tableau
----------
Le tableau Numpy est un :class:`~numpy:numpy.ndarray`. Un exemple simple d'utilisation::
>>> import numpy as np
>>> a = np.arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> type(a)
La fonction :func:`~numpy.arange` fonctionne de la même façon que la fonction :func:`range` de Python mais retourne un :class:`~numpy:numpy.ndarray` plutôt qu'une liste. L'objet :class:`~numpy:numpy.ndarray` possède un certain nombre d'attributs contenant ses caractéristiques::
>>> a.shape
(12,)
>>> a.ndim
1
>>> a.dtype
dtype('int32')
>>> a.size
12
La méthode :meth:`~numpy:numpy.ndarray.reshape` est utilisée pour organiser les données sur plusieurs dimensions::
>>> a.reshape(3,4)
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> a.reshape(4,3)
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
Si les paramètres de :meth:`~numpy:numpy.ndarray.reshape` ne sont pas compatibles avec les données une exception :py:exc:`ValueError` est levée::
>>> a.reshape(4,4)
Traceback (most recent call last):
File "", line 1, in
ValueError: total size of new array must be unchanged
Création d'un tableau
---------------------
Le constructeur de la classe :class:`~numpy:numpy.ndarray` accepte une séquence Python comme argument::
>>> l = [ i**2 for i in range(5) ]
>>> l
[0, 1, 4, 9, 16]
>>> a = np.array(l) # l'argument est une liste
>>> a
array([ 0, 1, 4, 9, 16])
>>> a = np.array((1, 2, 3)) # l'argument est un tuple
>>> a
array([1, 2, 3])
Les méthodes de tableau
-----------------------
Le tableau :class:`~numpy:numpy.ndarray` dispose d'un grand nombre de méthodes permettant de réaliser des opérations sur les tableaux avec une grande efficacité algorithmique. Quelques unes en action::
>>> a = np.array((6, 2, 1, 4, 5, 3))
>>> a.sum()
21
>>> a.cumprod()
array([ 6, 12, 12, 48, 240, 720], dtype=int32)
>>> a.cumsum()
array([ 6, 8, 9, 13, 18, 21], dtype=int32)
>>> a.max()
6
>>> a.min()
1
L'opération de tri :meth:`~numpy:numpy.ndarray.sort` est conduite "sur place"::
>>> a.sort()
>>> a
array([1, 2, 3, 4, 5, 6])
On dispose également de méthodes statistiques::
>>> a.mean()
3.5
>>> a.std()
1.707825127659933
>>> a.var()
2.9166666666666665
Mais d'autres opérations statistiques sont possibles par l'intermédiaire de fonctions. Un exemple de l'utilisation de :func:`~numpy:numpy.median`::
>>> np.median(a)
3.5
Opérations sur les tableaux
---------------------------
Les opérations numériques sur les tableaux sont vectorisées. Inutile de parcourir les éléments du tableau avec une boucle. La syntaxe est concise, élégante et très efficace d'un point de vue algorithmique::
>>> a
array([1, 2, 3, 4, 5, 6])
>>> a*2
array([ 2, 4, 6, 8, 10, 12])
>>> b = a*2
>>> b
array([ 2, 4, 6, 8, 10, 12])
>>> c = b-1
>>> c
array([ 1, 3, 5, 7, 9, 11])
>>> d = a/c
>>> d
array([ 1., 0.66666667, 0.6, 0.57142857, 0.55555556, 0.54545455])
Slicing
-------
L'accès à des éléments ou des portions d'un tableau :class:`~numpy:numpy.ndarray` utilise la même syntaxe que celle des séquences Python::
>>> a
array([1, 2, 3, 4, 5, 6])
>>> a[1:]
array([2, 3, 4, 5, 6])
>>> a[::2]
array([1, 3, 5])
>>> a[::-1]
array([6, 5, 4, 3, 2, 1])
Filtrage
--------
On peut utiliser la vectorisation pour créer aisément un masque de filtrage::
>>> a > 3
array([False, False, False, True, True, True], dtype=bool)
Ce masque permet de mettre en oeuvre une fonctionnalité puissante de filtrage des éléments d'un tableau en étendant le concept de slicing. On peut en effet utiliser ce masque pour sélectionner ou non certains éléments du tableau. Sans surprise les éléments correspondant à ``True`` sont conservés, ceux correspondant à ``False`` sont écartés::
>>> a[a>3]
array([4, 5, 6])
Itérer sur un tableau
---------------------
La vectorisation introduite par Numpy est une opération puissante qu'il faut privilégier. La très grande majorité des opérations sur les tableaux peut être traitée de cette façon. C'est une syntaxe concise, élégante, lisible (donc maintenable) et très efficace algorithmiquement. Dans le cas très particulier où la vectorisation ne conviendrait pas, on itère sur des tableaux, de la même manière que sur des séquences Python::
>>> for i in a:
... print(i)
...
1
2
3
4
5
6
Matplotlib
==========
`NumPy `__ fournit une structure de donnée efficace (:class:`~numpy:numpy.ndarray`) ainsi que les méthodes/fonctions permettant de la manipuler. Un environnement de calcul scientifique doit également fournir les outils nécessaires pour tracer courbes et graphiques. `Matplotlib `_ est le framework graphique historique. Mais il souffre de plusieurs limitations et est maintenant remplacé par des solutions plus performantes, dont les deux principales sont `Bokeh `_ et `Plotly `_.
Tracer une courbe
-----------------
La fonction :func:`~matplotlib.pyplot.plot` permet de tracer une courbe 2D.
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(0, np.pi*2)
>>> plt.plot(x, np.sin(x))
[]
>>> plt.title('Sine function')
Text(0.5, 1.0, 'Sine function')
>>> plt.xlabel('angle (radians)')
Text(0.5, 0, 'angle (radians)')
>>> plt.grid()
>>> plt.show()
:func:`~numpy.linspace` génère un tableau de nombres réels compris entre 0 et 2 :math:`\pi`. La fonction :func:`~numpy.sin` est vectorisée et génère un tableau de valeurs nécessaire pour l'affichage.
.. image:: ../images/14-sine.png
:scale: 75 %
:align: center
Tracer un histogramme
---------------------
La fonction :func:`~matplotlib.pyplot.hist` permet de tracer l'histogramme d'un ensemble de données.
>>> x = np.random.randn(10000)
>>> n, bins, patches = plt.hist(x)
>>> n
array([ 3., 41., 307., 1177., 2620., 2991., 1951., 733., 161.,
16.])
>>> bins
array([-4.15566633, -3.36897652, -2.58228671, -1.7955969 , -1.00890709,
-0.22221727, 0.56447254, 1.35116235, 2.13785216, 2.92454197,
3.71123178])
>>> plt.title('10.000 random numbers')
Text(0.5, 1.0, '10.000 random numbers')
>>> plt.xlabel('bins')
Text(0.5, 0, 'bins')
>>> plt.ylabel('count')
Text(0, 0.5, 'count')
>>> plt.show()
``n`` est un :class:`~numpy.ndarray` contenant le nombre d'échantillons dans chacune des classes dont les limites sont définie par le tableau ``bins`` comme le montre la figure produite.
.. image:: ../images/14-hist.png
:scale: 75 %
:align: center
La fonction :func:`~matplotlib.pyplot.hist` accepte d'autres arguments que les données à traiter. En particulier, le paramètre ``bins`` permet de définir les classes. Si c'est un entier ``bins`` représente le nombre de classes. Si c'est une séquence, les valeurs du tableau ``bins`` délimitent les classes. Cette délimitation peut être inhomogène.
>>> b = list(range(-4,5,1))
>>> b
[-4, -3, -2, -1, 0, 1, 2, 3, 4]
>>> n, bins, patches = plt.hist(x, bins=b)
>>> n
array([ 7., 219., 1324., 3478., 3373., 1371., 215., 12.])
>>> plt.title('10.000 random numbers')
Text(0.5, 1.0, '10.000 random numbers')
>>> plt.xlabel('bins')
Text(0.5, 0, 'bins')
>>> plt.ylabel('count')
Text(0, 0.5, 'count')
>>> plt.show()
La figure produite est différente:
.. image:: ../images/14-hist2.png
:scale: 75 %
:align: center
.. note::
Les résultats obtenus peuvent être sensiblement différents d'une simulation à une autre, car les données générées sont pseudo aléatoires.