Tutorial de Numpy - Rediseño y redimensionamiento de matrices de NumPy

1. numpy.reshape()
2. ndarray.reshape()
3. reshape() Función/Método Memoria compartida
4. numpy.resize()

NumPy tiene dos funciones (y también métodos) para cambiar las formas de los arrays - reshape y resize. Tienen una diferencia significativa que será el centro de atención de este capítulo.

numpy.reshape()

Comencemos con la función para cambiar la forma del array - 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]])

Convierte un vector de 8 elementos a el array de la forma de (4, 2). Puede ser ejecutada con éxito porque la cantidad de elementos antes y después de reshape es idéntica. Aumenta el ValueError si las cantidades son diferentes.

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

Echemos un vistazo más de cerca a el array de la remodelación. La primera fila contiene los primeros 4 datos del arrayA y la segunda fila contiene los últimos 4. Rellena los datos en el orden de la fila en esta conversión de remodelación.

Necesitas cambiar el parámetro order si quieres que el orden de llenado de los datos sea de columna.

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

El valor por defecto de orden es C, que significa leer o escribir datos en un orden de índice similar a C, o en palabras simples, en el orden de la fila. F significa leer o escribir datos en un orden de índice similar al Fortan, o digamos, en el orden de la column. Puede consultar la documentación oficial de NumPy para conocer más detalles de los diferentes métodos de indexación.

ndarray.reshape()

Además de la función reshape, NumPy tiene también el método reshape en el objeto ndarray. El método tiene los mismos parámetros que la función pero sin el array como parámetro.

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])

Puedes ver que el método reshape es similar a la función reshape. Y también debería ser consciente de que el método ndarray.reshape() no cambia los datos y la forma del array original, sino que devuelve una nueva instancia ndarray.

reshape() Función/Método Memoria compartida

La función o método del array convertido en reshape comparte la misma memoria del array original. Podrías pensar que es una copia superficial en Python, donde si cambias los datos de un array, los datos correspondientes en el otro array también se modifican.

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() es un poco similar a reshape en el sentido de conversión de formas. Pero tiene algunas diferencias significativas.

1. No tiene el parámetro order. El orden de resize es el mismo que order='C' en reshape.
2. Si el número de elementos del array de destino no es el mismo que el del array original, forzará a redimensionar pero no provocará errores.

Centrémonos en la segunda diferencia.

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

El resultado es el mismo que en reshpae si los números de elementos son los mismos.

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 el nuevo array tiene más filas, repetirá los datos del array original pero no aumentará el error.

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 el número de elementos en la nueva matriz es menor, se obtiene el número de elementos que necesita para rellenar la nueva matriz en el orden de las filas.

resize Función/Método Memoria

El nuevo array no comparte la misma memoria con el array original en la función/método resize. El cambio de datos en un array no se mapea al otro.

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]])