Seleccionar filas y columnas en Pandas con iloc y loc

En los DataFrames de Pandas existen diferentes formas de seleccionar los registros de las filas y columnas. Siendo dos de las más importantes iloc y loc. La primera permite seleccionar los elementos en base a la posición, mientras que la segunda permite seleccionar mediante etiquetas o declaraciones condicionales. Esta entrada en un tutorial en el que se explicaran los fundamentos para seleccionar filas y columnas en Pandas con iloc y loc.

Los objetos DataFrame de Pandas

Los objetos DataFrame de Pandas son una estructura de datos de alto rendimiento con la que es posible manejar fácilmente datos tabulares para el análisis de datos. En estos objetos cada una de las filas representa un registro. Mientras que en cada una de las columnas representan variables, a las que generalmente se les asigna un nombre. Siendo una tarea habitual seleccionar de forma rápida tanto filas como columnas.

En este tutorial se va a utilizar el conjunto de datos de tips que se pueden encontrar en el paquete seaborn. La importación de los datos se puede realizar mediante el siguiente código.

from seaborn import load_dataset

df = load_dataset("tips")
df.head()

   total_bill   tip     sex smoker  day    time  size
0       16.99  1.01  Female     No  Sun  Dinner     2
1       10.34  1.66    Male     No  Sun  Dinner     3
2       21.01  3.50    Male     No  Sun  Dinner     3
3       23.68  3.31    Male     No  Sun  Dinner     2
4       24.59  3.61  Female     No  Sun  Dinner     4

Seleccionar filas y columnas en Pandas mediante posición con iloc

El método iloc se utiliza en los DataFrames para seleccionar los elementos en base a su ubicación. Su sintaxis es data.iloc[<filas>, <columnas>], donde <filas> y <columnas> son la posición de las filas y columnas que se desean seleccionar en el orden que aparecen en el objeto. Una notación familiar para los usuarios de Matlab. En un DataFrame cada una de las filas tiene un número que va desde 0 hasta el total de filas menos uno. Siendo iloc el método que permite seleccionar los datos en base a estos números. Lo mismo que aplica a las columnas.

En iloc hay dos argumentos filas y columnas. En caso de que se omita el segundo, se seleccionarán todas las columnas de la fila. Así para seleccionar diferentes filas se puede utilizar.

df.iloc[0] # Primera fila
df.iloc[1] # Segunda fila
df.iloc[-1] # Última fila

Nótese como el uso de valores negativos permite acceder a la última posición sin necesidad de conocer el tamaño del conjunto de datos. Por otro lado, para seleccionar una columna se tiene que utilizar : como primer parámetro, lo que indica todos, y el índice de esta como segundo. Así se puede hacer

df.iloc[:, 0] # Primera columna
df.iloc[:, 1] # Segunda columna
df.iloc[:, -1] # Última columna

Selección múltiple de filas o columnas mediante posición con iloc

En muchas ocasiones se puede desear seleccionar un conjunto de filas o columnas en lugar de una sola. Para ello se puede utilizar un vector con el listado en lugar de un escalar. Imprimiendo las filas o columnas en el orden indicado, por lo que se puede utilizar esto para reordenar los elementos de un DataFrame.

df.iloc[0:5] # Primeras cinco filas
df.iloc[:, 0:5] # Primeras cinco columnas
df.iloc[[0,2,1]]  # Primera, tercera y segunda filas
df.iloc[:, [0,2,1]]  # Primera, tercera y segunda columnas

Consideraciones al utilizar iloc

Es importante tener en cuenta que iloc devuelve una Serie Pandas cuando se selecciona una fila y un DataFrame cuando se selecciona varias. En el caso que sea necesario seleccionar un DataFrame con una única columna es necesario pasar una lista con la columna, no un escalar.

Por otro lado, al seleccionar varias filas o columnas con inicio:fin es necesario recordar que los valores ira desde el principio hasta el final menos uno. Por ejemplo, iloc[1:3] solamente seleccionara la segunda y tercera fila, 1 y 3. Teniendo en cuenta además que los índices en Python comienzan en 0, no en 1 como es el caso de R o Matlab.

Seleccionar filas y columnas en Pandas en base a etiquetas con loc

El método loc se puede usar de dos formas diferentes: seleccionar filas o columnas en base a una etiqueta o seleccionar filas o columnas en base a una condición.

Seleccionar filas o columnas en base a su etiqueta con loc

En el ejemplo importado las filas tienen como etiquete el número de fila. Por lo que el uso de loc parece similar al de iloc para las filas, aunque tiene algunas diferencias. Por ejemplo, si se han seleccionado las filas del 1 al 4 y se carga el resultado en un nuevo DataFrame a la hora de acceder a la fila 1 con loc se tendrá la primera del nuevo objeto mientras que iloc devolverá la segunda. Esto es así porque los índices se conservan, pero no las posiciones.

df_sub = df.loc[1:5]
df_sub.loc[1]

total_bill     10.34
tip             1.66
sex             Male
smoker            No
day              Sun
time          Dinner
size               3
Name: 1, dtype: object

df_sub.iloc[1]

total_bill     21.01
tip              3.5
sex             Male
smoker            No
day              Sun
time          Dinner
size               3
Name: 2, dtype: object

En el caso de las columnas se nota más la diferencia ya que se puede acceder a ellas por nombre, tanto sea una como varias

df.loc[:, 'tip'] # Columna tip
df.loc[:, ['tip', 'sex', 'day']] # Columnas tip, sex y day

Seleccionar filas o columnas en base a una condición con loc

Quizás esta sea una de las opciones más interesantes de las vistas, ya que permite seleccionar los datos en un DataFrame en base condiciones lógicas. Las cuales se pueden obtener a partir de los valores. Por ejemplo, se puede seleccionar fácilmente los registros correspondientes reservas realizadas por hombres:

is_male = df.loc[:, 'sex'] == 'Male'
df_male = df.loc[is_male]
df_male.head()

   total_bill   tip   sex smoker  day    time  size
1       10.34  1.66  Male     No  Sun  Dinner     3
2       21.01  3.50  Male     No  Sun  Dinner     3
3       23.68  3.31  Male     No  Sun  Dinner     2
5       25.29  4.71  Male     No  Sun  Dinner     4
6        8.77  2.00  Male     No  Sun  Dinner     2

En este ejemplo se puede ver que primero se ha seleccionado la columna sex y comprobado cuando esta tiene el valor Male. Lo que produce un objeto Serie únicamente con valores verdaderos o falsos. Esta serie es la que posteriormente se utiliza para seleccionar los registros que se cargar en el nuevo DataFrame. Los dos pasos aquí vistos se pueden escribir en una única línea.

df.loc[df.loc[:, 'sex'] == 'Male']

Conclusiones

En esta entrada se han visto los diferentes métodos disponibles para seleccionar filas y columnas en Pandas. En primer lugar, el método iloc mediante el cual se pueden seleccionar los elementos en base a su ubicación. En segundo lugar, el método loc con el que seleccionar filas o columnas en base a una etiqueta o seleccionar filas o columnas en base a una condición. Ambos métodos permiten seleccionar más de una fila o columna a la vez, lo que los hace altamente productivos. Además, poder utilizar condiciones lógicas en loc permite filtrar los datos.

Imágenes: Pixabay (PublicDomainPictures)