Reestructuración de datos: Pivot y Reshape en Pandas

Las pivot tables (tablas dinámicas, en Excel) y los métodos stack y unstack pueden ser aplicados en nuestro df de ventas, según el interés de la audiencia a la que nos dirijamos: * Equipo gerencial: total de ventas por productos, por clientes o por región (para definir políticas o planes comerciales) * Proveeduría o fabricación: cantidades vendidas por producto (StockCode o Description) o por país (para asegurar disponibilidad del inventario) * Contabilidad o financiera: total de ventas por cliente, por facturas o por períodos: años, meses o días (para realizar conciliaciones bancarias, revisar cuentas de clientes o generar reportes tributarios o para la gerencia). * etc

📝 Mis apuntes de la clase (parte 1) **Pivot table** Una **pivot table** es una herramienta para resumir y reorganizar columnas de un DataFrame de pandas, que además permite crear cálculos estadísticos (suma, conteos, promedios, etc.). Básicamente transforma los valores de determinadas filas o columnas en indices de un nuevo DataFrame, la intersección de éstos es el valor resultante. La nueva organización de los datos nos ayuda a encontrar patrones que pudieran estar ocultos en los datos crudos. **Función**: * **pivot\_table()**: Puede implementarse directo del DataFrame o a partir de la librería en si misma "**pd.pivot\_table()**" con la diferencia de que ésta última recibe el DF como parámetro. **Parámetros**: * **data**: Cuando se utiliza la función directamente de pandas. * **values**: Nombre de la columna o columnas (lista) que rellenarán la tabla a partir de la función de agregación. * **index**: Nombre de la columna donde se tomarán los valores para crear los indices del DataFrame resultante. * **columns**: Nombre de la columna donde se tomarán los valores las nuevas columnas del DataFrame resultante. * **aggfunc**: Función de agregación a aplicar. **Ejemplo # 1:** Crear un resumen del promedio de ventas que tuvo cada país durante los doce meces del año 2011. ```python # Creamos una copia del DataFrame original sales_2011 = retail_df.loc[retail_df["InvoiceDate"].dt.year == 2011, ::] # Creamos la columna "Year" donde guardaremos la extracción de año a partir del "InvoiceDate" sales_2011["Month"] = sales_2011["InvoiceDate"].dt.month # Hacemos un pivot table sales_by_year = sales_2011.pivot_table( values="TotalPrice", index="Country", columns="Month", aggfunc="mean" ) sales_by_year ``` Resultado:  **Ejemplo #2**: Crear un resumen del promedio de ventas que tuvo cada país durante los 4 trimestres del año 2011. ```python # Función para calcular cual es el trimestre del año def quarter_of_year(value): if value in [1, 2, 3]: return "1st" elif value in [4, 5, 6]: return "2nd" elif value in [7, 8, 9]: return "3rd" else: return "4th" # Aplicamos la función para calcular el trimestre correspondiente sales_2011["Quarter"] = sales_2011["Month"].apply(quarter_of_year) # Hacemos pivot table donde las columnas seran cada trimestre del 2011 quarter_sales = sales_2011.pivot_table( values="TotalPrice", index="Country", columns="Quarter", aggfunc="mean" ) quarter_sales.head() ``` Resultado: 

### **Usos Principales de las Pivot Tables** 1. **Resumir Datos**: Permiten calcular agregaciones (como sumas, medias, conteos) y ver resultados resumidos en una tabla estructurada. 2. **Reorganizar Datos**: Facilitan la reorganización de datos para ver relaciones entre diferentes variables. Puedes pivotar filas en columnas y viceversa. 3. **Comparar Datos**: Ayudan a comparar datos en diferentes niveles de detalle, como por ejemplo ver las ventas por producto y por región en una sola tabla. 4. **Visualizar Datos**: Preparan datos para ser visualizados de manera más clara y significativa.

Aqui se pude ver como use la pívot table para identificar que vino tiene mayor cantidad de alcohol que otro 

Si imprimimos print(type(df\_stacked)) Podemos ver que lo que obtenemos al hacer un stack de un dataframe es un objeto tipo Serie \<class 'pandas.core.series.Series'>

