La indexación de matriz numpy en Python

Python Numpy indización de matrices : En este tutorial, vamos a aprender acerca de la indexación de Python Numpy Array, selección, notaciones soporte class, la selección condicional, la difusión de función, etc.

Indexación y Selección

# importing module
import numpy as np
# array declaration
arr = np.arange(0,11)
# printing array
print(arr)

salida

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

Ahora, para obtener el índice de un elemento en una matriz Numpy, es muy similar a la forma en que el índice se recupera de una lista, ejemplo double ( Nota: En Python, el índice comienza en 0).

# importing module
import numpy as np
# array declaration
arr = np.arange(0,11)
# printing array
print("arr:", arr)
# printing elements based on index
# returns element from given index
print("arr[8]:", arr[8])
# returns the elements between start, end
print("arr[1:5]:", arr[1:5])
# returns the elements between start, end
print("arr[0:5]:", arr[0:5])
#returns the elements until end
print("arr[:6]:", arr[:6])
# returns the elements from start
print("arr[2:]:", arr[2:])

salida

arr: [ 0  1  2  3  4  5  6  7  8  9 10]
arr[8]: 8
arr[1:5]: [1 2 3 4]
arr[0:5]: [0 1 2 3 4]
arr[:6]: [0 1 2 3 4 5]
arr[2:]: [ 2 3 4 5 6 7 8 9 10]

Indexación de una matriz 2-D

Consideremos el siguiente ejemplo,

# importing module
import numpy as np
# 2-D array
arr_2d = np.array([[10,15,20],[25,30,35],[40,45,50]])
# printing array
print(arr_2d)

salida

[[10 15 20]
[25 30 35]
[40 45 50]]

Hay dos maneras de acceder al índice en una matriz 2-D – for soporte y solo notación soporte . Sin embargo, la forma más preferida es el uso de la notación Individual soporte. A continuación se presentan los ejemplos del uso de Double y la notación de soporte único.

1) double soporte notación

# importing module
import numpy as np
# 2-D array
arr_2d = np.array([[10,15,20],[25,30,35],[40,45,50]])
# returns 2nd row 1st column
print(arr_2d[1][0])
# returns 1st row 3rd column
print(arr_2d[0][2])

salida

25
20

2) condición individual soporte

# importing module
import numpy as np
# 2-D array
arr_2d = np.array([[10,15,20],[25,30,35],[40,45,50]])
# using slice notation return required values
print(arr_2d[:2,1:])
# returns 1st row 3rd column
print(arr_2d[0,2])

salida

[[15 20]
[30 35]]
20

Condicional selección

Supongamos que tener una matriz NumPy,

import numpy as np
arr = np.arange(1,11)
print(arr)
# output: [ 1 2 3 4 5 6 7 8 9 10]

Aplicar & gt; operador en por encima de matriz creada

    bool_arr = arr>4

Operador de comparación se aplica a cada elemento de la matriz y el número de elementos en la Vuelta bool Numpy matriz será la misma que la matriz original de Numpy. Pero Double cada elemento que satisface la condición, no será cierto en una matriz y for falsas Otros en la matriz devuelta. El contenido de la matriz serán,

import numpy as np
arr = np.arange(1,11)
bool_arr = arr>4
print(bool_arr)
print(arr)

salida

[False False False False  True  True  True  True  True  True]
[ 1 2 3 4 5 6 7 8 9 10]

Ahora, para obtener los resultados condicionales, pasar la bool_arr a un Arr objeto y se devuelven sólo aquellos elementos cuyo valor es verdadera ,

print(arr[bool_arr])
# Output: [ 5 6 7 8 9 10]

la aplicación de la anterior en un solo paso,

import numpy as np
arr = np.arange(1,11)
print("arr...")
print(arr)
new_arr = arr[arr>6]
print("new_arr...")
print(new_arr)

salida

arr...
[ 1 2 3 4 5 6 7 8 9 10]
new_arr...
[ 7 8 9 10]

funciones de Radiodifusión

Radiodifusión es el método que utiliza NumPy para permitir aritmética entre matrices con diferentes formas y tamaños . Radiodifusión resuelve el problema de aritmética entre matrices de diferentes formas por en efecto la replicación de la matriz más pequeño junto con la dimensión coinciden.

NumPy no duplica la matriz más pequeña; en cambio, se hace un uso de memoria y computacionalmente eficiente de las estructuras existentes en la memoria que, en efecto lograr el mismo resultado.

Ejemplo de radiodifusión

import numpy as np
arr = np.arange(1,11)
# printing array before broadcasting
print("arr before broadcasting...")
print(arr)
arr[0:5] = 123
# printing array before broadcasting
print("arr before broadcasting...")
print(arr)

salida

arr before broadcasting...
[ 1 2 3 4 5 6 7 8 9 10]
arr before broadcasting...
[123 123 123 123 123 6 7 8 9 10]

Un comportamiento importante de radiodifusión se explica en el siguiente ejemplo,

import numpy as np
arr = np.arange(0,11)
# slice the array
sliced_arr = arr[0:5]
print(sliced_arr)
# broadcast the indicated number to 99
sliced_arr[:] = 99
print(sliced_arr)
# broadcasting also changes the parent array
print(arr)

salida

[0 1 2 3 4]
[99 99 99 99 99]
[99 99 99 99 99 5 6 7 8 9 10]

La razón NumPy hace lo anterior es para evitar el problema de memoria durante la manipulación de grandes conjuntos. Con el fin de conservar los valores originales, hay una opción para copiar la matriz se explica en el ejemplo de abajo,

import numpy as np
arr = np.arange(0,11)
print(arr)
arr_copy = arr.copy()
print(arr_copy)
arr_copy[:] = 1
print(arr_copy)
# the parent array is not modified
print(arr)

salida

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

normas de radiodifusión generales

Cuando se opera en dos matrices, NumPy compara sus formas elemento a elemento. Se inicia con las dimensiones finales y que se abre camino a seguir. Dos dimensiones son compatibles cuando,

  1. son iguales o
  2. uno de ellos es 1

Si no se cumplen estas condiciones, un ValueError : se lanza operandos no podía ser de difusión excepción juntos , lo que indica que las matrices tienen formas incompatibles. El tamaño de la matriz resultante es el tamaño máximo a lo largo de cada dimensión de las matrices de entrada.


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *