Los fundamentos de
las matrices NumPy

La manipulación de datos en Python es casi sinónimo de la manipulación de matrices NumPy: incluso las herramientas más nuevas como Pandas se construyen alrededor de la matriz NumPy. Esta sección presentará varios ejemplos del uso de la manipulación de matrices NumPy para acceder a datos y submatrices, y para dividir, remodelar y unir las matrices. Si bien los tipos de operaciones que se muestran aquí pueden parecer un poco áridos y pedantes, comprenden los componentes básicos de muchos otros ejemplos utilizados a lo largo del libro. ¡Conócelos bien!

Cubriremos algunas categorías de manipulaciones básicas de matrices aquí:

• Atributos de las matrices: Determinar el tamaño, la forma, el consumo de memoria y los tipos de datos de las matrices.
• Indexación de matrices: Obtención y configuración del valor de elementos de matriz individuales.
• División de matrices: Obtener y configurar submatrices más pequeñas dentro de una matriz más grande.
• Remodelación de matrices: Cambiar la forma de una matriz determinada.
• Unir y dividir matrices: Combinar varias matrices en una y dividir una matriz en muchas.

Atributos de una matriz NumPy¶

Primero, analicemos algunos atributos útiles de la matriz. Comenzaremos definiendo tres matrices aleatorias, una matriz unidimensional, bidimensional y tridimensional. Usaremos el generador de números aleatorios de NumPy, que semilla con un valor establecido para asegurarnos de que se generen las mismas matrices aleatorias cada vez que se ejecute este código:

In [1]:

import numpy as np
np.random.seed(0)  # seed for reproducibility

x1 = np.random.randint(10, size=6)  # One-dimensional array
x2 = np.random.randint(10, size=(3, 4))  # Two-dimensional array
x3 = np.random.randint(10, size=(3, 4, 5))  # Three-dimensional array

Cada matriz tiene atributos ndim (el número de dimensiones), shape (el tamaño de cada dimensión) y size (el tamaño total de la matriz):

In [2]:

print("x3 ndim: ", x3.ndim)
print("x3 shape:", x3.shape)
print("x3 size: ", x3.size)

x3 ndim:  3
x3 shape: (3, 4, 5)
x3 size:  60

Otro atributo útil es el dtype, el tipo de datos de la matriz (que se discutimó anteriormente en Comprensión de los tipos de datos en Python):

In [3]:

print("dtype:", x3.dtype)

dtype: int64

Otros atributos incluyen itemize, que enumera el tamaño (en bytes) de cada elemento de la matriz, y nbytes, que enumera el tamaño total (en bytes) de la matriz:

In [4]:

print("itemsize:", x3.itemsize, "bytes")
print("nbytes:", x3.nbytes, "bytes")

itemsize: 8 bytes
nbytes: 480 bytes

En general, esperamos que nbytes sea igual a itemize multiplicado por size.

Indexación de matrices:
Acceso a elementos individuales¶

Si está familiarizado con la indexación de listas estándar de Python, la indexación en NumPy le resultará bastante familiar. En una matriz unidimensional, se puede acceder al valor $i^{th}$ (contando desde cero) especificando el índice deseado entre corchetes, al igual que con las listas de Python:

In [5]:

x1

Out[5]:

array([5, 0, 3, 3, 7, 9])

In [6]:

x1[0]

Out[6]:

5

In [7]:

x1[4]

Out[7]:

7

Para indexar desde el final de la matriz, se pueden usar índices negativos:

In [8]:

x1[-1]

Out[8]:

9

In [9]:

x1[-2]

Out[9]:

7

En una matriz multidimensional, se puede acceder a los elementos mediante una tupla de índices separados por comas:

In [10]:

x2

Out[10]:

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

In [11]:

x2[0, 0]

Out[11]:

3

In [12]:

x2[2, 0]

Out[12]:

1

In [13]:

x2[2, -1]

Out[13]:

7

Los valores también se pueden modificar utilizando cualquiera de las notación de índice anterior:

In [14]:

x2[0, 0] = 12
x2

Out[14]:

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

Tenga en cuenta que, a diferencia de las listas de Python, las matrices NumPy tienen un tipo fijo. Esto significa, por ejemplo, que si intenta insertar un valor de punto flotante en una matriz de enteros, el valor se truncará silenciosamente. ¡No se deje sorprender por este comportamiento!

In [15]:

x1[0] = 3.14159  # this will be truncated!
x1

Out[15]:

array([3, 0, 3, 3, 7, 9])

Rebanado de matrices:
Acceso a submatrices¶

