evidencia-3-theta

April 28, 2024

Facultad de Contaduria Pública y Administración / UANL / Almacenes de Datos Otoño 2023 /

Profesor MSc Manuel Olmedo
Equipo THETA / grupo FC

[1]: import pandas as pd

import numpy as np

#Evidencia 3 Filtrado de Datos

En este notebook realizaran operaciones de filtrado de datos en un dataframe sobre una tienda de
bicicletas.
Construiran un dataframe a partir de datos de una tabla de una base de datos de una cadena de
tiendas de bicicletas. https://www.kaggle.com/datasets/dillonmyrick/bike-store-sample-database
Deben de descargar y subir a su drive el archivo orders.csv.
Deberán de realizar las manipulaciones indicadas al dataframe en las instrucciones siguientes, es-
cribiendo el código apropiado, y explicando su funcionamiento.
##Importando Datos a un Dataframe
[2]: from google.colab import drive
drive.mount('/content/drive')

Mounted at /content/drive

[4]: df = pd.read_csv("/content/drive/MyDrive/ADAT_GRUPO FC/orders.csv")

[5]: df

[5]: order_id customer_id order_status order_date required_date \

0 1 259 4 2016-01-01 2016-01-03
1 2 1212 4 2016-01-01 2016-01-04
2 3 523 4 2016-01-02 2016-01-05
3 4 175 4 2016-01-03 2016-01-04
4 5 1324 4 2016-01-03 2016-01-06
… … … … … …
1610 1611 6 3 2018-09-06 2018-09-06
1611 1612 3 3 2018-10-21 2018-10-21

1
 1612 1613 1 3 2018-11-18 2018-11-18
1613 1614 135 3 2018-11-28 2018-11-28
1614 1615 136 3 2018-12-28 2018-12-28

shipped_date store_id staff_id

0 2016-01-03 1 2
1 2016-01-03 2 6
2 2016-01-03 2 7
3 2016-01-05 1 3
4 2016-01-06 2 6
… … … …
1610 NaN 2 7
1611 NaN 1 3
1612 NaN 2 6
1613 NaN 3 8
1614 NaN 3 8

[1615 rows x 8 columns]

##Ejercicios
###Ejercicio 1 Obtener cuales son los 5 clientes con mas ordenes en la base de datos.
Empezamos organizando las ordenes confomre a los clientes que lo solicitaron para tener un mejor
estetica.
Despues realziamos lo que es un ordenamiento del DataFrame por la columna ‘customer_id’: donde
se ordeno el DataFrame df según la columna ‘customer_id’ en orden ascendente (de menor a mayor),
y el resultado se guardo en un nuevo DataFrame llamado df_sorted.
continuamos con la obtención de los 5 clientes con más órdenes:Donde se cuentan las ocurren-
cias de cada valor de ‘customer_id’ en el DataFrame ordenado df_sorted, utilizando el método
value_counts(). Luego, se seleccionan los primeros 5 valores (los clientes con más órdenes) y se
almacenan en la variable top_5_customers.
Seguimos con la obtención de los índices de los 5 clientes con más órdenes: Donde se obtienen
los índices (es decir, los valores de ‘customer_id’) de los 5 clientes con más órdenes, utilizando
el atributo index del objeto top_5_customers, y se convierten en una lista utilizando el método
tolist(). Estos índices se almacenan en la variable top_5_customer_indices.
Casi terminando hacemos lo que es un filtrado de los datos para obtener los 5 clientes con más
órdenes: En donde se filtran las filas del DataFrame df_sorted para incluir solo aquellas que
tienen ‘customer_id’ en la lista de los 5 clientes con más órdenes (top_5_customer_indices). El
resultado se guarda en un nuevo DataFrame llamado top_5_customers_. Acabamos imprimiendo
los 5 clientes con más órdenes
[6]: #comenzamos organizando los clientes junto con los pedidos que reañizaron, para␣
↪asi tener un mejor arreglo de los clientes que cuentan con más ordenes.

df.sort_values(by=['customer_id'], ascending=True)

