Dos de los métodos más utilizados para acceder a los elementos de una Serie o un DataFrame en Pandas son loc e iloc. Algo que se debe a su gran flexibilidad, permite seleccionar elementos o subconjuntos usando tanto los nombres de las etiquetas (loc) como la posición (iloc) de forma intuitiva. Aunque, en algunos casos, pueden ofrecer problemas de rendimiento. Por ejemplo, en los bucles, cuando es necesario acceder a múltiples elementos. Problemas de rendimiento que se pueden solucionar reemplazando loc e iloc por at e iat para operar sobre los elementos de la serie o el DataFrame dentro de un bucle.
Operar sobre las filas de un DataFrame con loc e iloc
Para comprobar los problemas de rendimiento de loc e iloc se puede crear un DataFrame aleatorio con medio millón de filas y tres columnas.
import pandas as pd import numpy as np np.random.seed(0) df = pd.DataFrame(np.random.randint(0, 1000, (500000, 3)), columns=['A', 'B', 'C']) df.head()
A B C 0 684 559 629 1 192 835 763 2 707 359 9 3 723 277 754 4 804 599 70
Ahora se puede plantear un problema sencillo, sumar los valores de la primera (A) y segunda columna (B), para almacenar el resultado en la tercera (C). Lo que se puede implementar con el siguiente código en el que también se mide el tiempo de ejecución con time().
import time
start = time.time()
for index, row in df.iterrows():
df.loc[index, 'C'] = row.A + row.B
end = time.time()
print(end - start)16.9221031665802
En mi equipo el código ha tardado 16,92 segundos en ejecutarse. Se puede repetir el ejercicio cambiando loc por iloc, con lo que el código quedaría de la siguiente forma.
import time
start = time.time()
for index, row in df.iterrows():
df.iloc[index, 2] = row.A + row.B
end = time.time()
print(end - start)15.030578851699829
Lo que ofrece una ligera mejora del rendimiento, ahora el proceso ha tardado 15,03 segundos.
Operar sobre las filas de un DataFrame con at e iat
Este problema se puede resolver con at en lugar de loc, solamente reemplazo un método por el otro. Por lo que el código anterior quedaría como
import time
start = time.time()
for index, row in df.iterrows():
df.at[index, 'C'] = row.A + row.B
end = time.time()
print(end - start)9.518975973129272
Ahora solamente ha tardado 9,52 segundos en terminar la tarea, lo que supone una mejora del 78% respecto al uso de iloc. En el caso de iat el código que se debería ejecutar sería el siguiente.
import time
start = time.time()
for index, row in df.iterrows():
df.at[index, 'C'] = row.A + row.B
end = time.time()
print(end - start)11.972346067428589
Aunque en este caso el tiempo necesario para completar la tarea es de 11,97 segundos, un aumento de rendimiento menor respecto a iloc pero aún más importante.
¿Por qué no siempre se puede reemplazar loc e iloc por at e iat para mejorar el rendimiento en bucles?
Los métodos loc y at no funcionan exactamente igual, por lo que no es posible reemplazar uno por otro en todas las ocasiones. Lo mismo que en el caso de iloc e iat. Mientras que con loc e iloc se puede seleccionar un subconjunto del DataFrame original con at e iat solamente se pueden seleccionar un elemento. Por lo que, cuando se quiere crear un nuevo conjunto de datos solamente con unos valores se tiene que usar obligatoriamente loc o iloc. Por ejemplo, para seleccionar las tres primeras filas del objeto.
df.loc[:2]
A B C 0 684 559 629 1 192 835 763 2 707 359 9
En este caso si se cambia loc por at el código producirá un error.
Mejorar el rendimiento en bucles reemplazado iterrows()
En una publicación anterior se vio que iterrows() no es el método más eficiente para iterar sobre un DataFrame. Iterar sobre los índices con range() es una forma mucho más eficaz. Algo que se puede realizar fácilmente para el problema de ejemplo.
import time
start = time.time()
for _ in range(250):
for index in range(len(df.head())):
df.loc[index, 'C'] = df.loc[index, 'A'] + df.loc[index, 'B']
end = time.time()
print(end - start)0.059928178787231445
Si se repite el ejercicio anterior iterando sobre los índices con loc se tiene que el proceso, replicado esta vez 250 veces, solamente tarda 0,0599 segundos.
import time
start = time.time()
for _ in range(250):
for index in range(len(df.head())):
df.at[index, 'C'] = df.at[index, 'A'] + df.at[index, 'B']
end = time.time()
print(end - start)0.011784791946411133
Pero si se repite con at el tiempo se reduce a solo 0,0118 segundos. Por lo que la mejor ahora es de un factor 5.
Aunque esta es la opción más eficiente para resolver este problema, en las secciones anteriores se empleó `iterorws()` mostrar de una forma más clara al diferencia de rendimiento entre un método y otro.
Conclusiones
En esta entrada se ha visto que cambiar loc por at e iloc por iat, cuando esto es posible, se puede traducir en una importante mejora del rendimiento cuando se trabaja con bucles. Pudiendo mejorar en un factor de 5. Además se ha vuelto a comprobar que iterrows() tampoco es la forma más eficiente de iterar sobre un DataFrame, iterar sobre los índices es mucho más eficaz.
Deja una respuesta