Iloc vs Loc en Pandas: Una guía con ejemplos

Una de esas cosas molestas que todos intentamos averiguar cuando aprendemos Pandas es la distinción entre .loc y .iloc.

Acabemos con esta confusión y aclaremos la diferencia entre estos dos métodos. Daré muchos ejemplos, y espero que la distinción esté mucho más clara al final de este blog.

¿Qué son .loc e .iloc en Pandas?

Tanto .loc como .iloc son atributos esenciales de Pandas DataFrames, y ambos se utilizan para seleccionar subconjuntos específicos de datos. Su finalidad es acceder y permitir la manipulación de una parte concreta del Marco de Datos en lugar de todo el Marco de Datos. 

Como podemos ver en la tabla , la sintaxis es muy similar. La diferencia radica en cómo utilizamos los argumentos row_indexer y column_indexer. Esto se debe a que los dos métodos ofrecen enfoques diferentes para indexar los datos: mientras que .loc indexa basándose en los nombres de las etiquetas, .iloc toma como argumentos el índice numérico de posición de filas y columnas.

Examinemos detalladamente cada uno de los dos métodos, empezando por .loc.

Utilizando .loc: Selección por etiquetas

Para ilustrar los conceptos, consideremos una hipotética base de datos de clientes representada por este DataFrame llamado df, con el Customer ID representando el índice de fila:

En hay cuatro formas principales de seleccionar filas con .loc. Entre ellas están:

• Seleccionar una sola fila
• Seleccionar varias filas
• Seleccionar una porción de filas
• Selección condicional de filas

Seleccionar una sola fila con .loc

Para seleccionar una sola fila, utilizamos la etiqueta de la fila que queremos recuperar como row_indexer. En consecuencia, la sintaxis es la siguiente: df.loc['row_label']. Vamos a utilizarlo para mostrar toda la información sobre nuestro cliente Ali Khan:

df.loc['C345']

Seleccionar varias filas con .loc

Si queremos seleccionar varias filas que no se siguen necesariamente en orden, tenemos que pasar una lista de sus etiquetas de fila como argumento row_indexer. Esto significa que tenemos que utilizar no uno, sino dos pares de corchetes: uno para la sintaxis normal de .loc y otro para la lista de etiquetas.

La línea df.loc[['row_label_1', 'row_label_2']] devolverá las dos filas del DataFrame df especificadas en la lista. Supongamos que queremos conocer no sólo la información sobre Ali Khan, sino también sobre David Lee:

df.loc[['C345', 'C567']]

Seleccionar una porción de filas con .loc

Podemos seleccionar un rango de filas pasando las etiquetas de la primera y la última fila con dos puntos entre ellas: df.loc['row_label_start':'row_label_end']. Podríamos mostrar las cuatro primeras filas de nuestro DataFrame así:

df.loc['C123' : 'C456']

Aquí hay que tener en cuenta dos cosas:

1. La salida incluye la fila especificada en row_label_end. Esto es diferente en .iloc, que trataremos más adelante.
2. Sólo utilizamos un par de corchetes, aunque queramos recuperar varias filas. No utilizamos una lista para especificar las distintas filas, por lo que utilizar dos corchetes devolvería un SyntaxError.

Selección condicional de filas mediante .loc

También podemos devolver filas basándonos en una expresión condicional. Podemos filtrar todas las filas según cumplan o no una determinada condición y mostrar sólo las que la cumplan.

La sintaxis correspondiente es df.loc[conditional_expression], siendo conditional_expression una declaración sobre los valores permitidos en una columna concreta.

Para columnas con datos no numéricos (como Name o Country), la declaración sólo puede utilizar el operador igual o desigual, ya que no hay orden entre los valores. Podríamos, por ejemplo, devolver todas las filas de clientes que no sean de Asia:

df.loc[df['Region'] != 'Asia']

Seleccionar una sola columna con .loc

Para seleccionar columnas, tenemos que especificar el argumento column_indexer, que viene después del argumento row_indexer. Si sólo queremos especificar la column_indexer, tenemos que marcar de alguna manera que queremos devolver todas las filas y sólo filtrar por las columnas. ¡Veamos cómo podemos hacerlo!