2
[6]: order_id customer_id order_status order_date required_date \
1612 1613 1 3 2018-11-18 2018-11-18
598 599 1 4 2016-12-09 2016-12-10
1554 1555 1 1 2018-04-18 2018-04-18
691 692 2 3 2017-02-05 2017-02-05
1508 1509 2 1 2018-04-09 2018-04-09
… … … … … …
1365 1366 1441 4 2018-01-26 2018-01-27
1035 1036 1442 4 2017-07-30 2017-08-01
557 558 1443 4 2016-11-15 2016-11-16
615 616 1444 4 2016-12-20 2016-12-23
1423 1424 1445 4 2018-03-07 2018-03-10

shipped_date store_id staff_id

1612 NaN 2 6
598 2016-12-12 2 6
1554 NaN 2 7
691 NaN 1 3
1508 NaN 1 3
… … … …
1365 2018-01-28 2 6
1035 2017-07-31 2 6
557 2016-11-17 2 7
615 2016-12-23 2 6
1423 2018-03-10 1 2

[1615 rows x 8 columns]

[7]: # Ordenamos el dataframe por la columna customer_id

df_sorted = df.sort_values(by='customer_id', ascending=True)

# Obtenemos los 5 clientes con más órdenes

top_5_customers = df_sorted['customer_id'].value_counts().head(5)

# Obtenemos los índices de los 5 clientes con más órdenes

top_5_customer_indices = top_5_customers.index.tolist()

# Obtenemos los 5 clientes con más órdenes

top_5_customers_ = df_sorted[df_sorted['customer_id'].
↪isin(top_5_customer_indices)]

# por ultimo imprimimos los 5 clientes con más órdenes

print(top_5_customers_)

order_id customer_id order_status order_date required_date \

1612 1613 1 3 2018-11-18 2018-11-18
598 599 1 4 2016-12-09 2016-12-10

3
 1554 1555 1 1 2018-04-18 2018-04-18
1176 1177 21 3 2017-10-12 2017-10-12
1408 1409 21 4 2018-02-26 2018-02-28
1595 1596 21 2 2018-04-28 2018-04-28
443 444 30 4 2016-09-19 2016-09-20
1552 1553 30 2 2018-04-18 2018-04-18
348 349 30 3 2016-08-03 2016-08-03
1496 1497 31 2 2018-04-06 2018-04-06
349 350 31 3 2016-08-03 2016-08-03
161 162 31 4 2016-04-06 2016-04-08
581 582 32 3 2016-12-04 2016-12-04
158 159 32 4 2016-04-04 2016-04-06
1512 1513 32 2 2018-04-10 2018-04-10

shipped_date store_id staff_id

1612 NaN 2 6
598 2016-12-12 2 6
1554 NaN 2 7
1176 NaN 3 9
1408 2018-02-28 3 8
1595 NaN 3 8
443 2016-09-21 1 2
1552 NaN 1 3
348 NaN 1 3
1496 NaN 1 2
349 NaN 1 3
161 2016-04-07 1 3
581 NaN 1 2
158 2016-04-06 1 2
1512 NaN 1 2
###Ejercicio 2 Obtener cuantas ordenes estan en cada uno de los status de orden (1: Pending, 2:
Processing, 3: Rejected, 4: Completed).

[8]: # Se hizo uso del comando .value_counts() en la columna de order_status para␣

↪saber cuantas ordenes de número 4, 3, 2 y 1 hay.

df['order_status'].value_counts()

[8]: order_status
4 1445
2 63
1 62
3 45
Name: count, dtype: int64

###Ejercicio 3 Filtrar por años y ver cuantas ordenes hay en cada uno.
se crea una nueva columna llamada ‘order_year’ que contiene solo el año de cada fecha en la

4
 columna ‘order_date’. La propiedad .dt.year accede al componente del año de cada fecha en la
serie ‘order_date’. Esta operación se basa en la propiedad de objetos de fecha y hora en pandas
que permite acceder a varios componentes de la fecha y hora, como el año, el mes, el día, etc. y
por ultimo con el comando .value_counts() se cuenta el número de ocurrencias de cada año en la
columna ‘order_year’ y devuelve un objeto de serie que contiene estos recuentos, ordenados de el
que tiene mayor cantidad al que tiene menos.
[9]: df['order_date'] = pd.to_datetime(df['order_date'])
df['order_year'] = df['order_date'].dt.year
df['order_year'].value_counts()

