En NumPy, la **indexación** y el **slicing** permiten acceder y modificar elementos de arrays de manera muy flexible. Estas técnicas son esenciales para trabajar con arrays de múltiples dimensiones.
### **1. Indexación**
La indexación en NumPy es similar a la de listas de Python, pero se extiende a arrays de múltiples dimensiones. Los índices comienzan en 0.
#### **1.1. Indexación en arrays unidimensionales**
import numpy as np
\# Array unidimensional
arr = np.array(\[10, 20, 30, 40, 50])
\# Acceder al primer elemento
print(arr\[0]) # 10
\# Acceder al último elemento
print(arr\[-1]) # 50
#### **1.2. Indexación en arrays multidimensionales**
En arrays multidimensionales, se usa una tupla de índices, donde cada índice corresponde a una dimensión del array.
\# Array bidimensional
arr\_2d = np.array(\[\[1, 2, 3], \[4, 5, 6], \[7, 8, 9]])
\# Acceder al elemento en la fila 1, columna 2
print(arr\_2d\[1, 2]) # 6
\# Acceder a toda la fila 0
print(arr\_2d\[0]) # \[1 2 3]
\# Acceder a toda la columna 1
print(arr\_2d\[:, 1]) # \[2 5 8]
#### **1.3. Modificación mediante indexación**
Se puede cambiar el valor de un elemento específico accediendo a él mediante su índice.
\# Cambiar el valor en la fila 1, columna 2
arr\_2d\[1, 2] = 10
print(arr\_2d)
\# \[\[ 1 2 3]
\# \[ 4 5 10]
\# \[ 7 8 9]]
### **2. Slicing (Corte de arrays)**
El slicing en NumPy permite extraer una parte del array (subarrays). La sintaxis general para slicing es arr\[inicio:fin], donde se incluye inicio y se excluye fin.
#### **2.1. Slicing en arrays unidimensionales**
\# Array unidimensional
arr = np.array(\[10, 20, 30, 40, 50])
\# Extraer elementos desde el índice 1 hasta el 3 (no incluye el 3)
print(arr\[1:3]) # \[20 30]
\# Todos los elementos desde el índice 2 en adelante
print(arr\[2:]) # \[30 40 50]
\# Todos los elementos hasta el índice 3 (sin incluirlo)
print(arr\[:3]) # \[10 20 30]
#### **2.2. Slicing en arrays multidimensionales**
En arrays multidimensionales, se puede aplicar slicing en cada dimensión.
\# Array bidimensional
arr\_2d = np.array(\[\[1, 2, 3], \[4, 5, 6], \[7, 8, 9]])
\# Extraer un subarray: filas 0 y 1, columnas 1 y 2
subarray = arr\_2d\[0:2, 1:3]
print(subarray)
\# \[\[2 3]
\# \[5 6]]
\# Extraer todas las filas y solo la columna 0
print(arr\_2d\[:, 0]) # \[1 4 7]
#### **2.3. Slicing con paso**
Se puede definir un paso en el slicing, que indica la cantidad de elementos que se deben saltar.
\# Array unidimensional
arr = np.array(\[10, 20, 30, 40, 50])
\# Extraer elementos cada dos posiciones
print(arr\[::2]) # \[10 30 50]
\# Array bidimensional
arr\_2d = np.array(\[\[1, 2, 3], \[4, 5, 6], \[7, 8, 9]])
\# Extraer subarray con salto en las filas
print(arr\_2d\[::2, :]) # \[\[1 2 3] \[7 8 9]]
### **3. Indexación booleana**
NumPy permite seleccionar elementos del array en función de una condición. Esto se conoce como **indexación booleana**.
\# Array unidimensional
arr = np.array(\[10, 20, 30, 40, 50])
\# Condición: seleccionar elementos mayores a 20
cond = arr > 20
print(arr\[cond]) # \[30 40 50]
### **4. Indexación avanzada**
En NumPy, también puedes seleccionar elementos específicos utilizando listas o arrays de índices.
\# Array unidimensional
arr = np.array(\[10, 20, 30, 40, 50])
\# Seleccionar elementos en los índices 0, 2 y 4
print(arr\[\[0, 2, 4]]) # \[10 30 50]
\# Array bidimensional
arr\_2d = np.array(\[\[1, 2, 3], \[4, 5, 6], \[7, 8, 9]])
\# Seleccionar elementos específicos de varias filas
print(arr\_2d\[\[0, 2], \[1, 2]]) # \[2 9]
### **5. Asignación mediante slicing**
También es posible modificar partes de un array utilizando slicing.
\# Array unidimensional
arr = np.array(\[10, 20, 30, 40, 50])
\# Cambiar los primeros tres elementos
arr\[:3] = \[1, 2, 3]
print(arr) # \[ 1 2 3 40 50]
\# Array bidimensional
arr\_2d = np.array(\[\[1, 2, 3], \[4, 5, 6], \[7, 8, 9]])
\# Cambiar toda la primera fila
arr\_2d\[0, :] = \[0, 0, 0]
print(arr\_2d)
\# \[\[0 0 0]
\# \[4 5 6]
\# \[7 8 9]]
### Resumen de indexación y slicing en NumPy:
- **Indexación**: Se usa para acceder a elementos individuales de arrays de cualquier dimensión.
- **Slicing**: Extrae subarrays especificando rangos (inicio, fin, paso).
- **Indexación booleana**: Selecciona elementos basados en condiciones.
- **Indexación avanzada**: Permite seleccionar varios elementos específicos a la vez.
Estas técnicas son muy poderosas para manipular y acceder a datos de manera eficiente en NumPy. ¿Te gustaría profundizar en algún aspecto específico?
