Comment décaler les éléments d'une matrice numpy en python ?

Introduction

Les tableaux Numpy sont des structures de données multidimensionnelles qui peuvent contenir des éléments du même type de données. Ces tableaux sont très utiles pour effectuer des opérations mathématiques et statistiques sur de grandes quantités de données. Cependant, il arrive souvent que nous ayons besoin de modifier la position ou l'ordre des éléments dans un tableau Numpy.

Dans ce guide, nous allons explorer différentes méthodes pour décaler les éléments dans une matrice Numpy.

Décaler les éléments d'une matrice 1D avec la fonction np.roll()

La méthode la plus simple pour décaler des éléments dans un tableau Numpy est d'utiliser la fonction np.roll(). Cette fonction prend deux arguments : le premier est le tableau que nous souhaitons modifier, et le second est le nombre de positions à déplacer. Voici un exemple pour mieux comprendre :

Pour commencer, nous pouvons créer un tableau 1D en utilisant la fonction np.array()

import numpy as np

data = np.arange(1,10)

print( data )

donne

array([1, 2, 3, 4, 5, 6, 7, 8, 9])

Décaler les éléments de n positions vers la droite

Pour déplacer les éléments de n positions, nous pouvons utiliser la fonction roll de numpy. Par exemple, si nous voulons déplacer de 2 positions :

n = 2

new_data = np.roll(data,shift=n)

print(new_data)

Le résultat de l'exemple ci-dessus sera :

array([8, 9, 1, 2, 3, 4, 5, 6, 7])

Comme vous pouvez le voir, les éléments ont été déplacés de deux positions vers la droite. Si nous donnons un nombre négatif à la fonction np.roll(), les éléments seront déplacés vers la gauche.

Si votre objectif est de décaler vos éléments de n sans remplacer les éléments qui précèdent, une solution simple consiste à définir une valeur par défaut:

default_value =  -999

new_data[:n] = default_value

print(new_data)

Le résultat de l'exemple ci-dessus sera :

array([-999, -999,    1,    2,    3,    4,    5,    6,    7])

Décaler les éléments de n positions vers la gauche

Pour déplacer les éléments de n positions, nous pouvons utiliser la fonction roll de numpy. Par exemple, si nous voulons déplacer nos éléments de -3 :

n = -3

new_data = np.roll(data,n)

print(new_data)

Le résultat de l'exemple ci-dessus sera :

array([4 5 6 7 8 9 1 2 3])

Décaler les éléments d'une matrice sans remplacement:

default_value =  -999

new_data[n:] = default_value

print(new_data)

Le résultat de l'exemple ci-dessus sera :

array([   4,    5,    6,    7,    8,    9, -999, -999, -999])

Veuillez noter que ce cas diffère légèrement du scénario précédent lorsque n est positif.

Décaler les éléments d'une matrice 2D

Utilisation de la fonction roll() de numpy

Créons une matrice 2D avec numpy

import numpy as np

data = np.arange(1,31).reshape(5,6)

print(data)

donne ici

array([[ 1,  2,  3,  4,  5,  6],
       [ 7,  8,  9, 10, 11, 12],
       [13, 14, 15, 16, 17, 18],
       [19, 20, 21, 22, 23, 24],
       [25, 26, 27, 28, 29, 30]])

Ensuite, en appliquant la fonction roll() sans spécifier l'axe :

n = 2

new_data = np.roll(data,n)

print(new_data)

vous observerez le résultat suivant :

[[29 30  1  2  3  4]
 [ 5  6  7  8  9 10]
 [11 12 13 14 15 16]
 [17 18 19 20 21 22]
 [23 24 25 26 27 28]]

Pour obtenir le même résultat, vous pouvez aplatir le tableau 2D et appliquer la fonction de roll() comme précédemment. Puis ensuite revenir a sa forme d'origine comme ceci

new_data = data.flatten()

new_data = np.roll(data,n)

new_data = new_data.reshape(data.shape)

Déplacement des éléments dans un tableau 2D le long des lignes

Pour utiliser la fonction numpy.roll() et déplacer les éléments le long des lignes, vous pouvez indiquer l'axe dans la fonction roll(). Par exemple, si vous souhaitez déplacer les éléments de n positions vers la droite le long des lignes d'une. matrice 2D, vous pouvez utiliserer np.roll(mon_tableau, shift=n, axis=0).

Les éléments de chaque rangée se déplacent indépendamment des autres, revenant au début de la rangée si nécessaire.

n = 2

new_data = np.roll(data,n, axis=0)

print(new_data)

donne ici

[[19 20 21 22 23 24]
 [25 26 27 28 29 30]
 [ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]
 [13 14 15 16 17 18]]

Pour déplacer les éléments vers la gauche, utilisez une valeur de décalage négative à la place.

Déplacement des éléments dans une matrice 2D le long des colonnes.

n = 2

new_data = np.roll(data,n, axis=1)

print(new_data)

donne

[[ 5  6  1  2  3  4]
 [11 12  7  8  9 10]
 [17 18 13 14 15 16]
 [23 24 19 20 21 22]
 [29 30 25 26 27 28]]

En utilisant la fonction shift de la bibliothèque scipy ndimage

Une autre option est d'utiliser la fonction de décalage de la bibliothèque ndimage de scipy:

Par exemple, une solution pour décaler à la fois les colonnes et les lignes de 2 est la suivante :

from scipy.ndimage import shift

new_data = shift(data, shift=2, cval=0)

print(new_data)

donne ici

[[ 0  0  0  0  0  0]
 [ 0  0  0  0  0  0]
 [ 0  0  1  2  3  4]
 [ 0  0  7  8  9 10]
 [ 0  0 13 14 15 16]]

Il est également possible de spécifier des décalages variables pour différentes axes en utilisant une séquence telle qu'un tuple ou une liste. Par exemple, vous pouvez décaler d'un dans la ligne mais de trois dans les colonnes :

new_data = shift(data, shift=[1,3], cval=0)

print(new_data)

donne

[[ 0  0  0  0  0  0]
 [ 0  0  0  1  2  3]
 [ 0  0  0  7  8  9]
 [ 0  0  0 13 14 15]
 [ 0  0  0 19 20 21]]

Références