[9]: order_year
2017 688
2016 635
2018 292
Name: count, dtype: int64

Para organizar los años de menor a mayor se hizo uso del comando .value_counts().sort_index()

[10]: df['order_year'].value_counts().sort_index()

[10]: order_year
2016 635
2017 688
2018 292
Name: count, dtype: int64

###Ejercicio 4 Cuantas ordenes hay para cada una de las sucursales de las bicicleterias.
[11]: # Se hace uso del comando .value_counts() en la columna de store_id para saber␣
↪cuantas ordenes hay para cada una de las sucursales de las bicicleterias.

df['store_id'].value_counts()

[11]: store_id
2 1093
1 348
3 174
Name: count, dtype: int64

###Ejercicio 5 En el año 2018 cual sucursal fue la que tuvo mas ordenes.
utilizamos el método value_counts() para contar la frecuencia de cada valor único en la columna
‘store_id’, pero solo para el subconjunto de datos correspondiente al año 2018. Después, utilizamos
el método idxmax() para obtener el índice (es decir, el valor del ‘store_id’) con la frecuencia más
alta en ese subconjunto de datos, es decir, la tienda con más órdenes en 2018.
[12]: df_2018 = df[df['order_year'] == 2018]
most_orders_store = df_2018['store_id'].value_counts().idxmax()

5
 print(f"La sucursal con más órdenes en 2018 fue: {most_orders_store}")

La sucursal con más órdenes en 2018 fue: 2

###Ejercicio 6 Cuantas ordenes hay por cada uno de los empleados de las sucursales.
[13]: df['staff_id'].value_counts()

[13]: staff_id
6 553
7 540
3 184
2 164
8 88
9 86
Name: count, dtype: int64

[14]: # Creamos un diccionario para almacenar los conteos de pedidos para cada␣
↪empleado

order_counts = {}

# Iterar sobre cada fila del DataFrame

for i in range(len(df)):
# Obtener el ID del empleado y el ID de la tienda
staff_id = df.loc[i, 'staff_id']
store_id = df.loc[i, 'store_id']

# Verificamos si el ID del empleado ya está en el diccionario

if staff_id not in order_counts:
# Si no está, inicializar el conteo para ese empleado
order_counts[staff_id] = {}

# Verificarmos si el ID de la tienda ya está en el diccionario para ese␣

↪empleado

if store_id not in order_counts[staff_id]:

# Si no está, inicializar el conteo para esa tienda
order_counts[staff_id][store_id] = 0

# Incrementar el conteo de pedidos para ese empleado y tienda

order_counts[staff_id][store_id] += 1

# Imprimir los conteos de pedidos para cada empleado y tienda

for staff_id, store_counts in order_counts.items():
print(f"Empleado ID: {staff_id}")
for store_id, count in store_counts.items():
print(f" Store ID: {store_id}, Order Count: {count}")

Empleado ID: 2

6
 Store ID: 1, Order Count: 164
Empleado ID: 6
Store ID: 2, Order Count: 553
Empleado ID: 7
Store ID: 2, Order Count: 540
Empleado ID: 3
Store ID: 1, Order Count: 184
Empleado ID: 8
Store ID: 3, Order Count: 88
Empleado ID: 9
Store ID: 3, Order Count: 86
###Ejercicio 7 En el año 2018 cual fue el empleado que realizo mas ordenes.
Seleccionnamos lo que son todas las filas del DataFrame df donde el valor en la columna ‘or-
der_year’ es igual a 2018 y lo asigna a un nuevo DataFrame llamado df_2018. despues usamos
most_orders_staff = df_2018[‘staff_id’].value_counts().idxmax(): para calcular el número de ór-
denes para cada empleado en el DataFrame df_2018, encuentra el identificador del empleado con
el mayor número de órdenes y lo asigna a la variable most_orders_staff.
[15]: df_2018 = df[df['order_year'] == 2018]
most_orders_staff = df_2018['staff_id'].value_counts().idxmax()
print(f"El empleado con más órdenes en 2018 fue: {most_orders_staff}")

