Les fonctions

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 :

permet de l'appliquer à un numpy array.

on définit par exemple la fonction :

def myFunc(x, y):
    return x + y / 2.0 if y > 0 else 0

on définit ensuite une version vectorisée par : myFuncV = numpy.vectorize(myFunc).
application de la fonction : myFuncV(numpy.array([1, 2, 3]), numpy.array([-1, 4, 5])) donne [0, 4, 5]. Attention : ici numpy s'est basé sur le type du premier élément du résultat pour décider que c'était un array d'entiers (int64), d'où le fait qu'il ne renvoie pas la valeur attendue !
si on définit la version vectorisée par : myFuncV = numpy.vectorize(myFunc, otypes = [numpy.float64]), cette fois-ci, avec myFuncV(numpy.array([1, 2, 3]), numpy.array([-1, 4, 5])), on obtient la bonne valeur : [0., 4., 5.5] !
attention, la vectorization d'une fonction ne l'accélère pas, l'exécution se fait au rythme de python !

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'])]

programmer en python, tutoriel python, graphes en python, Aymeric Duclert