> Modules non standards > numpy > Manipulation des arrays
Manipulation des arrays
Généralités :
- a = numpy.array([[1, 2, 3], [4, 5, 6]]); a.shape : permet d'avoir la dimension de l'array, ici (2, 3).
- les arrays 2d sont remplies d'abord par ligne, et les index sont par ligne, puis par colonne.
Accès aux éléments par index :
- a = numpy.array([[1, 2, 3], [4, 5, 6]]) donne :
array([[1, 2, 3],
[4, 5, 6]])
- a[0,1] : donne l'élément sur la ligne 0 et la colonne 1, donc ici 2.
- a[0][1] : marche aussi, mais est moins efficace car crée d'abord la sous array a[0] !
- a[-1,-1] : dernier élément, donc ici 6.
- a[0] : première ligne, donc ici array([1, 2, 3]).
- a[:,0] : première colonne, donc ici array([1, 4]).
- a[0:2,0:2] : sous-array 2d des 2 premières lignes et 2 premières colonne, donc :
array([[1, 2],
[4, 5]])
- attention, quand on fait b = a[0:2,0:2], b n'est pas une copie de a, mais une "vue" sur a : si on modifie b, cela modifie a (et réciproquement) !
- on peut utiliser des arrays pour récupérer certains éléments :
- a[numpy.array([0, 1, 0]), numpy.array([0, 2, 2])] donne array([1, 6, 3]).
- a[[0, 1, 0], [0, 2, 2]] marche aussi.
Pour changer toutes les valeurs d'une array (qui peut être 2d) : a[:] = 2
Compter le nombre d'éléments d'une array satisfaisant une condition : (a > 2).sum().
Modification des éléments selon une condition :
- on part de a = numpy.array([[1, 2, 3], [4, 2, 1]]).
- a == 2 donne :
array([[False, True, False],
[False, True, False]], dtype=bool)
- a[a == 2] = 7 affecte à l'array a :
array([[1, 7, 3],
[4, 7, 1]])
- a[a > 1] = 7 affecte à l'array a :
array([[1, 7, 7],
[7, 7, 1]])
Pour transformer une array de valeurs en array avec des 1 partout où la valeur était différente de 0 et 0 ailleurs :
a = numpy.array([0, 3, 1, 0, 6]); a2 = 0 + (a != 0) donne pour a2 : array([0, 1, 1, 0, 1])
Fonctions de manipulation :
- on part de a = numpy.array([[1, 2, 3], [4, 5, 6]]), donc :
array([[1, 2, 3],
[4, 5, 6]])
- a.reshape(3, 2) : renvoie une array2d de taille 3 x 2.
- le résultat est ici :
array([[1, 2],
[3, 4],
[5, 6]])
- il faut que le nombre total d'éléments soit conservé.
- l'array de départ n'est pas affectée.
- par contre, l'array renvoyée s'appuie les mêmes données (modification de l'une modifie aussi l'autre).
- a.reshape(3, -1) : on peut laisser l'une des dimensions à -1 : elle sera déduite automatiquement des autres dimensions !
- a.ravel() : renvoie une liste en la transformant en 1d : array([1, 2, 3, 4, 5, 6]), mais celle-ci est liée à l'array de départ (modification de l'une modifie l'autre).
- a.ravel('F') : pareil, mais en itérant d'abord par colonne : array([1, 4, 2, 5, 3, 6]).
- a.flat : donne un itérateur (1D) qui renvoie les valeurs dans le même ordre que ravel.
- a.flatten() et a.flatten('F') : comme ravel, mais renvoie une copie indépendante.
- a.transpose() ou a.T : renvoie une vue transposée de l'array 2d (qui reste liée à l'array de départ).
- numpy.hstack((a, a)) : crée une nouvelle array en mettant le tuple d'arrays données (2 ou plus) côte à côte, ici donne :
array([[1, 2, 3, 1, 2, 3],
[4, 5, 6, 4, 5, 6]])
- numpy.vstack((a, a)) : crée une nouvelle array en mettant le tuple d'arrays données (2 ou plus) les uns en dessous des autres, ici donne :
array([[1, 2, 3],
[4, 5, 6],
[1, 2, 3],
[4, 5, 6]])
- numpy.tile : permet de construire des arrays répétées :
- numpy.tile(7, 3) : donne array([7, 7, 7]).
- numpy.tile([7, 8], 3) : c'est [7, 8] qui est répété, donne array([7, 8, 7, 8, 7, 8]).
- numpy.tile(7, [2, 3]) : répétition sur une array 2d :
array([[7, 7, 7],
[7, 7, 7]])
- numpy.tile([7, 8], [2, 3]) : on peut combiner les deux pour donner :
array([[7, 8, 7, 8, 7, 8],
[7, 8, 7, 8, 7, 8]])
- numpy.repeat : permet de répéter les éléments d'une array :
- numpy.repeat(numpy.array([7, 8, 9]), 2) : chaque élément est répété 2 fois : array([7, 7, 8, 8, 9, 9]).
- numpy.repeat(numpy.array([[7, 8, 9]]), 2, axis = 0).flatten() : répétition de la séquence 2 fois : array([7, 8, 9, 7, 8, 9])
- numpy.repeat(a, 2, 0) : répétition de chaque élément 2 fois selon les lignes, donne :
array([[1, 2, 3],
[1, 2, 3],
[4, 5, 6],
[4, 5, 6]])
- numpy.repeat(a, 2, 1) : répétition de chaque élément 2 fois selon les colonnes, donne :
array([[1, 1, 2, 2, 3, 3],
[4, 4, 5, 5, 6, 6]])
- numpy.repeat(numpy.nan, 10) : renvoie un vecteur de 10 valeurs NaN.
Concaténation d'arrays :
- numpy.concatenate([a1, a2, a3]) : concaténation d'arrays 1d
- numpy.concatenate([a1, a2, a3]) : concaténation d'arrays 2d par ligne ("les unes en dessous des autres")
- numpy.concatenate([a1, a2, a3], axis = 1) : concaténation d'arrays 2d par colonne ("les unes à côté des autres"). Défaut de axis est 0 (par ligne).
- il faut à chaque fois que les autres dimensions soient compatibles quand arrays à plusieurs dimensions.
Pour compter le nombre d'occurrences dans un dataframe :
- si df = pandas.DataFrame({'A': ['a', 'a', 'b', 'b', 'a'], 'B': [1, 2, 1, 1, 2]}) :
- df.value_counts().rename('nbr').reset_index()
- ou alors df.groupby(['A', 'B']).size().rename('nbr').reset_index()
Pour enlever la moyenne d'une colonne ou d'une ligne avec une array :
ar = numpy.array([[1, 2, 3], [4, 5, 6]])
- par colonne, c'est facile : ar - ar.mean(axis = 0), ce qui donne :
array([[-1.5, -1.5, -1.5],
[ 1.5, 1.5, 1.5]])
- par ligne : ar - ar.mean(axis = 1, keepdims = True), ce qui donne :
array([[-1., 0., 1.],
[-1., 0., 1.]])
Pour calculer les z-values (valeurs centrées réduites) par colonne : (ar - ar.mean(axis = 0)) / ar.std(axis = 0)
Padding : numpy.pad(ar, (0, 10), mode = 'constant', constant_values = 2) : renvoie une array avec 0 valeurs égales à 2 rajoutées au début et 10 valeurs égales à 2 rajoutées à la fin.
Copyright python-simple.com
programmer en python, tutoriel python, graphes en python, Aymeric Duclert