Así como podemos usar corchetes para acceder a elementos individuales de la matriz, también podemos usarlos para acceder a submatrices con la notación rebanada, marcada con dos puntos (:) personaje. La sintaxis de segmentación de NumPy sigue la de la lista estándar de Python; para acceder a una porción de una matriz x, use esto:

x[start:stop:step]

Si alguno de estos no está especificado, por defecto tienen los valores start = 0, stop= size of dimension, step = 1. Echaremos un vistazo al acceso a submatrices en una dimensión y en múltiples dimensiones.

Subarreglos unidimensionales¶

In [16]:

x = np.arange(10)
x

Out[16]:

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

In [17]:

x[:5]  # first five elements

Out[17]:

array([0, 1, 2, 3, 4])

In [18]:

x[5:]  # elements after index 5

Out[18]:

array([5, 6, 7, 8, 9])

In [19]:

x[4:7]  # middle sub-array

Out[19]:

array([4, 5, 6])

In [20]:

x[::2]  # every other element

Out[20]:

array([0, 2, 4, 6, 8])

In [21]:

x[1::2]  # every other element, starting at index 1

Out[21]:

array([1, 3, 5, 7, 9])

Un caso potencialmente confuso es cuando el valor de step es negativo. En este caso, se intercambian los valores predeterminados de start y stop. Esta se convierte en una forma conveniente de invertir una matriz:

In [22]:

x[::-1]  # all elements, reversed

Out[22]:

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

In [23]:

x[5::-2]  # reversed every other from index 5

Out[23]:

array([5, 3, 1])

Subarreglos multidimensionales¶

Los sectores multidimensionales funcionan de la misma manera, con varios sectores separados por comas. Por ejemplo:

In [24]:

x2

Out[24]:

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

In [25]:

x2[:2, :3]  # two rows, three columns

Out[25]:

array([[12,  5,  2],
       [ 7,  6,  8]])

In [26]:

x2[:3, ::2]  # all rows, every other column

Out[26]:

array([[12,  2],
       [ 7,  8],
       [ 1,  7]])

Finalmente, las dimensiones del subarreglo incluso se pueden invertir juntas:

In [27]:

x2[::-1, ::-1]

Out[27]:

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

Acceder a filas y columnas de matriz¶

Una rutina comúnmente necesaria es acceder a filas o columnas individuales de una matriz. Esto se puede hacer combinando la indexación y la división, utilizando una división vacía marcada con dos puntos (:):

In [28]:

print(x2[:, 0])  # first column of x2

[12  7  1]

In [29]:

print(x2[0, :])  # first row of x2

[12  5  2  4]

En el caso del acceso a filas, el segmento vacío se puede omitir para obtener una sintaxis más compacta:

In [30]:

print(x2[0])  # equivalent to x2[0, :]

[12  5  2  4]

Submatrices como vistas sin copia¶

Una cosa importante, y extremadamente útil, que debe saber acerca de los segmentos de matriz es que devuelven vistas en lugar de copias de los datos de la matriz. Esta es un área en la que la división de matrices de NumPy difiere de la división de listas de Python: en las listas, las divisiones serán copias. Considere nuestra matriz bidimensional de antes:

In [31]:

print(x2)

[[12  5  2  4]
 [ 7  6  8  8]
 [ 1  6  7  7]]

Extraigamos un subarreglo $2\times2$ de esto:

In [32]:

x2_sub = x2[:2, :2]
print(x2_sub)

[[12  5]
 [ 7  6]]

Ahora, si modificamos este subarreglo, veremos que se cambia el arreglo original. Observar:

In [33]:

x2_sub[0, 0] = 99
print(x2_sub)

[[99  5]
 [ 7  6]]

In [34]:

print(x2)

[[99  5  2  4]
 [ 7  6  8  8]
 [ 1  6  7  7]]

Este comportamiento predeterminado es bastante útil: significa que cuando trabajamos con grandes conjuntos de datos, podemos acceder y procesar partes de estos conjuntos de datos sin la necesidad de copiar el búfer de datos subyacente.

Creando copias de matrices¶

A pesar de las buenas características de las vistas de matriz, a veces es útil copiar explícitamente los datos dentro de una matriz o submatriz. Esto se puede hacer más fácilmente con el método copy ():

In [35]:

x2_sub_copy = x2[:2, :2].copy()
print(x2_sub_copy)

[[99  5]
 [ 7  6]]

Si ahora modificamos este subarreglo, el arreglo original no se toca:

In [36]:

x2_sub_copy[0, 0] = 42
print(x2_sub_copy)

[[42  5]
 [ 7  6]]

In [37]:

print(x2)

[[99  5  2  4]
 [ 7  6  8  8]
 [ 1  6  7  7]]

