Filtrado de datos con condiciones en Pandas

En mi opinión una sintaxis más clara y legible de la que se muestra acá es usar la función query, además otro punto a destacar es que al usar print() para mostrar el dataset sale en un formato tampoco muy legible, una mejor opcion sería simplemente escribir el nombre del dataset y se imprime con un formato estilo tabla, adjunto imagen de como lo he estado trabajando. ![]()

**¿Qué es el fitrado de datos en Pandas?** El filtrado de datos con condiciones en pandas se refiere a seleccionar filas de un DataFrame o Series que cumplen con ciertos criterios. Esto se hace utilizando expresiones booleanas para definir las condiciones, y luego aplicándolas para obtener solo los datos que satisfacen esas condiciones.

**¿Para qué filtrar la información?** * Filtrar la información nos permite prestar atención en aspectos específicos de nuestro set de datos. * Ejemplo: determinar las ventas por países o por series de tiempo.


#### **1. Lectura y Limpieza del Conjunto de Datos** file\_path = '/content/online\_retail.csv' sales\_data = pd.read\_csv(file\_path) sales\_data\['InvoiceDate'] = pd.to\_datetime(sales\_data\['InvoiceDate']) sales\_data.dropna(subset=\['CustomerID', 'InvoiceDate'], inplace=True) sales\_data\['TotalPrice'] = sales\_data\['Quantity'] \* sales\_data\['UnitPrice'] print(sales\_data.head()) **Descripción**: 1. Lee el archivo online\_retail.csv en un DataFrame de Pandas llamado sales\_data. 2. Convierte la columna InvoiceDate a formato datetime utilizando pd.to\_datetime. 3. Elimina filas con valores faltantes en las columnas críticas (CustomerID y InvoiceDate) usando dropna. 4. Crea una nueva columna TotalPrice como el producto de las columnas Quantity y UnitPrice. 5. Muestra las primeras cinco filas del DataFrame limpio utilizando head(). **Resultado**: Las primeras cinco filas del conjunto de datos, mostrando las columnas InvoiceNo, StockCode, Description, Quantity, InvoiceDate, UnitPrice, CustomerID, Country y el nuevo TotalPrice. #### **2. Filtrar Ventas en el Reino Unido** uk\_sales = sales\_data\[sales\_data\['Country'] == 'United Kingdom'] print(uk\_sales) **Descripción**: Filtra el conjunto de datos para incluir solo las filas donde la columna Country sea 'United Kingdom'. **Resultado**: Un DataFrame filtrado que contiene solo las ventas realizadas en el Reino Unido, con todas las columnas incluidas. #### **3. Filtrar Ventas con Cantidades Altas** high\_quantity\_sales = sales\_data\[sales\_data\['Quantity'] > 40] print(high\_quantity\_sales) **Descripción**: Filtra el conjunto de datos para incluir solo las filas donde la columna Quantity sea mayor a 40. **Resultado**: Un DataFrame con filas donde Quantity supera los 40. Esto incluye todas las columnas originales. #### **4. Filtrar Ventas con Cantidades Altas en el Reino Unido** uk\_high\_quantity\_sales = sales\_data\[(sales\_data\['Country'] == 'United Kingdom') & (sales\_data\['Quantity'] > 40)] print(uk\_high\_quantity\_sales) **Descripción**: Filtra el conjunto de datos para incluir solo las filas donde: 1. La columna Country sea 'United Kingdom'. 2. La columna Quantity sea mayor a 40. El filtrado se realiza utilizando un operador lógico AND (&). **Resultado**: Un DataFrame que muestra las ventas en el Reino Unido con cantidades mayores a 40. #### **5. Filtrar Ventas del Año 2010** sales\_2010 = sales\_data\[sales\_data\['InvoiceDate'].dt.year == 2010] print(sales\_2010) **Descripción**: Filtra el conjunto de datos para incluir solo las filas donde el año en la columna InvoiceDate sea 2010. Esto se logra utilizando .dt.year. **Resultado**: Un DataFrame que contiene todas las ventas ocurridas en 2010. #### **6. Filtrar Ventas de Diciembre de 2010** sales\_dec\_2010 = sales\_data\[(sales\_data\['InvoiceDate'].dt.year == 2010) & (sales\_data\['InvoiceDate'].dt.month == 12)] print(sales\_dec\_2010) **Descripción**: Filtra el conjunto de datos para incluir solo las filas donde: 1. El año en la columna InvoiceDate sea 2010. 2. El mes en la columna InvoiceDate sea diciembre (12). El filtrado se realiza utilizando un operador lógico AND (&). **Resultado**: Un DataFrame que contiene todas las ventas ocurridas en diciembre de 2010.

