Tutorial Pandas: Operaciones de filtrado, búsqueda y ordenación

Operaciones de búsqueda y filtrado

En Pandas, las operaciones de búsqueda y filtrado son esenciales para la manipulación de datos. Estas operaciones permiten seleccionar subconjuntos de datos de un DataFrame en función de ciertas condiciones. 

A continuación, se describen las técnicas más comunes para realizar estas operaciones.

Para filtrar filas en un DataFrame en función de una condición, se utiliza la notación booleana. Por ejemplo, para filtrar un DataFrame df y obtener solo las filas donde la columna A es mayor que 5, se puede hacer lo siguiente:

import pandas as pd

# Crear un DataFrame de ejemplo
df = pd.DataFrame({
    'A': [1, 2, 6, 4, 5],
    'B': [10, 20, 30, 40, 50]
})

# Filtrar filas donde la columna A es mayor que 5
filtered_df = df[df['A'] > 5]
print(filtered_df)

Para buscar valores específicos dentro de una columna, se puede utilizar el método isin(). Este método devuelve un DataFrame con las filas que contienen los valores especificados:

# Filtrar filas donde la columna B contiene valores específicos
values_to_search = [20, 40]
filtered_df = df[df['B'].isin(values_to_search)]
print(filtered_df)

La selección basada en múltiples condiciones se puede realizar utilizando operadores lógicos (& para "y", | para "o"). Por ejemplo, para filtrar filas donde la columna A es mayor que 2 y la columna B es menor que 50:

# Filtrar filas con múltiples condiciones
filtered_df = df[(df['A'] > 2) & (df['B'] < 50)]
print(filtered_df)

Para buscar y filtrar datos basados en patrones de texto, se puede utilizar el método str.contains() en combinación con la notación booleana. Por ejemplo, para filtrar filas donde la columna C contiene la subcadena 'foo':

import pandas as pd

# Crear un DataFrame de ejemplo con datos de texto
df = pd.DataFrame({
    'A': [1, 2, 6, 4, 5],
    'C': ['foo', 'bar', 'foo', 'baz', 'qux']
})

# Filtrar filas donde la columna C contiene 'foo'
filtered_df = df[df['C'].str.contains('foo')]
print(filtered_df)

El método query() proporciona una sintaxis similar a SQL para realizar búsquedas y filtrados de manera más legible. Por ejemplo, para filtrar filas donde la columna A es mayor que 2 y la columna B es menor que 50:

import pandas as pd

# Crear un DataFrame de ejemplo
df = pd.DataFrame({
    'A': [1, 2, 6, 4, 5],
    'B': [10, 20, 30, 40, 50]
})

# Usar el método query para filtrar filas
filtered_df = df.query('A > 2 and B < 50')
print(filtered_df)

Para buscar valores nulos o no nulos, se pueden utilizar los métodos isna() y notna(). Por ejemplo, para filtrar filas donde la columna D tiene valores nulos:

import pandas as pd

# Crear un DataFrame de ejemplo con valores nulos
df = pd.DataFrame({
    'A': [1, 2, 6, 4, 5],
    'D': [None, 20, 30, None, 50]
})

# Filtrar filas donde la columna D tiene valores nulos
filtered_df = df[df['D'].isna()]
print(filtered_df)

Estas técnicas permiten realizar búsquedas y filtrados de manera eficiente y flexible en Pandas, facilitando la manipulación y análisis de datos.

Operaciones lógicas

Las operaciones lógicas en Pandas permiten combinar múltiples condiciones de filtrado para seleccionar subconjuntos de datos de un DataFrame. Estas operaciones se basan en operadores lógicos como & (AND), | (OR) y ~ (NOT). 

A continuación, se detallan las técnicas más comunes para realizar estas operaciones.

Para combinar condiciones usando el operador AND (&), se deben colocar las condiciones entre paréntesis. Por ejemplo, para filtrar un DataFrame df y obtener solo las filas donde la columna A es mayor que 2 y la columna B es menor que 50:

import pandas as pd

# Crear un DataFrame de ejemplo
df = pd.DataFrame({
    'A': [1, 2, 6, 4, 5],
    'B': [10, 20, 30, 40, 50]
})

# Filtrar filas donde la columna A es mayor que 2 y la columna B es menor que 50
filtered_df = df[(df['A'] > 2) & (df['B'] < 50)]
print(filtered_df)