Apilada por producto, precio unitario, cantidad y total Stock\_descipcion\_cant= sales\_data\[\['StockCode', 'Description','Quantity','UnitPrice']].head(10) Stock\_descipcion\_cant\['TotalPrice'] = Stock\_descipcion\_cant\['UnitPrice'] \* Stock\_descipcion\_cant\['Quantity'] apilados = Stock\_descipcion\_cant.stack() print(apilados) 

Tiene cierto parecido a la elaboración de tablas dinámicas en excel

#### **1. Creación de una Tabla Pivote** pivot\_table = pd.pivot\_table(sales\_data, values='Quantity', index='Country', columns='StockCode', aggfunc='sum') print(pivot\_table) **Descripción**: * Se crea una tabla pivote utilizando pd.pivot\_table, donde: * values='Quantity' especifica que la columna Quantity se utiliza para los cálculos. * index='Country' establece Country como las filas (índice). * columns='StockCode' establece StockCode como las columnas. * aggfunc='sum' agrega los datos sumando la cantidad (Quantity) para cada combinación de Country y StockCode. * La tabla pivote se imprime. **Resultado**: Una tabla con: * Filas representando países. * Columnas representando códigos de producto (StockCode). * Valores representando la cantidad total vendida para cada código de producto en cada país. Las combinaciones faltantes se rellenan con NaN. #### **2. Creación de un DataFrame de Ejemplo** df = pd.DataFrame({     'A': \['foo', 'bar', 'baz'],     'B': \[1, 2, 3],     'C': \[4, 5, 6] }) print(df) **Descripción**: * Se crea un DataFrame simple df con tres columnas: A, B y C. * Las filas se rellenan con los datos proporcionados. **Resultado**: Un DataFrame con tres filas y tres columnas:     A  B  C 0  foo  1  4 1  bar  2  5 2  baz  3  6 #### **3. Apilar el DataFrame** df\_stack = df.stack() print(df\_stack) **Descripción**: * El método stack() transforma el DataFrame apilando las columnas en filas, creando una Serie con un índice jerárquico. * El nivel interno del índice corresponde a los nombres de las columnas originales, y el nivel externo al índice de las filas originales. **Resultado**: Una Serie apilada donde cada valor está asociado con un par de índices (fila y columna original). Por ejemplo: 0  A    foo    B      1    C      4 1  A    bar    B      2    C      5 2  A    baz    B      3    C      6 dtype: object #### **4. Desapilar la Serie Apilada** df\_unstacked = df\_stacked.unstack() print(df\_unstacked) **Descripción**: * El método unstack() transforma la Serie apilada de nuevo en un DataFrame, revirtiendo la operación de stack(). * El nivel externo del índice se convierte en filas, y el nivel interno en columnas. **Resultado**: El DataFrame original es reconstruido:     A  B  C 0  foo  1  4 1  bar  2  5 2  baz  3  6

stack es lo mismo que el metodo transponer ?

Usando la pivot table, podemos ver la información más ordenada, ya que al aplicar stack al resultado de la profe obtenemos esto: ```python pivot_table = pd.pivot_table(df, index=['Country'], columns=['StockCode'], values=['Quantity'], aggfunc=np.sum) print(pivot_table.stack()) print(pivot_table.stack()) Quantity Country StockCode Australia 15036 600.0 15056BL 3.0 16161P 400.0 16169E 25.0 20665 6.0 ... ... Unspecified 85180A 2.0 85180B 1.0 85212 12.0 85213 12.0 85227 10.0 ```pivot\_table = pd.pivot\_table(df, index=\['Country'], columns=\['StockCode'], values=\['Quantity'], aggfunc=np.sum)print(pivot\_table.stack())