Puedes seleccionar una sola columna especificando en column_indexerla etiqueta de la columna correspondiente. Para recuperar todas las filas, tenemos que especificar la dirección row_indexer con dos puntos simples. Llegamos a una sintaxis que tiene este aspecto: df.loc[:, 'column_name'].

Vamos a mostrar la Name de cada cliente:

df.loc[:, 'Name']

Seleccionar varias columnas con .loc

De forma similar a la selección de varias filas, tenemos que pasar una lista de etiquetas de columnas si queremos devolver varias columnas de un DataFrame que no se sucedan necesariamente en orden: df.loc[:, [col_label_1, 'col_label_2']].

Suponiendo que quisiéramos añadir el Age de todos los clientes a nuestra última salida, funcionaría así:

df.loc[:, ['Name', 'Age']]

Seleccionar una porción de columnas con .loc

Si utilizas dos puntos entre las etiquetas de dos columnas, se seleccionarán todas las columnas del rango de orden comprendido entre las dos columnas especificadas. Incluye la columna final, lo que significa que la columna llamada col_end también se seleccionará en la sintaxis estándar, que es la siguiente: df.loc[:, 'col_start':'col_end'].

Si nos interesaran los Name, Country, y Region de nuestros clientes, nuestra línea de código podría ser:

df.loc[:, 'Name':'Region']

Selección combinada de filas y columnas mediante .loc

También es posible especificar tanto el row_indexer como el column_indexer. Se puede utilizar para recuperar una única información, es decir, una celda del Marco de datos. Para ello, especificamos una fila y una columna utilizando la sintaxis df.loc['row_label', 'column_name'] .

El caso más útil es devolver un sub-DataFrame que se centre exactamente en el conjunto de filas y columnas que nos interesan. Es posible especificar ambos indexadores como listas utilizando los corchetes, o como una rebanada utilizando los dos puntos, e incluso combinarlo con una expresión condicional para la selección de filas.

He aquí un ejemplo de devolución de Name, Country, y Region de cada cliente con un Age superior a 30:

df.loc[df['Age'] > 30, 'Name':'Region']

Utilizando .iloc: Selección por posición entera

.iloc selecciona por posición en lugar de por etiqueta. Esta es la sintaxis estándar para utilizar .iloc: df.iloc[row_indexer, column_indexer]. Hay dos cosas especiales que debes tener en cuenta:

• Cuenta a partir de 0: La primera fila y columna tienen el índice 0, la segunda el índice 1, etc.
• Exclusividad del valor final de rango: Al utilizar un corte, la fila o columna especificada tras los dos puntos no se incluye en la selección.

Seleccionar una sola fila con .iloc

Se puede seleccionar una sola fila utilizando el número entero que representa el número de índice de la fila como row_indexer. No necesitamos comillas ya que estamos introduciendo un número entero y no una cadena de etiquetas como hicimos con .loc. Para devolver la primera fila de un DataFrame llamado df, introduce df.iloc[0].

En nuestro DataFrame de ejemplo, esta misma línea de código devuelve la información de John Doe:

df.iloc[0]

Seleccionar varias filas con .iloc

La selección de varias filas funciona en .iloc como en .loc-introducimos los números enteros del índice de fila en una lista con corchetes. La sintaxis es la siguiente: df.iloc[[0, 3, 4]].

A continuación puedes ver el resultado correspondiente en nuestra tabla de clientes:

df.iloc[[0, 3, 4]]

Seleccionar una porción de filas con .iloc

Para seleccionar una porción de filas, utilizamos dos puntos entre dos enteros de índice de fila especificados. Ahora, tenemos que prestar atención a la exclusividad mencionada anteriormente. 

Podemos tomar como ejemplo la línea df.iloc[1:4] para ilustrar este concepto. El índice número 1 significa la segunda fila, por lo que nuestro corte empieza ahí. El índice entero 4 representa la quinta fila, pero como .iloc no es inclusivo para la selección de trozos, nuestra salida incluirá todas las filas hasta la última antes de ésta. Por tanto, devolverá la segunda, tercera y cuarta fila. 

Probemos que la línea funciona como debe:

df.iloc[1:4]

Seleccionar una sola columna con .iloc

La lógica de selección de columnas mediante .iloc sigue lo que hemos aprendido hasta ahora. Veamos cómo funciona para columnas únicas, columnas múltiples y trozos de columna.

