Numpy - Episode 2
Création d’un tableau
Pour créer un tableau, il y a plusieurs méthodes. La méthode la plus utilisée est de créer une liste ou une séquence de listes comme argument de la fonction array().
>>> import numpy as np
>>> c = np.array([[1, 2, 3],[4, 5, 6]])
>>> c
array([[1, 2, 3],
[4, 5, 6]])
La fonction array () peut accepter des tuples ou ensemble de tuples.
>>> import numpy as np
>>> d = np.array(((1, 2, 3),(4, 5, 6)))
>>> d
array([[1, 2, 3],
[4, 5, 6]])
La fonction zeros() peut être utilisée pour créer un tableau de zéro. Elle accepte comme argument la dimension de la matrice. Par exemple, pour créer un tableau à deux dimensions 3x3, nous pouvons écrire :
>>> a = np.zeros(3, 3)
>>> a
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]]
La fonction ones() fait la même chose que la fonction zeros() mais en remplissant le tableau par des un :
>>> b = np.zeros(3, 3)
>>> b
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]]
Par défaut les deux fonction zeros() et ones() créent des tableaux avec le data-type float64.
La fonctionnalité qui peut être utile est arange(). Cette fonction génère un tableau NumPy avec des séquences numériques qui répondent à des règles particulières en fonction de l'argument passé. Par exemple, si on veut générer de valeurs entre 0 et 10 :
>>> e = np.arange(0, 10)
>>> e
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Mais avec la fonction arange(), nous avons créé uniquement un tableau à 1 dimension. Pour générer un tableau à 2 dimensions, on combine la fonction arange() avec la fonction reshape(). Cette dernière fonction divise un tableau linéaire en parts différents par la manière spécifiée par l’argument de forme :
>>> tab1 = np.arange(0, 12).reshape(3, 4)
>>> tab1
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
Opérations Arithmétiques de Base
Les premières opérations que va effectuer sur les tableaux sont les opérateurs arithmétiques : addition, multiplication, soustraction et division. Ces opérateurs s’appliquent élément par élément. Par exemple :
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> a + 4
array([4, 5, 6, 7])
>>> a * 2
array([0, 2, 4, 6])
>>> a - 3
array([-3, -2, -1, 0])
>>> a / 5
array([0. , 0.2, 0.4, 0.6])
>>> b = np.arange(4, 8)
>>> b
array([4, 5, 6, 7])
>>> a + b
array([ 4, 6, 8, 10])
>>> a - b
array([-4, -4, -4, -4])
>>> a * b
array([ 0, 5, 12, 21])
>>> a / b
array([0. , 0.2 , 0.33333333, 0.42857143])
>>> a * np.sin(b)
array([-0. , -0.95892427, -0.558831 , 1.9709598 ])
>>> a * np.sqrt(b)
array([0. , 2.23606798, 4.89897949, 7.93725393])
Produit Matriciel
Dans NumPy, le produit matriciel est désigné par la fonction dot() :
>>> A = np.arange(0, 9).reshape(3, 3)
>>> A
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> B = np.ones((3, 3))
>>> B
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
>>> A * B
array([[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]])
>>> np.dot(A, B)
array([[ 3., 3., 3.],
[12., 12., 12.],
[21., 21., 21.]])
fonctions d'agrégation
les fonctions d'agrégation effectuent une opération sur un ensemble de valeurs, un tableau par exemple, et produisent un seul résultat. Par conséquent, la somme de tous les éléments d'un tableau est une fonction d'agrégation. De nombreuses fonctions de ce type sont implémentées dans la classe ndarray.
>>> a = np.array([3.3, 4.5, 1.3, 5.7, 0.3])
>>> a.sum()
15.100000000000001
>>> a.min()
0.3
>>> a.max()
5.7
>>> a.mean()
3.0200000000000005
>>> a.std()
1.9903768487399565