HOWTO · NumPy
Iterar sobre filas de una matriz Numpy en Python
Este tutorial explica cómo iterar sobre las filas de una matriz NumPy en Python.
En esta página
NumPy, una biblioteca fundamental en Python para operaciones numéricas, permite a los desarrolladores trabajar sin problemas con matrices, especialmente en el ámbito de la computación científica y la manipulación de datos. Cuando se trata de matrices multidimensionales, la capacidad de iterar sobre las filas es una habilidad fundamental.
En este artículo, exploraremos varios métodos y técnicas para iterar de manera eficiente sobre las filas de una matriz NumPy en Python.
Usar bucles for para iterar sobre las filas de una matriz NumPy en Python y los elementos dentro de cada fila
Para empezar, importamos la biblioteca NumPy como np y creamos una matriz NumPy 2D llamada my_array utilizando la función np.array. Esta matriz, denotada por corchetes, representa una matriz con tres filas y tres columnas.
import numpy as np
# Create a 2D NumPy array
my_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
Iterar sobre las filas de una matriz NumPy utilizando un bucle for es un enfoque común e intuitivo. El bucle for nos permite iterar sobre cada fila sin esfuerzo.
En el ejemplo proporcionado, usamos un bucle for para iterar sobre cada fila de my_array e imprimir el contenido de cada fila.
import numpy as np
# Create a 2D NumPy array
my_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# Iterate over rows using a for loop
for row in my_array:
print(row)
El bucle for itera sobre cada fila de la matriz y, en cada iteración, la variable row representa una sola fila de la matriz. La instrucción print(row) imprime el contenido de cada fila.
Un solo bucle produce filas completas, porque iterar una matriz bidimensional produce sus submatrices unidimensionales. Cuando necesita los elementos individuales dentro de cada fila, anide un segundo bucle dentro del primero:
import numpy as np
# Create a 2D NumPy array
my_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# Iterate over the elements within each row using a nested for loop
for row in my_array:
for cell in row:
print(cell)
El bucle interno se ejecuta una vez por cada elemento de la fila actual, por lo que los nueve elementos se imprimen uno por línea:
1
2
3
4
5
6
7
8
9
La salida del ejemplo demuestra la simplicidad de usar un bucle for para la iteración.
[1 2 3]
[4 5 6]
[7 8 9]
Usar un bucle for y la función flatten() para iterar sobre los elementos de una matriz NumPy en Python
Combinar un bucle for con la función flatten() ofrece un enfoque alternativo para iterar sobre los elementos de una matriz NumPy.
La función flatten() en NumPy es un método que devuelve una copia unidimensional de una matriz, colapsando todas las dimensiones. Esto es particularmente útil cuando desea iterar sobre todos los elementos de una matriz 2D en secuencia utilizando un bucle for.
Aquí está la sintaxis de la función flatten():
numpy_array.flatten(order="C")
numpy_array: La matriz que se va a aplanar.order: (Opcional) El orden en que se aplanan los elementos de la matriz. Puede serC(por filas, el predeterminado) oF(por columnas).
Veamos un ejemplo:
import numpy as np
# Create a 2D NumPy array
my_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# Iterate over rows using a for loop and flatten()
for cell in my_array.flatten():
print(cell, end=" ")
Salida:
1 2 3 4 5 6 7 8 9
En primer lugar, creamos una matriz 2D llamada my_array usando la función np.array(). Esta matriz contiene valores organizados en una matriz con tres filas y tres columnas.
Queremos recorrer cada elemento de la matriz, pero de una manera más secuencial. Así que usamos un bucle for para iterar sobre los elementos de la matriz después de aplicarle la función flatten().
La función flatten() esencialmente transforma nuestra matriz 2D en una matriz unidimensional más simple, lo que facilita recorrerla.
Dentro del bucle, en cada iteración, la variable cell toma el valor del elemento actual. Luego, imprimimos ese elemento, seguido de un espacio.
La parte end=" " en la instrucción print garantiza que los elementos se impriman en la misma línea con un espacio entre ellos. Así, cuando ejecutamos este código, obtenemos una línea ordenada de todos los elementos de nuestra matriz 2D, lo que lo convierte en una forma práctica de iterar sobre los elementos usando un bucle for y la función flatten().
Usar la función apply_along_axis() para iterar sobre las filas de una matriz NumPy en Python
La función apply_along_axis() en NumPy proporciona otra forma conveniente de aplicar una función a lo largo del eje especificado de una matriz, lo que la convierte en una herramienta efectiva para operaciones por filas.
Su sintaxis es la siguiente:
numpy.apply_along_axis(func1d, axis, arr, *args, **kwargs)
Parámetros:
func1d: La función que se aplicará a lo largo del eje especificado.axis: El eje a lo largo del cual se aplicará la función (0para columnas,1para filas).arr: La matriz de entrada.*argsy**kwargs: Argumentos posicionales y de palabra clave adicionales que se pasarán a la función.
Ahora, profundicemos en un ejemplo para demostrar cómo usar apply_along_axis() para iterar sobre filas en una matriz NumPy:
import numpy as np
my_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
def row_operation(row):
return row.sum()
result = np.apply_along_axis(row_operation, axis=1, arr=my_array)
print("Result of row-wise operation:", result)
Salida:
Result of row-wise operation: [ 6 15 24]
En este ejemplo, creamos una matriz NumPy 2D llamada my_array. Luego definimos una función row_operation() que toma una fila como entrada y realiza una operación específica en esa fila.
En este caso, calcula la suma de los elementos en cada fila.
A continuación, usamos la función apply_along_axis(), especificando la función row_operation, estableciendo axis=1 para indicar la aplicación por filas, y proporcionando nuestra matriz my_array como entrada.
El resultado es una matriz que contiene la salida de la función row_operation aplicada a cada fila de my_array. Finalmente, imprimimos el resultado, mostrando cómo apply_along_axis() itera eficientemente sobre las filas.
Iterar sobre las filas de una matriz NumPy en Python utilizando nditer
La función nditer es una parte de la biblioteca NumPy y está diseñada para iterar eficientemente sobre los elementos en una matriz. Ofrece una variedad de métodos y opciones para personalizar el proceso de iteración.
La sintaxis de nditer es la siguiente:
numpy.nditer(
op,
flags=["readwrite"],
op_flags=None,
op_dtypes=None,
order="K",
casting="safe",
buffersize=0,
)
Parámetros:
op: La matriz sobre la que se va a iterar.flags: Una lista de banderas que modifican el comportamiento del iterador (el valor predeterminado esreadwrite).op_flags: Banderas adicionales para cada operando (si corresponde).op_dtypes: Una lista de tipos de datos de operandos (si corresponde).order: El orden en que el iterador debe recorrer la matriz (Cpara el estilo C,Fpara el estilo Fortran,Kpara mantener el orden).casting: Especifica la regla de conversión para la conversión implícita de tipos.buffersize: Tamaño del búfer para optimización.
Ahora, ilustremos cómo usar nditer para iterar sobre filas en una matriz NumPy con un ejemplo práctico:
import numpy as np
my_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
with np.nditer(my_array, flags=["multi_index"], op_flags=["readwrite"]) as it:
for row_index in it:
row_data = my_array[it.multi_index[0], :]
print(f"Row {it.multi_index[0] + 1}: {row_data}")
Salida:
Row 1: [1 2 3]
Row 1: [1 2 3]
Row 1: [1 2 3]
Row 2: [4 5 6]
Row 2: [4 5 6]
Row 2: [4 5 6]
Row 3: [7 8 9]
Row 3: [7 8 9]
Row 3: [7 8 9]
En este ejemplo, primero creamos una matriz NumPy 2D llamada my_array. Para iterar sobre las filas, usamos la función nditer con la bandera 'multi_index', lo que indica que queremos rastrear el multi-índice durante la iteración.
Dentro del bucle, it.multi_index[0] nos da el índice de la fila actual, y usamos este índice para acceder a los elementos de la matriz a lo largo de esa fila.
En este caso, row_data representa los elementos de la fila actual.
Puede realizar cualquier operación por fila dentro del bucle, lo que convierte a nditer en una herramienta versátil para personalizar el proceso de iteración en función de sus necesidades específicas.
Iterar sobre las filas de una matriz NumPy en Python utilizando enumerate y ndenumerate
Además de los métodos discutidos anteriormente, las funciones integradas enumerate y ndenumerate, en combinación con un bucle for, también se pueden usar para iterar sobre las filas en una matriz NumPy.
Usar enumerate con un bucle for
La función enumerate en Python es una herramienta versátil para obtener tanto el índice como el valor de los elementos en un iterable. Cuando se combina con un bucle for, se convierte en una forma práctica de iterar sobre filas en una matriz NumPy.
Aquí hay un ejemplo:
import numpy as np
my_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
for row_index, row_data in enumerate(my_array):
print(f"Row {row_index + 1}: {row_data}")
Salida:
Row 1: [1 2 3]
Row 2: [4 5 6]
Row 3: [7 8 9]
En este ejemplo, enumerate(my_array) devuelve pares de índices de fila (row_index) y los datos de fila correspondientes (row_data). El bucle for luego itera sobre estos pares, lo que nos permite acceder e imprimir cada fila junto con su índice.
Usar ndenumerate con un bucle for
NumPy proporciona la función ndenumerate, diseñada específicamente para iterar sobre elementos y sus índices en matrices multidimensionales. Así es como puede usarla para iterar sobre filas:
import numpy as np
my_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
for index, value in np.ndenumerate(my_array):
row_index = index[0]
if index[1] == 0:
print(f"Row {row_index + 1}: {my_array[row_index, :]}", end=" ")
Salida:
Row 1: [1 2 3] Row 2: [4 5 6] Row 3: [7 8 9]
En este ejemplo, np.ndenumerate(my_array) devuelve pares de índices (index) y valores correspondientes (value). El bucle itera sobre estos pares, y usamos el primer índice (index[0]) para identificar el índice de fila.
Imprimimos el valor, asegurándonos de que esté en los valores de cada fila comprobando si el segundo índice (index[1]) es 0.
Ambos métodos ofrecen formas efectivas de iterar sobre filas en una matriz NumPy. El método enumerate proporciona un enfoque conciso y pitónico, mientras que ndenumerate de NumPy proporciona más control sobre el proceso de iteración, especialmente en matrices multidimensionales.
Conclusión
Iterar sobre las filas de una matriz NumPy es una habilidad fundamental para cualquiera que trabaje con datos en Python. Los métodos discutidos en este artículo proporcionan un kit de herramientas integral para que elija según sus necesidades específicas.
Ya sea la simplicidad de un bucle for, la eficiencia de nditer, o la flexibilidad de enumerate y ndenumerate, dominar estas técnicas indudablemente mejorará su destreza en la manipulación de matrices y contribuirá al desarrollo de aplicaciones Python robustas.