En \*\*Pandas\*\*, la reestructuración de datos mediante las funciones `pivot`, `pivot\_table`, `melt`, y `stack/unstack` permite reorganizar y transformar \*\*DataFrames\*\* en diferentes formatos. Estas funciones son útiles para cambiar el formato de los datos, reorganizarlos o preparar resúmenes. A continuación te explico cómo funcionan estas técnicas con ejemplos: \### 1. \*\*`pivot()` para reorganizar columnas\*\* El método `pivot()` reorganiza los datos de un DataFrame al transformar columnas en índices, y los valores en filas. \#### Ejemplo: ```python import pandas as pd \# Crear un DataFrame de ejemplo df = pd.DataFrame({ 'fecha': \['2023-01', '2023-02', '2023-01', '2023-02'], 'ciudad': \['Madrid', 'Madrid', 'Barcelona', 'Barcelona'], 'ventas': \[250, 300, 200, 210] }) \# Reorganizar el DataFrame usando 'fecha' como índice, 'ciudad' como columnas y 'ventas' como valores pivot\_df = df.pivot(index='fecha', columns='ciudad', values='ventas') print(pivot\_df) ``` \*\*Resultado:\*\* ``` ciudad Barcelona Madrid fecha 2023-01 200.0 250.0 2023-02 210.0 300.0 ``` \### 2. \*\*`pivot\_table()` para agregar datos\*\* La función `pivot\_table()` es similar a `pivot()`, pero permite realizar agregaciones si hay duplicados en los datos. Esto es útil cuando hay valores repetidos y deseas aplicar una función de agregación como `sum()`, `mean()`, etc. \#### Ejemplo con agregación: ```python \# Crear un DataFrame con datos repetidos df = pd.DataFrame({ 'fecha': \['2023-01', '2023-01', '2023-02', '2023-02'], 'ciudad': \['Madrid', 'Madrid', 'Barcelona', 'Barcelona'], 'ventas': \[250, 300, 200, 210] }) \# Crear una tabla dinámica usando 'fecha' como índice, 'ciudad' como columnas y 'ventas' como valores, agregando con sum pivot\_table\_df = df.pivot\_table(index='fecha', columns='ciudad', values='ventas', aggfunc='sum') print(pivot\_table\_df) ``` \*\*Resultado:\*\* ``` ciudad Barcelona Madrid fecha 2023-01 200.0 550.0 2023-02 210.0 NaN ``` \### 3. \*\*`melt()` para transformar de formato ancho a largo\*\* El método `melt()` transforma un \*\*DataFrame\*\* de formato ancho (donde los datos están en columnas) a formato largo (donde los datos se combinan en una columna única de valores). \#### Ejemplo: ```python \# Crear un DataFrame en formato ancho df\_wide = pd.DataFrame({ 'fecha': \['2023-01', '2023-02'], 'Madrid': \[250, 300], 'Barcelona': \[200, 210] }) \# Convertir el DataFrame a formato largo usando melt() df\_long = pd.melt(df\_wide, id\_vars='fecha', var\_name='ciudad', value\_name='ventas') print(df\_long) ``` \*\*Resultado:\*\* ``` fecha ciudad ventas 0 2023-01 Madrid 250 1 2023-02 Madrid 300 2 2023-01 Barcelona 200 3 2023-02 Barcelona 210 ``` \### 4. \*\*`stack()` y `unstack()` para reestructuración de índices jerárquicos\*\* `stack()` y `unstack()` son métodos que permiten manipular índices jerárquicos (índices multi-nivel). \- \*\*`stack()`\*\* convierte columnas en filas. \- \*\*`unstack()`\*\* convierte filas en columnas. \#### Ejemplo de `stack()`: ```python \# Crear un DataFrame con multi-índice df\_multi = df.pivot(index='fecha', columns='ciudad', values='ventas') \# Aplicar stack() para convertir las columnas en índices stacked\_df = df\_multi.stack() print(stacked\_df) ``` \*\*Resultado:\*\* ``` fecha ciudad 2023-01 Barcelona 200 Madrid 250 2023-02 Barcelona 210 Madrid 300 dtype: int64 ``` \#### Ejemplo de `unstack()`: ```python \# Aplicar unstack() para convertir los índices de nuevo en columnas unstacked\_df = stacked\_df.unstack() print(unstacked\_df) ``` \*\*Resultado:\*\* ``` ciudad Barcelona Madrid fecha 2023-01 200.0 250.0 2023-02 210.0 300.0 ``` \### 5. \*\*`wide\_to\_long()` para transformar varias columnas en una\*\* La función `wide\_to\_long()` es útil cuando tienes varias columnas que representan variables relacionadas y deseas convertirlas en una sola. \#### Ejemplo: ```python \# Crear un DataFrame con varias columnas df\_wide = pd.DataFrame({ 'id': \[1, 2], 'nombre': \['Ana', 'Pedro'], 'edad\_2021': \[25, 30], 'edad\_2022': \[26, 31] }) \# Convertir el DataFrame a formato largo usando wide\_to\_long() df\_long = pd.wide\_to\_long(df\_wide, stubnames='edad', i='id', j='anio') print(df\_long) ``` \*\*Resultado:\*\* ``` nombre edad id anio 1 2021 Ana 25 2022 Ana 26 2 2021 Pedro 30 2022 Pedro 31 ``` \### 6. \*\*`transpose()` para intercambiar filas y columnas\*\* El método `transpose()` intercambia filas por columnas y viceversa. \#### Ejemplo: ```python \# Transponer el DataFrame df\_transposed = df\_wide.transpose() print(df\_transposed) ``` \*\*Resultado:\*\* ``` 0 1 id 1 2 nombre Ana Pedro edad\_2021 25 30 edad\_2022 26 31 ``` \### 7. \*\*`set\_index()` y `reset\_index()` para trabajar con índices\*\* El método `set\_index()` permite establecer una columna como índice, y `reset\_index()` revierte la operación para convertir el índice en columna. \#### Ejemplo con `set\_index()`: ```python \# Establecer la columna 'fecha' como índice df\_indexed = df.set\_index('fecha') print(df\_indexed) ``` \*\*Resultado:\*\* ``` ciudad ventas fecha 2023-01 Madrid 250 2023-01 Madrid 300 2023-02 Barcelona 200 2023-02 Barcelona 210 ``` \#### Ejemplo con `reset\_index()`: ```python \# Restablecer el índice como columna df\_reset = df\_indexed.reset\_index() print(df\_reset) ``` \*\*Resultado:\*\* ``` fecha ciudad ventas 0 2023-01 Madrid 250 1 2023-01 Madrid 300 2 2023-02 Barcelona 200 3 2023-02 Barcelona 210 ``` \### Resumen de funciones: \- \*\*`pivot()`\*\*: Convierte columnas en filas según un índice. \- \*\*`pivot\_table()`\*\*: Similar a `pivot()`, pero permite agregaciones. \- \*\*`melt()`\*\*: Transforma de formato ancho a largo. \- \*\*`stack()`\*\*: Convierte columnas en índices. \- \*\*`unstack()`\*\*: Convierte índices en columnas. \- \*\*`wide\_to\_long()`\*\*: Convierte varias columnas relacionadas en una columna única. \- \*\*`transpose()`\*\*: Intercambia filas y columnas. \- \*\*`set\_index()`\*\*: Establece una columna como índice. \- \*\*`reset\_index()`\*\*: Convierte un índice en columna. Estas funciones permiten transformar los datos en diferentes formas según tus necesidades. Si tienes alguna duda sobre cómo aplicarlas en tu caso, ¡déjame saber!