Para combinar condiciones usando el operador OR (|), también se deben colocar las condiciones entre paréntesis. Por ejemplo, para filtrar filas donde la columna A es mayor que 2 o la columna B es menor que 50:

# Filtrar filas donde la columna A es mayor que 2 o la columna B es menor que 50
filtered_df = df[(df['A'] > 2) | (df['B'] < 50)]
print(filtered_df)

El operador NOT (~) se utiliza para invertir una condición. Por ejemplo, para filtrar filas donde la columna A no es mayor que 2:

# Filtrar filas donde la columna A no es mayor que 2
filtered_df = df[~(df['A'] > 2)]
print(filtered_df)

El método loc también puede ser utilizado para aplicar estas operaciones lógicas de manera más explícita. Por ejemplo, para filtrar filas donde la columna A es mayor que 2 y la columna B es menor que 50 utilizando loc:

# Usar el método loc para filtrar filas
filtered_df = df.loc[(df['A'] > 2) & (df['B'] < 50)]
print(filtered_df)

Además de los operadores lógicos básicos, Pandas también permite el uso de métodos específicos para realizar operaciones lógicas complejas. Por ejemplo, el método any() puede ser utilizado para verificar si alguna de las condiciones en una fila es verdadera. Para ilustrar esto, consideremos un DataFrame con columnas A, B y C:

# Crear un DataFrame de ejemplo
df = pd.DataFrame({
    'A': [1, 2, 6, 4, 5],
    'B': [10, 20, 30, 40, 50],
    'C': [100, 200, 300, 400, 500]
})

# Filtrar filas donde alguna de las columnas A, B o C es mayor que 300
filtered_df = df[(df[['A', 'B', 'C']] > 300).any(axis=1)]
print(filtered_df)

De manera similar, el método all() puede ser utilizado para verificar si todas las condiciones en una fila son verdaderas. Por ejemplo, para filtrar filas donde todas las columnas A, B y C son mayores que 10:

# Filtrar filas donde todas las columnas A, B y C son mayores que 10
filtered_df = df[(df[['A', 'B', 'C']] > 10).all(axis=1)]
print(filtered_df)

Estas técnicas permiten combinar y manipular condiciones lógicas de manera eficiente en Pandas, facilitando un filtrado de datos más preciso y flexible.

Operaciones de comparación

En Pandas, las operaciones de comparación son fundamentales para evaluar condiciones y realizar filtrados en DataFrames. Estas operaciones permiten comparar valores dentro de columnas y generar máscaras booleanas que pueden ser utilizadas para seleccionar subconjuntos de datos. 

A continuación, se describen las técnicas más comunes para realizar estas operaciones.

Para comparar valores de una columna con un valor escalar, se pueden utilizar los operadores de comparación estándar: ==, !=, >, <, >=, y <=. Por ejemplo, para comparar si los valores de la columna A de un DataFrame df son mayores que 3:

import pandas as pd

# Crear un DataFrame de ejemplo
df = pd.DataFrame({
    'A': [1, 2, 6, 4, 5],
    'B': [10, 20, 30, 40, 50]
})

# Comparar valores de la columna A con 3
comparison_result = df['A'] > 3
print(comparison_result)

El resultado de esta operación será una Serie booleana que indica si cada valor en la columna A cumple la condición especificada.

Para comparar valores entre dos columnas, también se pueden utilizar los mismos operadores de comparación. Por ejemplo, para comparar si los valores de la columna A son mayores que los valores de la columna B:

# Comparar valores entre las columnas A y B
comparison_result = df['A'] > df['B']
print(comparison_result)

Además de los operadores de comparación estándar, Pandas proporciona métodos específicos para realizar comparaciones de manera más explícita. Algunos de estos métodos incluyen eq() (igual a), ne() (no igual a), gt() (mayor que), lt() (menor que), ge() (mayor o igual a), y le() (menor o igual a). Estos métodos pueden ser útiles para mejorar la legibilidad del código. Por ejemplo, para comparar si los valores de la columna A son iguales a 4:

# Usar el método eq para comparar valores de la columna A con 4
comparison_result = df['A'].eq(4)
print(comparison_result)

Las operaciones de comparación también pueden aplicarse a DataFrames completos, permitiendo la comparación elemento a elemento entre dos DataFrames del mismo tamaño. Por ejemplo, para comparar dos DataFrames df1 y df2:

