NumPy reshape (): comment remodeler les tableaux NumPy en Python

Publié: 2022-04-20

Dans ce didacticiel, vous apprendrez à utiliser NumPy reshape() pour remodeler les tableaux NumPy sans modifier les données d'origine.

Lorsque vous travaillez avec des tableaux Numpy, vous souhaiterez souvent remodeler un tableau existant en un tableau de dimensions différentes. Cela peut être particulièrement utile lorsque vous transformez des données en plusieurs étapes.

Et NumPy reshape() vous aide à le faire facilement. Au cours des prochaines minutes, vous apprendrez la syntaxe pour utiliser reshape() , et également remodeler les tableaux à différentes dimensions.

Qu'est-ce que le remodelage dans les tableaux NumPy ?

Lorsque vous travaillez avec des tableaux NumPy, vous souhaiterez peut-être d'abord créer un tableau de nombres à une dimension. Et puis remodelez-le en un tableau avec la dimension souhaitée.

Ceci est particulièrement utile lorsque les dimensions du nouveau tableau ne sont pas connues initialement ou sont déduites lors de l'exécution. Ou il peut également être possible qu'une certaine étape de traitement de données nécessite que l'entrée ait une forme spécifique.

C'est là que le remodelage est utile.

Par exemple, considérons l'illustration suivante. Nous avons un vecteur - un tableau unidimensionnel de 6 éléments. Et nous pouvons le remodeler en tableaux de formes 2 × 3, 3 × 2, 6 × 1, etc.

numpy-reshape

️ Pour suivre les exemples de ce tutoriel, vous devez avoir installé Python et NumPy. Si vous n'avez pas encore NumPy, consultez notre guide d'installation NumPy.

Vous pouvez maintenant continuer et importer NumPy sous l'alias np , en exécutant : import numpy as np .

Continuons à apprendre la syntaxe dans la section suivante.

Syntaxe de NumPy reshape()

Voici la syntaxe pour utiliser NumPy reshape() :

 np.reshape(arr, newshape, order = 'C'|'F'|'A')
  • arr est n'importe quel objet de tableau NumPy valide. Ici, c'est le tableau à remodeler.
  • newshape est la forme du nouveau tableau. Il peut s'agir d'un entier ou d'un tuple.
  • Lorsque newshape est un entier, le tableau renvoyé est unidimensionnel.
  • order fait référence à l'ordre dans lequel vous souhaitez lire les éléments du tableau à remodeler.
  • La valeur par défaut est 'C', ce qui signifie que les éléments du tableau d'origine seront lus dans un ordre d'indexation de type C (en commençant par 0)
  • 'F' signifie indexation de type Fortran (commençant par 1). Et 'A' lit les éléments dans un ordre de type C ou Fortran en fonction de la disposition de la mémoire du tableau arr .

Alors, que np.reshape() ?

Il renvoie une vue remodelée du tableau d'origine si possible. Sinon, il renvoie une copie du tableau.

Dans la ligne ci-dessus, nous avons mentionné que NumPy reshape() essaierait de renvoyer une vue chaque fois que possible. Sinon, il renvoie une copie . Commençons par discuter des différences entre une vue et une copie.

Afficher ou copier des tableaux NumPy

Comme son nom l'indique, la copie est une copie du tableau d'origine. Et toute modification apportée à la copie n'affectera pas le tableau d'origine.

D'autre part, la vue fait simplement référence à la vue remodelée du tableau d'origine. Cela signifie que toute modification apportée à la vue affectera également le tableau d'origine et vice versa.

Utilisez NumPy reshape() pour remodeler un tableau 1D en tableaux 2D

#1. Commençons par créer l'exemple de tableau à l'aide de np.arange().

Nous avons besoin d'un tableau de 12 nombres, de 1 à 12, appelé arr1. Comme la fonction NumPy arange() exclut le point de terminaison par défaut, définissez la valeur d'arrêt sur 13.