Al igual que con .loc, es importante especificar el row_indexer antes de poder pasar al column_indexer. Para recuperar los valores de la tercera columna de df para cada fila, introducimos df.iloc[:, 2].

Como Region es la tercera columna de nuestro DataFrame, se recuperará como consecuencia de esa línea de código:

df.iloc[:, 2]

Seleccionar varias columnas con .iloc

Para seleccionar varias columnas que no sean necesariamente consecutivas, podemos introducir de nuevo una lista que contenga números enteros como column_indexer. La línea df.iloc[:, [0, 3]] devuelve tanto la primera como la cuarta columna. 

En nuestro caso, la información mostrada es la Name así como la Age de cada cliente:

df.iloc[:, [0, 3]]

Seleccionar una porción de columnas con .iloc

Para la selección de rodajas mediante .iloc, la lógica de column_indexer sigue a la de row_indexer. La columna representada por el número entero después de los dos puntos no se incluye en la salida. Para recuperar la segunda y la tercera columna, la línea de código debe ser como sigue: df.iloc[:, 1:3].

Esta línea devuelve toda la información geográfica que tenemos sobre nuestros clientes:

df.iloc[:, 1:3]

Selección combinada de filas y columnas mediante .iloc

Podemos unir lo que hemos aprendido sobre .iloc para combinar la selección de filas y columnas. De nuevo, es posible devolver una sola celda o un sub-DataFrame. Para devolver la única celda en la intersección de la fila 3 y la columna 4, introducimos df.iloc[2, 3].

Al igual que con .loc, podemos especificar ambos indexadores como listas utilizando los corchetes, o como trozos utilizando los dos puntos. Si queremos seleccionar filas utilizando expresiones condicionales, eso también es técnicamente posible con .iloc, pero no se recomienda. Utilizar los nombres de las etiquetas y .loc suele ser mucho más intuitivo y menos propenso a errores.

Este último ejemplo muestra Country, Region y Age para la primera, segunda y quinta fila de nuestro DataFrame:

df.iloc[[0,1,4], 1:4]

.iloc frente a .loc: Cuándo utilizar cuál

En general, hay una regla empírica sencilla en la que la elección del método depende de tu conocimiento del Marco de datos:

• Utiliza .loc cuando conozcas las etiquetas (nombres) de las filas/columnas.
• Utiliza .iloc cuando conozcas las posiciones enteras de las filas/columnas.

Algunos escenarios favorecen .loc o .iloc por su naturaleza. Por ejemplo, iterar sobre filas o columnas es más fácil e intuitivo utilizando enteros que etiquetas. Como ya hemos dicho, filtrar filas basándose en condiciones sobre los valores de las columnas es menos propenso a errores utilizando los nombres de las etiquetas de las columnas.

Error de clave, error de nombre y error de índice con .loc e .iloc

Veamos los posibles problemas. Un escollo común al utilizar .loc es encontrarse con un KeyError. Este error se produce cuando intentamos acceder a una etiqueta de fila o columna que no existe en nuestro DataFrame. Para evitarlo, siempre tenemos que asegurarnos de que las etiquetas que utilizamos son correctas y de que coinciden con las etiquetas existentes en tu DataFrame, y comprobar dos veces si hay errores tipográficos.

Además, es importante utilizar siempre comillas para las etiquetas especificadas mediante .loc. Olvidarlos te devolverá un NameError.

Se puede producir un IndexError al utilizar .iloc si especificamos una posición entera que está fuera del rango válido de los índices de nuestro DataFrame. Esto ocurre cuando el índice al que intentas acceder no existe, ya sea porque supera el número de filas o columnas de tu Marco de datos o porque es un valor negativo. Para evitar este error, comprueba las dimensiones de tu Marco de datos y utiliza valores de índice adecuados dentro del rango válido.

Conclusión

Espero que este blog te haya sido útil y que la distinción entre .loc y .iloc esté ya clara. Para saber más, aquí tienes unos buenos pasos a seguir:

• SettingWithCopyWarning in Pandas: Cómo solucionar esta advertencia
• Curso: Manipulación de datos con pandas
• Curso: Escribir código eficiente con pandas
• Hoja de trucos: Manejo de datos con pandas
• Hoja de trucos: Remodelación de datos con pandas