97 lines
8.8 KiB
Python
97 lines
8.8 KiB
Python
import pandas as pd # pyright: ignore[reportMissingModuleSource]
|
|
import numpy as np
|
|
|
|
"""Crear un DataFrame desde un archivo CSV"""
|
|
|
|
df = pd.read_csv("DataSources/automobile_parts.csv") # Leer un archivo CSV y crear un DataFrame a partir de él, esta fuente puede ser datos SQL, archivo Excel, JSON, etc.
|
|
|
|
#------------------------------------------------inspeccionar el dataframe-------------------------------------
|
|
print("inspeccionar dataframe: \n", df.head(2), end="\n\n") # Mostrar las primeras filas del DataFrame para inspeccionar su contenido, se puede usar un valor int como argumento para especificar el número de filas a mostrar, por defecto es 5.
|
|
print(df.tail(3), end="\n\n") # Mostrar las últimas filas del DataFrame, se puede usar un valor int como argumento para especificar el número de filas a mostrar, por defecto es 5.
|
|
print(df.info(), end="\n\n") # Mostrar un resumen conciso del DataFrame, incluyendo el número de entradas no nulas, tipos de datos de cada columna y uso de memoria.
|
|
print(df.describe(), end="\n\n") # Generar estadísticas descriptivas del DataFrame, incluyendo conteo, media, desviación estándar, mínimo y máximo para cada columna numérica.
|
|
|
|
description = df.describe()
|
|
|
|
"""Indexación y segmentación (Seleccion y filtrado)"""
|
|
|
|
keys = df.keys()
|
|
|
|
print("claves: \n", keys, end="\n\n") # Mostrar los nombres de las columnas del DataFrame.
|
|
print(df.columns, end="\n\n") # Mostrar los nombres de las columnas del DataFrame, similar a keys().
|
|
|
|
print(list(df.columns), end="\n\n") # Convertir los nombres de las columnas a una lista y mostrarla.
|
|
|
|
# for i, j in zip(df.columns, list(df.columns)):
|
|
# print(i, "-", j, end=", ") # Iterar a través de los nombres de las columnas usando zip para mostrar cada nombre de columna dos veces. El método zip se usa para combinar dos o más iterables (como listas, tuplas, etc.) en un solo iterable de tuplas. En este caso, combina los nombres de las columnas de df.columns y la lista de nombres de columnas de list(df.columns) para mostrar cada nombre de columna dos veces.
|
|
|
|
print("\n")
|
|
print(df['TYPE'], end="\n\n") # Mostrar los valores de la columna 'TYPE' en el DataFrame. Esto devolverá una Serie que contiene los valores de esa columna específica.
|
|
print (df['TYPE'][4], end="\n\n") # Mostrar el valor de la columna 'TYPE' en el índice 4. Esto devolverá el valor específico ubicado en ese índice en la columna 'TYPE'.
|
|
#método loc
|
|
print(df.loc[4, 'TYPE'], end="\n\n") # Mostrar el valor de la columna 'TYPE' en el índice 4 usando el método loc. Esto devolverá el valor específico ubicado en ese índice en la columna 'TYPE'. El método loc se usa para indexación basada en etiquetas, donde se especifican las etiquetas de fila y columna para acceder a datos específicos en el DataFrame.
|
|
|
|
print(df.loc[4], end="\n\n") # Mostrar la fila completa en el índice 4 usando el método loc. Esto devolverá una Serie que contiene todos los valores para esa fila específica. El método loc se usa para indexación basada en etiquetas, donde se especifica la etiqueta de fila para acceder a toda la fila de datos en el DataFrame.
|
|
|
|
print(df.iloc[0:2, 0:3], end="\n\n") #Muestra un rango de filas y columnas, en este caso, mostrará las primeras dos filas (índice 0 y 1) y las primeras tres columnas (índice 0, 1 y 2) del DataFrame. El método iloc se usa para indexación basada en enteros, donde se especifican los índices de fila y columna para acceder a datos específicos en el DataFrame.
|
|
|
|
expensive_articles = df[df['PRICE'] > 400] # Filtrar el DataFrame para incluir solo filas donde la columna 'PRICE' tenga valores mayores que 1000. Esto devolverá un nuevo DataFrame que contiene solo los artículos caros.
|
|
|
|
print("Mostrar artículos caros", expensive_articles, end="\n\n")
|
|
|
|
audi_only = df[(df['MANUFACTURER'] == 'Audi') & (df['PRICE'] > 450)] # Filtrar el DataFrame para incluir solo filas donde la columna 'MANUFACTURER' tenga el valor 'Audi' y la columna 'PRICE' tenga valores mayores que 400. Esto devolverá un nuevo DataFrame que contiene solo los artículos fabricados por Audi y con precio superior a 400.
|
|
|
|
print("Mostrar solo audi y precio mayor que 400USD: \n", audi_only, end="\n\n")
|
|
|
|
|
|
"""MANUPULACION Y LIMPIEZA"""
|
|
|
|
df["QUANTITY"] = np.random.randint(1, 10, size=len(df)) # Crear una nueva columna 'QUANTITY' en el DataFrame y asignar un valor aleatorio entre 1 y 10 a cada fila utilizando la función randint de NumPy. El argumento size=len(df) asegura que se genere un número aleatorio para cada fila del DataFrame.
|
|
|
|
print(df.head(), end="\n\n")
|
|
|
|
# for i in range(len(df)):
|
|
# df.loc[i, "QUANTITY"] = np.random.randint(1, 10) # Asignar un valor aleatorio entre 1 y 10 a la columna 'QUANTITY' para cada fila del DataFrame. Esto se hace utilizando un bucle for para iterar a través de cada índice del DataFrame y el método loc para asignar el valor aleatorio a la columna 'QUANTITY' en esa fila específica.
|
|
|
|
print(df.head(), end="\n\n")
|
|
|
|
# df['Qty_2'] = [np.random.randint(1, 10) for _ in range(len(df))] # Crear una nueva columna 'Qty_2' en el DataFrame y asignar un valor aleatorio entre 1 y 10 a cada fila utilizando una comprensión de lista. La comprensión de lista itera a través de un rango que coincide con la longitud del DataFrame (len(df)) y genera un número aleatorio para cada fila.
|
|
# print(df.head(3), end="\n\n")
|
|
|
|
# import random
|
|
# df["MODEL"] = "A"
|
|
# df_tempo = df[df["MANUFACTURER"] == 'BMW']
|
|
|
|
# for i in range(len(df_tempo)):
|
|
# df_tempo.loc[i, "MODEL"] = random.choice(["A", "B", "C"]) # Asignar un valor aleatorio de la lista ["A", "B", "C"] a la columna 'MODEL' para cada fila del DataFrame temporal df_tempo, que contiene solo las filas donde el fabricante es 'BMW'. Esto se hace utilizando un bucle for para iterar a través de cada índice del DataFrame temporal y el método loc para asignar el valor aleatorio a la columna 'MODEL' en esa fila específica.
|
|
|
|
# print(df_tempo.head(3), end="\n\n")
|
|
|
|
# df = df[["PART ID", "TYPE", "MANUFACTURER", "YEAR", "QUANTITY", "PRICE"]] # Reorganizar las columnas del DataFrame para que aparezcan en el orden especificado.
|
|
# print(df.head(3), end="\n\n")
|
|
|
|
df.insert(4, "QUANTITY", df.pop("QUANTITY")) # Mover la columna 'QUANTITY' a la posición 4 en el DataFrame. El método pop se usa para eliminar la columna 'QUANTITY' del DataFrame y devolverla, y luego el método insert se usa para insertar esa columna en la posición especificada (índice 4) con el mismo nombre 'QUANTITY'.
|
|
print(df.head(), end="\n\n")
|
|
|
|
df["SUBTOTAL_INVENTORY"] = df["QUANTITY"] * df["PRICE"] # Crear una nueva columna 'SUBTOTAL_INVENTORY' que contiene el resultado de multiplicar la columna 'QUANTITY' por la columna 'PRICE' para cada fila del DataFrame. Esto calculará el subtotal del inventario para cada artículo basado en su cantidad y precio.
|
|
print(df.head(), end="\n\n")
|
|
|
|
df = df.rename(columns={"SUBTOTAL_INVENTORY": "SUBTOTAL"}) # Renombrar la columna 'SUBTOTAL_INVENTORY' a 'SUBTOTAL' en el DataFrame. El método rename se usa para cambiar el nombre de las columnas, donde se proporciona un diccionario que mapea los nombres antiguos a los nuevos.
|
|
print(df.head(), end="\n\n")
|
|
|
|
#NaN representan datos faltantes en el dataSet, este ejemplo se esta agregando para poder demostrar la limpieza del dataSet, para esto hay que ensuciarlo con estos datos
|
|
|
|
df["ACTIVE"] = [np.random.choice([True, False, np.nan]) for _ in range(len(df))] # Crear una nueva columna 'ACTIVE' y asignar un valor aleatorio de True, False o NaN a cada fila utilizando una comprensión de lista. La función np.random.choice se usa para seleccionar aleatoriamente un valor de la lista [True, False, np.nan] para cada fila del DataFrame, y la comprensión de lista itera a través de un rango que coincide con la longitud del DataFrame (len(df)).
|
|
print(df.head(), end="\n\n")
|
|
|
|
df.loc[len(df)] = ['PARTXXXX', 'Amortiguador', 'Nissan', 2026, np.nan, 100.11, np.nan, True] # Agregar una nueva fila al final del DataFrame con los valores especificados para cada columna. El método loc se usa para acceder a la posición del índice que es igual a la longitud actual del DataFrame (len(df)), lo que permite agregar una nueva fila al final. Los valores proporcionados corresponden a cada columna en el orden del DataFrame.
|
|
print(df.iloc[[-1]])
|
|
|
|
df = df.iloc[:-1] # Eliminar la última fila del DataFrame utilizando iloc para seleccionar todas las filas excepto la última. Esto se hace para limpiar el DataFrame después de agregar una fila con datos faltantes (NaN) para demostración.
|
|
print(df.tail(), end="\n\n")
|
|
|
|
"""Exportacion de resultados"""
|
|
|
|
df.to_csv("DataSources/automobile_parts_updated.csv", index=False) # Exportar el DataFrame a un archivo CSV llamado "automobile_parts_updated.csv" en la carpeta "DataSources". El argumento index=False se usa para evitar que se exporte el índice del DataFrame al archivo CSV, lo que significa que solo se exportarán las columnas de datos sin incluir el índice.
|
|
|