Utilisons maintenant la syntaxe ci-dessus et arr1 avec 12 éléments en un tableau 2D de forme (4,3). Appelons cela arr2 avec 4 lignes et 3 colonnes.

 import numpy as np arr1 = np.arange(1,13) print("Original array, before reshaping:\n") print(arr1) # Reshape array arr2 = np.reshape(arr1,(4,3)) print("\nReshaped array:") print(arr2)

Jetons un coup d'œil aux tableaux d'origine et remodelés.

 Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]

Au lieu de transmettre le tableau en tant qu'argument np.reshape() , vous pouvez également appeler la méthode .reshape() sur le tableau d'origine.

Vous pouvez exécuter dir(arr1) , et il listera toutes les méthodes et attributs possibles que vous pouvez utiliser sur l'objet tableau arr1 .

 dir(arr1) # Output [ ... ... 'reshape' ... .. ]

Dans la cellule de code ci-dessus, vous pouvez voir que .reshape() est une méthode valide à utiliser sur le tableau NumPy existant arr1 .

️ Ainsi, vous pouvez également utiliser la syntaxe simplifiée suivante pour remodeler les tableaux NumPy.

 arr.reshape(d0,d1,...,dn) # where: # d0, d1,..,dn are the dimensions of the reshaped array # d0 * d1 * ...* dn = N, the number of elements in arr

Pour la suite de ce tutoriel, utilisons cette syntaxe dans nos exemples.

#2. Essayons de remodeler notre vecteur à 12 éléments en un tableau 12 x 1.

 import numpy as np arr1 = np.arange(1,13) print("Original array, before reshaping:\n") print(arr1) # Reshape array arr3 = arr1.reshape(12,1) print("\nReshaped array:") print(arr3)

Dans la sortie ci-dessous, vous pouvez voir que le tableau a été remodelé selon les besoins.

 Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[ 1] [ 2] [ 3] [ 4] [ 5] [ 6] [ 7] [ 8] [ 9] [10] [11] [12]]

Alors, comment vérifier si nous avons obtenu une copie ou une vue ?

Pour vérifier cela, vous pouvez appeler l'attribut base sur le tableau renvoyé.

  • Si le tableau est une copie, l'attribut base sera None .
  • Si le tableau est une vue, l'attribut base sera le tableau d'origine.

Vérifions cela rapidement.

 arr3.base # Output array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

Comme vous pouvez le voir, l'attribut de base de arr3 renvoie le tableau d'origine. Cela signifie que nous avons reçu une vue du tableau d'origine.

#3. Maintenant, essayons de remodeler le vecteur dans un autre tableau 2 x 6 valide.

 import numpy as np arr1 = np.arange(1,13) print("Original array, before reshaping:\n") print(arr1) # Reshape array arr4 = arr1.reshape(2,6) print("\nReshaped array:") print(arr4)

Et voici la sortie :

 Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[ 1 2 3 4 5 6] [ 7 8 9 10 11 12]]

Dans la section suivante, arr1 en un tableau 3D.

Utilisez NumPy reshape() pour remodeler un tableau 1D en tableaux 3D

Pour remodeler arr1 en un tableau 3D, définissons les dimensions souhaitées sur (1, 4, 3).

 import numpy as np arr1 = np.arange(1,13) print("Original array, before reshaping:\n") print(arr1) # Reshape array arr3D = arr1.reshape(1,4,3) print("\nReshaped array:") print(arr3D)

Nous avons maintenant créé un tableau 3D avec les mêmes 12 éléments que le tableau d'origine arr1 .

 Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] Reshaped array: [[[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]]

Comment déboguer les erreurs de valeur lors du remodelage

Si vous vous souvenez de la syntaxe, le remodelage n'est valide que lorsque le produit des dimensions est égal au nombre d'éléments du tableau.

 import numpy as np arr1 = np.arange(1,13) print("Original array, before reshaping:\n") print(arr1) # Reshape array arr2D = arr1.reshape(4,4) print("\nReshaped array:") print(arr2D)

Ici, vous essayez de remodeler un tableau de 12 éléments en un tableau 4 × 4 avec 16 éléments. L'interpréteur renvoie une erreur de valeur, comme indiqué ci-dessous.

 Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12] ----------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-11-63552bcc8c37> in <module>() 6 7 # Reshape array ----> 8 arr2 = arr1.reshape(4,4) 9 print("\nReshaped array:") 10 print(arr2) ValueError: cannot reshape array of size 12 into shape (4,4)