Las pivot tables son muy flexibles y pueden ser adaptadas para cualquier tipo de análisis, dependiendo de las preguntas de negocio que quieras responder. Combinando estas tablas con gráficos y análisis adicionales, puedes extraer conclusiones valiosas sobre el comportamiento de las ventas, la gestión de inventario y la relación con los clientes. **Análisis de Ventas por Producto** **Objetivo**: Identificar cuáles productos generan más ingresos. ```js pivot_sales_product = sales_data.pivot_table( values='TotalPrice', index='Description', aggfunc='sum' ).sort_values(by='TotalPrice', ascending=False) print(pivot_sales_product.head()) ``` **Análisis de Ventas por País** Objetivo: Entender en qué países se realizan más ventas. ```js pivot_sales_country = sales_data.pivot_table( values='TotalPrice', index='Country', aggfunc='sum' ).sort_values(by='TotalPrice', ascending=False) print(pivot_sales_country.head()) ``` **Rendimiento de Ventas por Cliente** Objetivo: Analizar qué clientes son los más valiosos en términos de compras. ```js pivot_sales_customer = sales_data.pivot_table( values='TotalPrice', index='CustomerID', aggfunc='sum' ).sort_values(by='TotalPrice', ascending=False) print(pivot_sales_customer.head()) ```

```js df['InvoiceDate'] = pd.to_datetime(df['InvoiceDate']) df['Date'] = df['InvoiceDate'].dt.date pivot_table_df = df.pivot_table(index='Date', columns=['Country', 'Description'], values='Quantity', aggfunc='sum') stacked_df = pivot_table_df.stack() unstacked_df = stacked_df.unstack() print("Tabla dinámica original:") print(pivot_table_df.head(), "\n") print("Datos apilados (stacked):") print(stacked_df.head(), "\n") print("Datos desapilados (unstacked):") print(unstacked_df.head()) ```