Remodelación de matrices¶

Otro tipo de operación útil es la remodelación de matrices. La forma más flexible de hacer esto es con el método reshape. Por ejemplo, si desea colocar los números del 1 al 9 en una cuadrícula de $3 \times 3$, puede hacer lo siguiente:

In [38]:

grid = np.arange(1, 10).reshape((3, 3))
print(grid)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

Tenga en cuenta que para que esto funcione, el tamaño de la matriz inicial debe coincidir con el tamaño de la matriz reformada. Siempre que sea posible, el método reshape utilizará una vista sin copia de la matriz inicial, pero con búferes de memoria no contiguos este no es siempre el caso.

Otro patrón de remodelación común es la conversión de una matriz unidimensional en una matriz bidimensional de filas o columnas. Esto se puede hacer con el método reshape, o más fácilmente haciendo uso de la palabra clave newaxis dentro de una operación de corte:

In [39]:

x = np.array([1, 2, 3])

# row vector via reshape
x.reshape((1, 3))

Out[39]:

array([[1, 2, 3]])

In [40]:

# row vector via newaxis
x[np.newaxis, :]

Out[40]:

array([[1, 2, 3]])

In [41]:

# column vector via reshape
x.reshape((3, 1))

Out[41]:

array([[1],
       [2],
       [3]])

In [42]:

# column vector via newaxis
x[:, np.newaxis]

Out[42]:

array([[1],
       [2],
       [3]])

Veremos este tipo de transformación a menudo a lo largo del resto del libro.

Concatenación y división de matrices¶

Todas las rutinas anteriores funcionaron en matrices únicas. También es posible combinar varias matrices en una y, a la inversa, dividir una sola matriz en varias matrices. Echaremos un vistazo a esas operaciones aquí.

Concatenación de matrices¶

La concatenación, o unión de dos matrices en NumPy, se logra principalmente mediante las rutinas np.concatenate, np.vstack y np.hstack. np.concatenate toma una tupla o lista de matrices como primer argumento, como podemos ver aquí:

In [43]:

x = np.array([1, 2, 3])
y = np.array([3, 2, 1])
np.concatenate([x, y])

Out[43]:

array([1, 2, 3, 3, 2, 1])

También puede concatenar más de dos matrices a la vez:

In [44]:

z = [99, 99, 99]
print(np.concatenate([x, y, z]))

[ 1  2  3  3  2  1 99 99 99]

También se puede utilizar para matrices bidimensionales:

In [45]:

grid = np.array([[1, 2, 3],
                 [4, 5, 6]])

In [46]:

# concatenate along the first axis
np.concatenate([grid, grid])

Out[46]:

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

In [47]:

# concatenate along the second axis (zero-indexed)
np.concatenate([grid, grid], axis=1)

Out[47]:

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

Para trabajar con matrices de dimensiones mixtas, puede resultar más claro utilizar las funciones np.vstack (pila vertical) y np.hstack (pila horizontal):

In [48]:

x = np.array([1, 2, 3])
grid = np.array([[9, 8, 7],
                 [6, 5, 4]])

# vertically stack the arrays
np.vstack([x, grid])

Out[48]:

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

In [49]:

# horizontally stack the arrays
y = np.array([[99],
              [99]])
np.hstack([grid, y])

Out[49]:

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

De manera similar, np.dstack apilará matrices a lo largo del tercer eje.

División de matrices¶

Lo opuesto a la concatenación es la división, que se implementa mediante las funciones np.split, np.hsplit y np.vsplit. Para cada uno de estos, podemos pasar una lista de índices dando los puntos de división:

In [50]:

x = [1, 2, 3, 99, 99, 3, 2, 1]
x1, x2, x3 = np.split(x, [3, 5])
print(x1, x2, x3)

[1 2 3] [99 99] [3 2 1]

Observe que N puntos de división, conduce a subarreglos N + 1. Las funciones relacionadas np.hsplit y np.vsplit son similares:

In [51]:

grid = np.arange(16).reshape((4, 4))
grid

Out[51]:

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

In [52]:

upper, lower = np.vsplit(grid, [2])
print(upper)
print(lower)

[[0 1 2 3]
 [4 5 6 7]]
[[ 8  9 10 11]
 [12 13 14 15]]

In [53]:

left, right = np.hsplit(grid, [2])
print(left)
print(right)

[[ 0  1]
 [ 4  5]
 [ 8  9]
 [12 13]]
[[ 2  3]
 [ 6  7]
 [10 11]
 [14 15]]

De manera similar, np.dsplit dividirá las matrices a lo largo del tercer eje.