# Crear dos DataFrames de ejemplo
df1 = pd.DataFrame({
    'A': [1, 2, 6, 4, 5],
    'B': [10, 20, 30, 40, 50]
})

df2 = pd.DataFrame({
    'A': [1, 3, 6, 4, 2],
    'B': [10, 20, 25, 40, 55]
})

# Comparar elemento a elemento entre df1 y df2
comparison_result = df1 == df2
print(comparison_result)

El resultado de esta operación será un DataFrame de booleanos, donde cada elemento indica si la comparación es verdadera o falsa.

Para comparar valores con condiciones más complejas, se pueden combinar múltiples comparaciones utilizando operadores lógicos (& para "y", | para "o"). Por ejemplo, para seleccionar filas donde los valores de la columna A son mayores que 2 y los valores de la columna B son menores que 50:

# Combinar comparaciones con operadores lógicos
filtered_df = df[(df['A'] > 2) & (df['B'] < 50)]
print(filtered_df)

Estas técnicas de comparación son esenciales para la manipulación de datos en Pandas, permitiendo realizar análisis y filtrados precisos y eficientes.

Operaciones de ordenación

En Pandas, las operaciones de ordenación son esenciales para organizar y analizar datos de manera efectiva. La función principal para realizar estas operaciones es sort_values(), que permite ordenar un DataFrame en función de una o más columnas. 

A continuación, se describen las técnicas más comunes para llevar a cabo estas operaciones.

Para ordenar un DataFrame por una sola columna, se utiliza el método sort_values() especificando el nombre de la columna en el parámetro by. Por ejemplo, para ordenar un DataFrame df por la columna A de manera ascendente:

import pandas as pd

# Crear un DataFrame de ejemplo
df = pd.DataFrame({
    'A': [5, 2, 6, 1, 4],
    'B': [10, 20, 30, 40, 50]
})

# Ordenar por la columna A de manera ascendente
sorted_df = df.sort_values(by='A')
print(sorted_df)

Para ordenar en orden descendente, se utiliza el parámetro ascending=False:

# Ordenar por la columna A de manera descendente
sorted_df = df.sort_values(by='A', ascending=False)
print(sorted_df)

Cuando se necesita ordenar por múltiples columnas, se puede pasar una lista de nombres de columnas al parámetro by. Por ejemplo, para ordenar por la columna A y luego por la columna B:

# Crear un DataFrame de ejemplo
df = pd.DataFrame({
    'A': [5, 2, 6, 1, 4],
    'B': [10, 20, 30, 20, 50]
})

# Ordenar por las columnas A y B
sorted_df = df.sort_values(by=['A', 'B'])
print(sorted_df)

En este caso, el DataFrame se ordenará primero por la columna A y, en caso de empate, por la columna B.

Para ordenar por índice, se utiliza el método sort_index(). Este método ordena el DataFrame según sus etiquetas de índice:

# Crear un DataFrame de ejemplo con un índice desordenado
df = pd.DataFrame({
    'A': [5, 2, 6, 1, 4],
    'B': [10, 20, 30, 40, 50]
}, index=[3, 1, 4, 0, 2])

# Ordenar por el índice
sorted_df = df.sort_index()
print(sorted_df)

El ordenamiento por índice también puede ser en orden descendente utilizando ascending=False:

# Ordenar por el índice de manera descendente
sorted_df = df.sort_index(ascending=False)
print(sorted_df)

Además, es posible ordenar un DataFrame basado en una combinación de columnas y el índice. Para ello, primero se ordenan las columnas y luego se ordena el índice del DataFrame resultante:

# Ordenar por las columnas A y B, y luego por el índice
sorted_df = df.sort_values(by=['A', 'B']).sort_index()
print(sorted_df)

El método sort_values() también permite manejar valores nulos mediante el parámetro na_position, que puede tomar los valores 'first' o 'last' para indicar si los valores nulos deben aparecer al principio o al final:

# Crear un DataFrame de ejemplo con valores nulos
df = pd.DataFrame({
    'A': [5, None, 6, 1, 4],
    'B': [10, 20, None, 40, 50]
})

# Ordenar por la columna A con valores nulos al principio
sorted_df = df.sort_values(by='A', na_position='first')
print(sorted_df)

Estas técnicas permiten realizar operaciones de ordenación de manera eficiente y flexible en Pandas, facilitando la organización y análisis de datos.