Python: notación de corte en matrices NumPy

En este tutorial, repasaremos ejemplos de cómo dividir una matriz NumPy en Python. Cortaremos arreglos/matrices 1D y multidimensionales en subarreglo y submatrices.

Introducción

El término rebanar en programación generalmente se refiere a obtener una subcadena, una subtupla o una sublista de una cadena, tupla o lista, respectivamente.

Python ofrece una variedad de formas sencillas de dividir no solo estos tres sino cualquier iterable. Un iterable es, como su nombre indica, cualquier objeto sobre el que se pueda iterar.

En este artículo, repasaremos todo lo que necesita saber sobre Cortar Numpy Arrays en Python.

Corte de matriz NumPy {#corte de matriz numpy}

La forma más común de dividir una matriz NumPy es usando el operador : con la siguiente sintaxis:

1
2
array[start:end]
array[start:end:step]

El parámetro start representa el índice inicial, end es el índice final y step es el número de elementos que se "pasan" por encima.

NumPy es un paquete gratuito de Python que ofrece, entre otras cosas, arreglos n-dimensionales.

El corte de matrices 1D (unidimensionales) en NumPy se puede hacer con la misma notación que el corte de listas regulares en Python:

1
2
3
4
5
import numpy as np
arr = np.array([1,2,3,4])
print(arr[1:3:2])
print(arr[:3])
print(arr[::2])

Producción:

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

2D NumPy Array Slicing

Una matriz 2D en NumPy es una matriz de matrices, una matriz 3D es una matriz de matrices de matrices y así sucesivamente. Una matriz 2D se puede representar como una matriz de la siguiente manera:

1
2
3
import numpy
arr = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr)

Imprimamos esta matriz:

1
2
3
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

Cortar una matriz 2D puede dar como resultado una matriz o una matriz. La sintaxis que da como resultado una matriz sería:

1
arr[startx:endx:stepx, starty:endy:stepy]

La sintaxis que da como resultado una matriz:

1
2
arr[startx:endx:stepx, const]
arr[const, starty:endy:stepy]

El uso de esta sintaxis da como resultado una matriz cuyos elementos son las columnas en el rango de startx a endx en el eje x, y las filas en el rango de starty a endy en el eje y de la matriz original:

Echemos un vistazo a cómo podemos dividir esta matriz y en qué resulta el corte:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import numpy

arr = numpy.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print("The original matrix:")
print(arr)

print("A sliced submatrix:")
print(arr[1:4,2:4])

print("A sliced subarray:")
print(arr[1,:])

print("A sliced submatrix:")
print(arr[:,3:])

print("A sliced subarray:")
print(arr[:,3])

Este segmento de código imprime:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
The original matrix:
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]
 [13 14 15 16]]
A sliced submatrix:
[[ 7  8]
 [11 12]
 [15 16]]
A sliced subarray:
[5 6 7 8]
A sliced submatrix:
[[ 4]
 [ 8]
 [12]
 [16]]
A sliced subarray:
[ 4  8 12 16]

Conclusión

Cortar cualquier secuencia en Python es fácil, simple e intuitivo. La indexación negativa ofrece una manera fácil de adquirir los primeros o los últimos elementos de una secuencia, o invertir su orden.

En este artículo, hemos cubierto cómo dividir las matrices NumPy de Python.