Pour éviter de telles erreurs, vous pouvez utiliser -1 pour déduire automatiquement la forme de l'une des dimensions, en fonction du nombre total d'éléments.

Par exemple, si vous connaissez n - 1 dimensions à l'avance, vous pouvez utiliser -1 pour déduire la n-ième dimension dans le tableau remodelé.

Si vous avez un tableau de 24 éléments et que vous souhaitez le remodeler en un tableau 3D. Supposons que vous ayez besoin de 3 lignes et 4 colonnes. Vous pouvez transmettre la valeur de -1 le long de la troisième dimension.

 import numpy as np arr1 = np.arange(1,25) print("Original array, before reshaping:\n") print(arr1) # Reshape array arr_res = arr1.reshape(4,3,-1) print("\nReshaped array:") print(arr_res) print(f"Shape of arr_res:{arr_res.shape}")

Lorsque vous examinez la forme du tableau de formes, vous pouvez voir que le tableau remodelé a une forme de 2 le long de la troisième dimension.

 Original array, before reshaping: [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24] Reshaped 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]]] Shape of arr_res:(4, 3, 2)

Ceci est particulièrement utile pour aplatir un tableau. Et vous apprendrez cela dans la section suivante.

Utilisez NumPy reshape() pour aplatir un tableau

Il y a des moments où vous auriez besoin de revenir de tableaux à N dimensions à un tableau aplati. Supposons que vous vouliez aplatir une image en un long vecteur de pixels.

Codez un exemple simple en suivant les étapes suivantes :

  • Génère un tableau d'images en niveaux de gris 3 x 3, img_arr — avec des pixels compris entre 0 et 255.
  • Ensuite, aplatissez ce img_arr et imprimez le tableau aplati, flat_arr .
  • Imprimez également les formes de img_arr et flat_arr pour vérifier.
 img_arr = np.random.randint(0, 255, (3,3)) print(img_arr) print(f"Shape of img_arr: {img_arr.shape}") flat_arr = img_arr.reshape(-1) print(flat_arr) print(f"Shape of flat_arr: {flat_arr.shape}")

Voici la sortie.

 [[195 145 77] [ 63 193 223] [215 43 36]] Shape of img_arr: (3, 3) [195 145 77 63 193 223 215 43 36] Shape of flat_arr: (9,)

Dans la cellule de code ci-dessus, vous pouvez voir que flat_arr est un vecteur 1D de valeurs de pixels avec 9 éléments.

Résumé

Il est temps de revoir rapidement ce que nous avons appris.

  • Utilisez np.reshape(arr, newshape) pour remodeler arr dans la forme spécifiée dans newshape . newshape est un tuple spécifiant les dimensions du tableau remodelé.
  • Vous pouvez également utiliser arr.reshape(d0, d1, …, dn) pour remodeler arr afin qu'il ait la forme d0 x d1 x … x dn
  • Vérifiez si d0 * d1 * …* dn = N , le nombre d'éléments dans le tableau d'origine, pour éviter les erreurs de valeur lors du remodelage.
  • Utilisez -1 pour au plus une dimension dans la nouvelle forme si vous souhaitez que la dimension soit automatiquement déduite.
  • Enfin, vous pouvez utiliser arr.reshape(-1) pour aplatir le tableau.

Maintenant que vous savez utiliser NumPy reshape(), découvrez comment fonctionne la fonction NumPy linspace().

Vous pouvez essayer les exemples de code dans le bloc-notes Jupyter si vous le souhaitez. Si vous recherchez d'autres environnements de développement, consultez notre guide sur les alternatives Jupyter.