El **join izquierdo** incluye todas las filas del DataFrame de la izquierda, y solo las filas coincidentes del DataFrame de la derecha. Si no hay coincidencia, se llenan con NaN. El **join derecho** incluye todas las filas del DataFrame de la derecha y solamente las filas coincidentes del DataFrame de la izquierda. Al igual que en el join izquierdo, las filas sin coincidencia se llenan con NaN. Ambos métodos permiten combinar información de diferentes fuentes, pero cada uno tiene un enfoque distinto en cuanto a qué filas se mantienen.

La clase se centra en la reestructuración de datos usando Pivot Tables en Pandas. Se enseñó cómo crear tablas dinámicas para resumir y reorganizar datos crudos en un DataFrame, permitiendo realizar cálculos estadísticos como sumas y promedios. También se explicó cómo modificar índices usando columnas y cómo apilar y desapilar datos para una mejor visualización. Se enfatizó el uso de estas herramientas para descubrir patrones y obtener insights valiosos en el análisis de datos.

El filtrado de datos es una técnica utilizada en el análisis de datos para extraer subconjuntos específicos de información de un conjunto de datos más grande. Permite enfocarse en registros que cumplen ciertas condiciones, como analizar ventas de un país específico o transacciones en un periodo concreto. En Pandas, esto se logra utilizando condiciones lógicas sobre las columnas del DataFrame, permitiendo así una mejor comprensión y visualización de los datos relevantes para el análisis.

Si les sale un error al intentar filtrar por fecha es porque no hicieron el paso de convertir la columna de InvoiceDate a fecha, puesto que en el dataframe original esta columna viene de tipo Objeto. Para convertirla solo debe escribir: ```js df['InvoiceDate'] = pd.to_datetime(df['InvoiceDate']) ```

El código no se encuentra en recursos

📝 Mis apuntes de la clase El **filtrado de datos** en pandas es: * Técnica que permite extraer subconjuntos específicos del Data set. * Se basa en condiciones lógicas. * También aplica dentro de la funcionalidad **.loc** **Permite:** * Prestar atención más detallada en aspectos específicos de los datos * 💡 Datos de un periodo de tiempo especifico. * 💡 Información de una región o regiones en concreto. * 💡Datos según una categoría. **Sintaxis:** Obtendremos un nuevo DataFrame con los datos que cumplan con la condición dada: ```python # Una condición df[df["columna"] == "un valor"] # Dos condiciones df[(df["columna"] >= "un valor") & (df["columna"] <= "un valor")] # operador and df[(df["columna"] <= "un valor") | (df["columna"] >= "un valor")] # operatos or # Con .loc df.loc[df["columna"] == "un valor"] df.locdf[(df["columna"] <= "un valor") | (df["columna"] >= "un valor")] ``` Pero también podemos obtener un DataFrame solo con las columnas que necesitamos para el análisis. 📢 Si solo queremos una sola columna entonces como resultado tendremos una Serie. ```python # Una condición df[df["columna"] == "un valor"]["columna"] # Serie # Dos condiciones df[(df["columna"] >= "un valor") & (df["columna"] <= "un valor")][["columna uno", "columna 2"]] # DataFrame df[(df["columna"] <= "un valor") | (df["columna"] >= "un valor")][["columna uno", "columna 2", "columna 2"]] # DataFrame # Con .loc df.loc[df["columna"] == "un valor", ["columna uno", "columna 2"]] # DataFrame df.loc[(df["columna"] <= "un valor") | (df["columna"] >= "un valor"), "columna"] # Serie ``` Utilizar .loc con filtros es una herramienta potente para actualizar datos dada una condición. **Ejemplos:** ```python # Ventas realizadas en Reino Unido, solo necesitamos Descripción y Cantidad: uk_sales = retail_df[retail_df["Country"] == "United Kingdom"][["Description", "Quantity"]] print("Ventas en Reino Unido") display(uk_sales.head()) # Ventas realizadas en semana santa del 2011 # 17/abirl/2011 al 23/abril/2011 ss_2011 = retail_df[(retail_df["InvoiceDate"] >= pd.Timestamp(2011,4,17)) & (retail_df["InvoiceDate"] <= pd.Timestamp(2011,4,23))] print("Semana Sanda 2011") display(ss_2011.head()) ```  ```python # Solo las ventas de diciembre: december_sales = retail_df.loc[ (retail_df["InvoiceDate"].dt.year == 2011) & (retail_df["InvoiceDate"].dt.month == 12), ["Description", "Quantity", "UnitPrice", "TotalPrice"] ] print("Ventas de Diciembre de 2011") display(december_sales.head()) ``` 

