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.

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