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,
- son iguales o
- 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.