El empleado con más órdenes en 2018 fue: 7

###Ejercicio 8 Crear una columna nueva, llamada ‘preparing_time’, que seria el tiempo de
procesado de una orden, es decir el tiempo que transcurrio desde que se realizo la orden (order_date)
y el momento en que se envio la orden (shipped_date). Tip: Las columnas order_date y shipped
date deberan estar en formato datetime, para poder realizar la diferencia de tiempo.
[16]: # Comenzamos convitineod las columnas 'order_date' y 'shipped_date' a formato␣
↪datetime

df['order_date'] = pd.to_datetime(df['order_date'])
df['shipped_date'] = pd.to_datetime(df['shipped_date'])

# Seguimos con el calculo de la diferencia de tiempo entre 'shipped_date' y␣

↪'order_date'

df['preparing_time'] = df['shipped_date'] - df['order_date']

# por ultimo vamos a imprimir las primeras 5 filas del dataframe

print(df.head())

order_id customer_id order_status order_date required_date shipped_date \

0 1 259 4 2016-01-01 2016-01-03 2016-01-03
1 2 1212 4 2016-01-01 2016-01-04 2016-01-03
2 3 523 4 2016-01-02 2016-01-05 2016-01-03
3 4 175 4 2016-01-03 2016-01-04 2016-01-05
4 5 1324 4 2016-01-03 2016-01-06 2016-01-06

7
 store_id staff_id order_year preparing_time
0 1 2 2016 2 days
1 2 6 2016 2 days
2 2 7 2016 1 days
3 1 3 2016 2 days
4 2 6 2016 3 days
###Ejercicio 9 Usando la columna que crearon anteriormente llamada ‘preparing_time’, calcu-
lar el tiempo promedio de procesamiento de ordenes de cada una de las sucursales. En un mensaje
imprimir cual fue la que tenia mejores tiempos de procesamiento de una orden.
Se creo primero lo que es un diccionario vacío llamado average_preparing_time para almacenar los
tiempos promedio de preparación para cada sucursal. Despues se hace un bucle para cada identi-
ficador de sucursal único, el cual se itera sobre cada identificador de sucursal único en la columna
‘store_id’ del DataFrame df. Se cálcula el tiempo promedio de preparación para cada sucursal:
donde se calcula el tiempo promedio de preparación de estas órdenes y se guarda en el diccionario
average_preparing_time, utilizando el identificador de la sucursal como clave. Finalizamos con
la identificación de la sucursal con el mejor tiempo de procesamiento: donde se utilizo la función
min() junto con el parámetro key para encontrar la clave (es decir, el identificador de la sucursal)
en el diccionario average_preparing_time que tiene el valor mínimo, es decir, el tiempo promedio
de preparación más bajo. El identificador de esta sucursal se asigna a la variable best_store_id.
[17]: # Calculamos el tiempo promedio de procesamiento de ordenes de cada una de las␣
↪sucursales

average_preparing_time = {}
for store_id in df['store_id'].unique():
store_df = df[df['store_id'] == store_id]
average_preparing_time[store_id] = store_df['preparing_time'].mean()

# Imprimimos el tiempo promeido de procesamiento de ordenes de cada una de las␣

↪sucursales y la sucursal con mejores tiempos de procesamiento de una orden

best_store_id = min(average_preparing_time, key=average_preparing_time.get)

print(f"tiempo promedio de procesamiento de ordenes de cada una de las␣
↪sucursales: {average_preparing_time} ")

print(f"La sucursal con mejores tiempos de procesamiento de una orden es:␣

↪{best_store_id}")

tiempo promedio de procesamiento de ordenes de cada una de las sucursales: {1:

Timedelta('2 days 01:05:54.929577464'), 2: Timedelta('1 days
23:20:25.907752698'), 3: Timedelta('1 days 22:08:27.042253521')}
La sucursal con mejores tiempos de procesamiento de una orden es: 3