¿Cuál es el producto con la cantidad de ventas más alta de cada vez para el año 2011? ```python def highest_sales_each_month(data): resultados = [] for i in range(1, 13): results = data[ (data['InvoiceDate'].dt.year == 2011) & (df['InvoiceDate'].dt.month == i) ] resultados.append(results[results['Quantity'] == results['Quantity'].max()]) return resultados print(highest_sales_each_month(df)[11]) ```

En \*\*Pandas\*\*, el filtrado de datos basado en condiciones es una operación clave para seleccionar filas de un \*\*DataFrame\*\* que cumplan ciertos criterios. Aquí te muestro varias formas de hacerlo con ejemplos. \### 1. \*\*Filtrado básico con una condición\*\* Puedes filtrar filas de un DataFrame usando operadores lógicos como `==`, `>`, `<`, etc. \#### Ejemplo: ```python import pandas as pd \# Crear un DataFrame de ejemplo df = pd.DataFrame({ 'nombre': \['Ana', 'Juan', 'Pedro', 'Lucía'], 'edad': \[25, 30, 22, 28], 'ciudad': \['Madrid', 'Barcelona', 'Sevilla', 'Madrid'] }) \# Filtrar filas donde la edad sea mayor a 25 filtro = df\[df\['edad'] > 25] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 1 Juan 30 Barcelona 3 Lucía 28 Madrid ``` \### 2. \*\*Filtrado con múltiples condiciones\*\* Puedes combinar múltiples condiciones usando operadores lógicos: \- `&` para "y" lógico (AND). \- `|` para "o" lógico (OR). \- `~` para "no" lógico (NOT). Recuerda siempre encerrar cada condición entre paréntesis cuando combines varias. \#### Ejemplo con `&` (AND): ```python \# Filtrar filas donde la edad sea mayor a 25 y la ciudad sea Madrid filtro = df\[(df\['edad'] > 25) & (df\['ciudad'] == 'Madrid')] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 3 Lucía 28 Madrid ``` \#### Ejemplo con `|` (OR): ```python \# Filtrar filas donde la edad sea mayor a 25 o la ciudad sea Sevilla filtro = df\[(df\['edad'] > 25) | (df\['ciudad'] == 'Sevilla')] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 1 Juan 30 Barcelona 2 Pedro 22 Sevilla 3 Lucía 28 Madrid ``` \### 3. \*\*Filtrar con la función `isin()`\*\* La función `isin()` es útil para filtrar filas que coincidan con una lista de valores específicos en una columna. \#### Ejemplo: ```python \# Filtrar filas donde la ciudad sea Madrid o Sevilla filtro = df\[df\['ciudad'].isin(\['Madrid', 'Sevilla'])] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 0 Ana 25 Madrid 2 Pedro 22 Sevilla 3 Lucía 28 Madrid ``` \### 4. \*\*Filtrar filas con valores nulos (`isnull()` y `notnull()`)\*\* Puedes filtrar filas que contengan valores nulos (`NaN`) usando `isnull()` o `notnull()`. \#### Ejemplo: ```python \# Crear un DataFrame con valores nulos df2 = pd.DataFrame({ 'nombre': \['Ana', 'Juan', 'Pedro', 'Lucía'], 'edad': \[25, None, 22, 28], 'ciudad': \['Madrid', 'Barcelona', None, 'Madrid'] }) \# Filtrar filas donde haya valores nulos en la columna 'edad' filtro = df2\[df2\['edad'].isnull()] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 1 Juan NaN Barcelona ``` \#### Filtrar filas donde no haya valores nulos en la columna 'edad': ```python filtro = df2\[df2\['edad'].notnull()] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 0 Ana 25.0 Madrid 2 Pedro 22.0 None 3 Lucía 28.0 Madrid ``` \### 5. \*\*Filtrar con condiciones complejas (`query()` method)\*\* Pandas también proporciona el método `query()` para hacer filtrados con condiciones usando una sintaxis similar a SQL. \#### Ejemplo: ```python \# Filtrar filas donde la edad sea mayor a 25 y la ciudad sea Madrid usando query() filtro = df.query('edad > 25 and ciudad == "Madrid"') print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 3 Lucía 28 Madrid ``` \### 6. \*\*Filtrar con texto (`str.contains()`)\*\* Si necesitas filtrar datos basados en cadenas de texto, puedes usar `str.contains()` para buscar patrones en columnas de tipo string. \#### Ejemplo: ```python \# Filtrar filas donde la ciudad contenga la letra 'M' filtro = df\[df\['ciudad'].str.contains('M')] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 0 Ana 25 Madrid 3 Lucía 28 Madrid ``` \### 7. \*\*Filtrar usando índices\*\* También puedes filtrar filas basándote en el índice de las filas usando `.loc\[]` o `.iloc\[]`. \#### Ejemplo con `.loc\[]`: ```python \# Filtrar filas con índices específicos filtro = df.loc\[\[0, 2]] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 0 Ana 25 Madrid 2 Pedro 22 Sevilla ``` \#### Ejemplo con `.iloc\[]` (por posición): ```python \# Filtrar las primeras dos filas filtro = df.iloc\[:2] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 0 Ana 25 Madrid 1 Juan 30 Barcelona ``` \### 8. \*\*Filtrar filas únicas (`drop\_duplicates()`)\*\* Si quieres eliminar filas duplicadas, puedes usar `drop\_duplicates()`. \#### Ejemplo: ```python \# Eliminar filas duplicadas en todas las columnas filtro = df.drop\_duplicates() print(filtro) ``` \#### Ejemplo eliminando duplicados basados en una sola columna: ```python \# Eliminar filas duplicadas basadas solo en la columna 'nombre' filtro = df.drop\_duplicates(subset='nombre') print(filtro) ``` \### 9. \*\*Filtrar filas por rango de valores (`between()`)\*\* El método `between()` permite filtrar filas dentro de un rango. \#### Ejemplo: ```python \# Filtrar filas donde la edad esté entre 23 y 30 filtro = df\[df\['edad'].between(23, 30)] print(filtro) ``` \*\*Resultado:\*\* ``` nombre edad ciudad 1 Juan 30 Barcelona 3 Lucía 28 Madrid ``` Estos son algunos ejemplos básicos y avanzados para filtrar datos en \*\*Pandas\*\* utilizando diversas condiciones. Si tienes algún caso específico o necesitas más detalles, ¡hazme saber!

 transacciones realizadas en el país 'Germany' durante Diciembre de 2010, con una cantidad mayor a 5