Tutoriel Numpy - Redéfinition et redimensionnement de NumPy Array

  1. numpy.reshape()
  2. ndarray.reshape()
  3. Fonction/Méthode reshape() Mémoire partagée
  4. numpy.resize()

NumPy a deux fonctions (et aussi des méthodes) pour changer les formes des tableaux - reshape et resize. Elles ont une différence significative sur laquelle nous allons nous concentrer dans ce chapitre.

numpy.reshape()

Commençons par la fonction pour changer la forme du tableau - reshape().

import numpy as np

arrayA = np.arange(8)
# arrayA = array([0, 1, 2, 3, 4, 5, 6, 7])

np.reshape(arrayA, (2, 4))
#array([[0, 1, 2, 3],
#       [4, 5, 6, 7]])

Elle convertit un vecteur de 8 éléments en un tableau de la forme de (4, 2). Elle pourrait être exécutée avec succès parce que la quantité d’éléments avant et après le reshape est identique. Elle soulève l’erreur ValueError si les quantités sont différentes.

In [1]: np.reshape(arrayA, (3, 4))
    ---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
ValueError: cannot reshape array of size 8 into shape (3,4)

Regardons de plus près le tableau de la forme remodelée. La première ligne est constituée des 4 premières données du arrayA et la seconde ligne prend les 4 dernières. Elle remplit les données dans l’ordre de la ligne dans cette conversion de forme.

Vous devez changer le paramètre order si vous voulez que l’ordre de remplissage des données soit une colonne.

In [1]: np.reshape(arrayA, (2, 4), order='F')
Out[1]: array([[0, 2, 4, 6],
        	  [1, 3, 5, 7]])

La valeur par défaut de ordre est C, ce qui signifie que les données sont lues ou écrites dans un ordre d’index de type C, ou en mots simples, dans l’ordre des lignes. F signifie lire ou écrire les données dans l’ordre de l’index Fortan, ou disons, dans l’ordre de la column. Vous pouvez vous référer à la documentation officielle NumPy pour connaître plus de détails sur les différentes méthodes d’indexation.

ndarray.reshape()

En plus de la fonction reshape, NumPy a aussi la méthode reshape dans l’objet ndarray. La méthode a les mêmes paramètres que la fonction mais sans tableau donné comme paramètre.

In [1]: arrayB = arrayA.reshape((2, 4))
    
In [2]: arrayB
Out[2]:	array([[0, 1, 2, 3],
       		[4, 5, 6, 7]])
In [1]: arrayA
Out[2]: array([0, 1, 2, 3, 4, 5, 6, 7])    

Vous pouvez voir que la méthode reshape est similaire à la fonction reshape. Et vous devez aussi être conscient que la méthode ndarray.reshape() ne change pas les données et la forme du tableau original mais retourne une nouvelle instance de ndarray.

Fonction/Méthode reshape() Mémoire partagée

Le tableau converti en fonction ou méthode reshape partage la même mémoire que le tableau original. Vous pouvez penser que c’est une copie superficielle en Python, où si vous changez les données d’un tableau, les données correspondantes de l’autre tableau sont également modifiées.

In [1]: arrayA = np.arange(8)
    	arrayB = arrayA.reshape((2, 4))
        arrayB
Out[2]:	array([[0, 1, 2, 3],
       		[4, 5, 6, 7]])
In [2]: arrayA[0] = 10
    	arrayA
Out[2]: array([10, 1, 2, 3, 4, 5, 6, 7]) 
In [3]: arrayB    
Out[3]:	array([[10, 1, 2, 3],
       		[4, 5, 6, 7]])    

numpy.resize()

numpy.resize() est un peu similaire à reshape dans le sens de la conversion de forme. Mais il a quelques différences significatives.

  1. Il n’a pas de paramètre order. L’ordre de resize est le même que order='C' dans reshape.
  2. Si le nombre d’éléments du tableau cible n’est pas le même que celui du tableau original, il forcera à redimensionner mais ne provoquera pas d’erreurs.

Concentrons-nous sur la deuxième différence.

In [1]: arrayA = np.arange(8)
        arrayB = np.resize(arrayA, (2, 4))
Out[1]: array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

Le résultat est le même que dans reshpae si les numéros d’éléments sont les mêmes.

In [1]: arrayC = np.resize(arrayA, (3, 4))
    	arrayC
Out[1]: array([[0, 1, 2, 3],
       [4, 5, 6, 7],
       [0, 1, 2, 3]])
In [2]: arrayD = np.resize(arrayA, (4, 4))
    	arrayD
Out[2]: array([[0, 1, 2, 3],
       [4, 5, 6, 7],
       [0, 1, 2, 3],
       [4, 5, 6, 7]])

Si le nouveau tableau a plus de lignes, il répétera les données du tableau original mais ne lèvera pas l’erreur.

In [1]: arrayE = np.resize(arrayA, (2, 2))
		arrayE
Out[1]: array([[0, 1],
       [2, 3]])    
In [2]: np.resize(arrayA, (1,4))
Out[2]: array([[0, 1, 2, 3]])

Si le nombre d’éléments dans le nouveau tableau est plus petit, il récupère le nombre d’éléments dont il a besoin pour remplir le nouveau tableau dans l’ordre des lignes.

Fonction/Méthode Mémoire

Le nouveau tableau ne partage pas la même mémoire que le tableau original dans la fonction/méthode resize. Le changement de données dans un tableau n’est pas mappé sur l’autre.

In [1]: arrayA = np.arange(8)
    	arrayB = arrayA.reshape((2, 4))
        arrayB
Out[2]:	array([[0, 1, 2, 3],
       		[4, 5, 6, 7]])
In [2]: arrayA[0] = 10
    	arrayA
Out[2]: array([10, 1, 2, 3, 4, 5, 6, 7]) 
In [3]: arrayB    
Out[3]:	array([[0, 1, 2, 3],
       		[4, 5, 6, 7]])