Pandas DataFrame: Seleccionando filas por condición
Cuando trabajamos con DataFrames de Pandas, a menudo necesitamos seleccionar subconjuntos de los datos basados en alguna condición específica. Esto se puede lograr utilizando el método `loc[]`, que nos permite seleccionar filas en función de una condición de columna específica. En esta guía, veremos cómo utilizar el método `loc[]` para seleccionar filas que satisfacen una condición en un DataFrame.
Selección de Filas con `loc[]`
Para seleccionar filas en un DataFrame que satisfacen una condición, podemos utilizar la sintaxis `df.loc[cond]`, donde `cond` es una expresión booleana que se evalúa en cada fila del DataFrame. La expresión booleana debe devolver `True` o `False` para cada fila. Las filas que devuelven `True` se seleccionan en el subconjunto resultante y las filas que devuelven `False` se excluyen.
Veamos un ejemplo simple. Supongamos que tenemos un DataFrame `df` que contiene información sobre algunos estudiantes y sus calificaciones:
```
import pandas as pd
data = {'Nombre': ['Juan', 'María', 'Pedro', 'Luis', 'Ana'],
'Edad': [20, 19, 21, 18, 20],
'Calif': [8.0, 9.0, 7.5, 6.0, 8.5]}
df = pd.DataFrame(data)
```
Podemos seleccionar las filas que tienen una calificación mayor o igual a 8 utilizando la sintaxis `df.loc[df['Calif'] >= 8]`. Esto nos devuelve un DataFrame que contiene solo las filas que satisfacen la condición de tener una calificación mayor o igual a 8:
```
Nombre Edad Calif
0 Juan 20 8.0
1 María 19 9.0
4 Ana 20 8.5
```
Selección de Filas con Múltiples Condiciones
Podemos utilizar la sintaxis `&` y `|` para combinar múltiples condiciones en una expresión booleana. La sintaxis `&` es el operador lógico 'y' y la sintaxis `|` es el operador lógico 'o'. Por ejemplo, si queremos seleccionar filas que tienen una calificación mayor o igual a 8 y una edad mayor o igual a 20, podemos utilizar la sintaxis `df.loc[(df['Calif'] >= 8) & (df['Edad'] >= 20)]`:
```
Nombre Edad Calif
0 Juan 20 8.0
4 Ana 20 8.5
```
De manera similar, si queremos seleccionar filas que tienen una calificación mayor o igual a 8 o una edad mayor o igual a 20, podemos utilizar la sintaxis `df.loc[(df['Calif'] >= 8) | (df['Edad'] >= 20)]`:
```
Nombre Edad Calif
0 Juan 20 8.0
1 María 19 9.0
4 Ana 20 8.5
```
Selección de Filas con `query()`
Otra forma de seleccionar filas en un DataFrame es utilizando el método `query()`. Este método nos permite escribir una expresión booleana más legible y fácil de entender que la sintaxis `df.loc[]`.
Por ejemplo, para seleccionar las filas que tienen una calificación mayor o igual a 8 utilizando `query()`, podemos escribir `df.query('Calif >= 8')`:
```
Nombre Edad Calif
0 Juan 20 8.0
1 María 19 9.0
4 Ana 20 8.5
```
De manera similar, para seleccionar filas que tienen una calificación mayor o igual a 8 y una edad mayor o igual a 20 utilizando `query()`, podemos escribir `df.query('Calif >= 8 and Edad >= 20')`.
Ejemplos de Código
Aquí hay algunos ejemplos de código que ilustran diferentes escenarios de selección de filas en un DataFrame:
Seleccionando filas que contienen una cadena específica en una columna
Supongamos que tenemos un DataFrame `df` que contiene información sobre algunos estudiantes y sus materias:
```
import pandas as pd
data = {'Nombre': ['Juan', 'María', 'Pedro', 'Luis', 'Ana'],
'Materia': ['Matemáticas', 'Historia', 'Ciencias', 'Matemáticas', 'Ciencias'],
'Nota': [8.0, 9.0, 7.5, 6.0, 8.5]}
df = pd.DataFrame(data)
```
Podemos seleccionar las filas que contienen la cadena 'Matemáticas' en la columna 'Materia' utilizando la expresión `df.loc[df['Materia'].str.contains('Matemáticas')]`:
```
Nombre Materia Nota
0 Juan Matemáticas 8.0
3 Luis Matemáticas 6.0
```
Seleccionando filas que no contienen una cadena específica en una columna
Podemos seleccionar las filas que no contienen la cadena 'Matemáticas' en la columna 'Materia' utilizando la expresión `df.loc[~df['Materia'].str.contains('Matemáticas')]`:
```
Nombre Materia Nota
1 María Historia 9.0
2 Pedro Ciencias 7.5
4 Ana Ciencias 8.5
```
Seleccionando filas que contienen valores nulos
Podemos seleccionar las filas que contienen valores nulos utilizando la expresión `df.loc[df.isnull().any(axis=1)]`:
```
Empty DataFrame
Columns: [Nombre, Materia, Nota]
Index: []
```
Conclusión
Utilizar `loc[]` y `query()` nos permite seleccionar filas de un DataFrame en función de cierta condición. Esta habilidad es fundamental para filtrar y manejar grandes conjuntos de datos. Desde seleccionar filas basadas en el valor de una columna hasta seleccionar filas que contienen una cadena específica en una columna, estas herramientas de Pandas son poderosas y flexibles,y pueden adaptarse a diferentes necesidades.
Preguntas frecuentes
¿Puedo seleccionar filas basadas en múltiples condiciones?
Sí, podemos utilizar los operadores lógicos `&` y `|` para combinar múltiples condiciones en una expresión booleana.
¿Cómo selecciono filas que contienen valores nulos en un DataFrame?
Podemos utilizar la expresión `df.loc[df.isnull().any(axis=1)]` para seleccionar filas que contienen valores nulos.
¿Cómo puedo seleccionar filas que tienen una cadena específica en una columna?
Podemos utilizar la expresión `df.loc[df['columna'].str.contains('cadena')]` para seleccionar filas que tienen una cadena específica en una columna.
¿Cómo puedo seleccionar filas que no contienen una cadena específica en una columna?
Podemos utilizar la expresión `df.loc[~df['columna'].str.contains('cadena')]` para seleccionar filas que no contienen una cadena específica en una columna.