Opérateurs booléens sur les array numpy :
- a1 & a2 : and
- a1 | a2 : or
- a1 ^ a2 : xor
- ~ a1 : not
ufuncs avec une seule variable :
- numpy.negative(a1) : pareil que -a1
- numpy.sign(a1) : -1, 0 ou 1 selon le signe.
- numpy.exp, numpy.log : exponentielle, logarithme (base e).
- numpy.exp2, numpy.log2 : exponentielle en base 2 (i.e. 2 puissance n), logarithme en base 2.
- numpy.log10 : logarithme en base 10.
- numpy.sqrt : racine carrée.
- numpy.square : carrés, mais on peut faire aussi ar ** 2
- numpy.reciprocal : l'inverse, terme à terme (attention, pas l'inverse de la matrice).
- numpy.sin, numpy.cos, numpy.tan, numpy.arcsin, numpy.arccos, numpy.arctan, numpy.sinh, numpy.cosh, numpy.tanh, numpy.arcsinh, numpy.arccosh, numpy.arctanh : fonctions trigonométriques classiques, avec argument en radians.
- numpy.deg2rad, numpy.rad2deg : conversion de degrés en radians et vice-versa.
ufuncs (fonctions universelles) avec deux variables :
- a1 = numpy.array([1, 2, 3, 4]); a2 = numpy.array([4, 3, 2, 1]); a = numpy.add(a1, a2) : renvoie une array avec array([5, 5, 5, 5])
- a = numpy.add(a1, a2) et a = a1 + a2 sont équivalents.
- si "a" est une array de la bonne taille, on peut aussi faire : numpy.add(a1, a2, a) pour placer le résultat de a1 + a2 dans a.
- a = numpy.subtract(a1, a2) : comme a1 - a2
- a = numpy.multiply(a1, a2) : comme a1 * a2. C'est la multiplication terme à terme, attention, pas la multiplication de matrices !
- a = numpy.divide(a1, a2) : comme a1 / a2 : c'est la division entière si ce sont des entiers, sinon, c'est la division normale.
- a = numpy.remainder(a1, a2) : retourne le reste de la division entière (euclidienne), ici array([1, 2, 1, 0]).
- a = numpy.mod(a1, a2) : comme numpy.remainder
- a = true_divide(a1, a2) : division non entière, même si ce sont des entiers. Donne donc ici : array([0.25, 0.66666667, 1.5, 4.])
- a = true_divide(a1, a2) : fait une division entière même si ce ne sont pas des entiers. Par exemple, numpy.floor_divide(a1.astype(numpy.float), a2.astype(numpy.float)) donne array([ 0., 0., 1., 4.])
- numpy.power(a1, a2) : comme a1 ** a2 (donne ici array([1, 8, 9, 4]))
- numpy.minimum(a1, a2) : renvoie l'array numpy ayant les éléments correspondant au minimum des paires des valeurs de a1 et a2 à chaque position (idem avec maximum).
- numpy.dot(a, b) : multiplication de matrices. Il faut que a et b aient des dimensions compatibles. Par exemple numpy.dot(numpy.array([[1, 2], [4, 5], [2, 7], [5, 7]]), numpy.array([[1], [2]])) donne array([[ 5], [14], [16], [19]])
- a.dot(b) : autre façon de faire le produit de matrices.
- a @ b : autre façon plus simple de faire le produit de matrices.
- numpy.trace(mat) : trace de la matrice.
- numpy.linalg.det(mat) : déterminant de la matrice.
- numpy.linalg.inv(mat) : inverse de la matrice.
- w, v = numpy.linalg.eig(M) : renvoie les valeurs propres w et la matrice des vecteurs propres (les vecteurs propres sont en ligne)
Fonctions d'aggrégation :
- on part de a = numpy.array([[1, 2, 3], [4, 5, 6]]) :
array([[1, 2, 3],
[4, 5, 6]])
- numpy.sum(a) ou a.sum(): somme de tous les éléments de a (donne ici 21).
- attention : on peut faire aussi sum(a), mais ça calcule la somme avec la fonction sum de python, et c'est considérablement plus long !
- numpy.sum(a, 0) ou a.sum(0) : on aggrège selon la première dimension (lignes), donc éléments qui ne diffèrent que par le numéro de ligne sont ajoutés. Donne ici array([5, 7, 9]).
- numpy.sum(a, 1) ou a.sum(1) : on somme par colonne, donc ici array([6, 15]).
- si b est une array de booléens, b.sum() donne le nombre de valeurs True
- ça se généralise à plus de 2 dimensions et en donnant éventuellement plusieurs dimensions sur lesquelles faire la somme, par exemple : si b = numpy.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]), b.sum((0, 2)) donne array([30, 48]).
- a.mean() ou numpy.mean(a) : moyenne générale.
- numpy.nanmean() : la moyenne générale en ignorant les NaN.
- a.mean(0) ou numpy.mean(a, 0) : moyenne en ignorant la dimension ligne (donc par colonne si 2d) : array([2.5, 3.5, 4.5]).
- numpy.average([4, 2, 8], weights = [1, 2, 1]) : fait une moyenne pondérée ((4 * 1 + 2 * 2 + 8 * 1) / 4 = 4.0
- a.min() : minimum général, ici 1 (idem avec max).
- numpy.min(a) : minimum général (idem avec max)
- a.min(0) ou numpy.min(a, 0) : minimum en ignorant la dimension ligne, ici array([1, 2, 3]).
- numpy.nansum, numpy.nanmedian, numpy.nanstd, numpy.nanmin, numpy.nanmax, numpy.nanvar, numpy.nanquantile : fonctions qui ignore les NaN
- a.cumsum() : fait la somme cumulée après avoir aplati l'array en une seule dimension (donne ici array([1, 3, 6, 10, 15, 21])).
- a.cumsum(0) : moyenne cumulée en faisant varier le numéro de ligne, donne ici :
array([[1, 2, 3],
[4, 5, 6]])
- a.cumsum(1) : moyenne cumulée en faisant varier le numéro de colonne, donne ici :
array([[1, 3, 6],
[4, 9, 15]])
- a.count_non_zero() : renvoie le nombre de valeurs différentes de 0.
- pour compter le nombre de valeurs égales à une certaine valeur donnée sur chaque colonne : a = numpy.array([[1, 1, 1], [0, 1, 1], [0, 0, 1]]); (a == 1).sum(0) : donne array([1, 2, 3]).
- uniqueValues = numpy.unique(ar) : retourne les valeurs uniques d'une array 1d
- uniqueValues, counts = numpy.unique(ar, return_counts = True) : retourne un tuple avec les valeurs uniques d'une array 1d, et les comptes
Utilisation de fonctions d'aggrégation numpy sur listes simples : on peut très bien utiliser des fonctions numpy sur une liste python, python convertit d'abord la liste en array numpy. Exemple l = [1, 2, 3, 4]; numpy.mean(l) donne 2.5
Fonctions pour convertir des flottants en flottants à valeur entières :
- numpy.floor : partie entière. Par exemple, numpy.floor(numpy.array([1.5, -1.5, 0.5])) donne array([1., -2., 0.])
- numpy.ceil : partie entière + 1. Par exemple, numpy.ceil(numpy.array([1.5, -1.5, 0.5])) donne array([2., -1., 1.])
- numpy.trunc : supprime la partie décimale. Par exemple, numpy.trunc(numpy.array([1.5, -1.5, 0.5])) donne array([1.,-1., 0.])
- numpy.round(a, 2) : arrondi à 2 chiffres après la virgule.
Fonctions sur les valeurs logiques (booléennes) :
- numpy.logical_and(a1, a2)
- numpy.logical_or(a1, a2)
- numpy.logical_xor(a1, a2)
- numpy.logical_not(a1)
Comparaison d'array numpy :
- (a1 == a2).all() : renvoie True si toutes les couples de valeurs sont égaux, sinon False. Si le type est différent, il y a conversion de type pour la comparaison. Les 2 arrays doivent être de même taille.
- (a1 == a2).any() : renvoie True si un des couples de valeurs est égal, sinon False. Si le type est différent, il y a conversion de type pour la comparaison. Les 2 arrays doivent être de même taille.
Valeurs infinies ou non définies :
- a1 = numpy.array([0, 1, -1], dtype = float); a2 = numpy.log(a1) donne pour valeur a2 array([-inf, 0., nan]) (inf = infini, nan = non défini).
- numpy.isfinite(a2) : teste si la valeur est finie. Donne ici array([False, True, False], dtype=bool)
- numpy.isinf(a2) : teste si la valeur est infinie. Donne ici array([True, False, False], dtype=bool)
- numpy.isnan(a2) : teste si la valeur est définie. Donne ici array([False, False, True], dtype=bool). Attention : ne marche pas sur une string, renvoie alors une exception !
- on peut utiliser pandas.isna(x) : permet de tester si une valeur est NaN, qu'elle soit numerique ou string !
Fonctions sur les bits :
- numpy.bitwise_and, numpy.bitwise_or, numpy.bitwise_xor : opérateurs logiques sur les bits
- numpy.invert : inversion des bits (not)
- numpy.left_shift(numpy.array([0, 1, 2, 4]), 2) : décalage de bits à gauche (ici, donne array([ 0, 4, 8, 16])). Idem avec numpy.right_shift.
Comparaisons :
- numpy.greater : comparaison, renvoie une array de booléens :
ar1 = numpy.array([3, 6, 4, 6, 2])
ar2 = numpy.array([1, 7, 5, 3, 9])
numpy.greater(ar1, ar2)
renvoie : array([ True, False, False, True, False], dtype=bool)
- mais en fait, on peut aussi faire ar1 > ar2
- numpy.greater_equal, numpy.less, numpy.less_equal : idem.
- numpy.not_equal, numpy.equal : idem avec inégalités et égalités.
Fonction ensemblistes :
- numpy.intersect1d(ar1, ar2) : renvoie les éléments communs des 2 arrays 1d triés et uniques.
- numpy.union1d(ar1, ar2) : renvoie la réunion des 2 arrays 1d triés et uniques.
Vectorization d'une fonction :
Application d'une fonction selon un axe :
- on définit : a = numpy.array([[1, 2, 3], [4, 5, 6]]) :
array([[1, 2, 3],
[4, 5, 6]])
- numpy.apply_along_axis(sum, 0, a) : applique la fonction sum le long de l'axe 0, c'est à dire à tous les éléments qui ne diffèrent que par leur numéro de ligne (donne donc array([5, 7, 9])).
- on peut définir sa propre fonction (en ligne ou pas), par exemple : numpy.apply_along_axis(lambda x: sum(numpy.arange(1, len(x) + 1) * x), 0, a) (somme pondérée par le numéro d'ordre, donne ici array([ 9, 12, 15])).
- on peut passer des arguments supplémentaires qui seront passés à la fonction appelée : numpy.apply_along_axis(lambda x, y, z: y * sum(x) + z, 0, a, 2, 3) : donne array([13, 17, 21]) (2 est passé dans y et 3 dans z).
- on peut très bien ne pas renvoyer une valeur numérique mais une array. Par exemple numpy.apply_along_axis(lambda x: numpy.hstack((x, x)), 0, a) donne :
array([[1, 2, 3],
[4, 5, 6],
[1, 2, 3],
[4, 5, 6]])
numpy.split(['a', 'b', 'c', 'd', 'e', 'f', 'g'], [1, 3]) : split l'array en une liste ar[:1], ar[1:3], ar[3:] (ici, donne donc [array(['a']), array(['b', 'c']), array(['d', 'e', 'f', 'g'])]
