3ème série d'exemples numpy : vectorisation¶

premiers essais¶

In [1]:
import numpy as np

a = np.arange(10)
In [2]:
%timeit [x**2 + 2*x - 1 for x in a]
7.03 µs ± 861 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
In [3]:
%timeit a**2 + 2*a - 1
4.47 µs ± 592 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

Utilisation d'un paramètre en sortie pour optimiser¶

In [4]:
import numpy as np
a = np.arange(1, 1_000_000, dtype=np.float64)
In [5]:
%timeit [np.sqrt(x) for x in a]
1.66 s ± 95.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [6]:
%timeit np.sqrt(a)
4.41 ms ± 729 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
In [7]:
# Da vectorisation ne renvoie plus un tableau : elle met à jour le tableau défini par out : ici a
# On gagne en espace mémoire
# On gagne en rapidité car on ne crée plus un nouvel objet
%timeit  np.sqrt(a, out=a)
2.01 ms ± 372 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

timeit avec paramètres pour tester plus vite¶

In [8]:
%timeit -r 1 -n 1  [np.sqrt(x) for x in a]
1.71 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
In [9]:
%timeit -r 1 -n 1 np.sqrt(a)
2.82 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
In [10]:
%timeit -r 1 -n 1 np.sqrt(a, out=a)
1.84 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)

Méthode at() sur une fonction vectorisée : pour modifier la liste fournie¶

In [11]:
import numpy as np
a = np.arange(10, dtype=np.float32)
a
Out[11]:
array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.], dtype=float32)
In [12]:
# que les racines de a[2], a[4] et a[9]
np.sqrt.at(a, [2, 4, 9])
a
Out[12]:
array([0.       , 1.       , 1.4142135, 3.       , 2.       , 5.       ,
       6.       , 7.       , 8.       , 3.       ], dtype=float32)
In [13]:
b=np.array([9, 8, 7, 6, 5, 4, 3, 2, 1], dtype='float32')
b
Out[13]:
array([9., 8., 7., 6., 5., 4., 3., 2., 1.], dtype=float32)
In [14]:
np.sqrt.at(b, [2, 4, 6])
b
Out[14]:
array([9.       , 8.       , 2.6457512, 6.       , 2.236068 , 4.       ,
       1.7320508, 2.       , 1.       ], dtype=float32)

statistiques de base par colonne (axis=0) ou par ligne (axis=1)¶

In [15]:
a = np.arange(1, 10).reshape(3, 3)
a
Out[15]:
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
In [16]:
np.sum(a)
Out[16]:
45
In [17]:
np.sum(a, axis=0)
Out[17]:
array([12, 15, 18])
In [18]:
np.sum(a, axis=1)
Out[18]:
array([ 6, 15, 24])
In [19]:
np.nan
Out[19]:
nan
In [20]:
np.sum(a, axis=1)
Out[20]:
array([ 6, 15, 24])

nan et nansum()¶

In [21]:
a = np.arange(1, 10, dtype=np.float64).reshape(3, 3)

# np.sum(a) vaut 45
np.sum(a)
Out[21]:
45.0
In [22]:
# on met nan, qui est un float, en a[1, 1]
a[1, 1] = np.nan 
a
Out[22]:
array([[ 1.,  2.,  3.],
       [ 4., nan,  6.],
       [ 7.,  8.,  9.]])
In [23]:
# np.sum(a) vaut nan
np.sum(a)
Out[23]:
nan
In [24]:
# on utilize nansum()
# np.nansum(a) vaut 40
np. nansum (a)
Out[24]:
40.0
In [25]:
np. nansum (a, axis=0)
Out[25]:
array([12., 10., 18.])
In [26]:
np.nonzero(a)
Out[26]:
(array([0, 0, 0, 1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2, 0, 1, 2]))
In [27]:
a
Out[27]:
array([[ 1.,  2.,  3.],
       [ 4., nan,  6.],
       [ 7.,  8.,  9.]])

Compter les éléments non nan d’un tableau, par ligne et par colonne¶

In [28]:
a[1, 2] = np.nan 
a
Out[28]:
array([[ 1.,  2.,  3.],
       [ 4., nan, nan],
       [ 7.,  8.,  9.]])
In [29]:
np.isnan(a)
Out[29]:
array([[False, False, False],
       [False,  True,  True],
       [False, False, False]])
In [30]:
np.sum(np.isnan(a))
Out[30]:
2
In [31]:
np.invert(np.isnan(a))
Out[31]:
array([[ True,  True,  True],
       [ True, False, False],
       [ True,  True,  True]])
In [32]:
np.sum(np.invert(np.isnan(a)), axis=0)
Out[32]:
array([3, 2, 2])
In [33]:
np.sum(np.invert(np.isnan(a)), axis=1)
Out[33]:
array([3, 1, 3])