me gustaria añadir una tercera función final una vez hace los calculos te pregunta si…
- User
me gustaria añadir una tercera función final una vez hace los calculos te pregunta si quieres hacer un analisis de las ventas si le dices que debe generar una pestaña nueva con un analisis de las referencias según sus ventas utilizando PVP Oferta, PVP NEX solo PVP NEW = ( Costo neto + Margen por Unidad) tambie hay que hacer otra pestaña donde analiza por referencia los margenes actuales= PVP Oferta - Coste Neto y comparar con el Margen por Unidad calculado por el programa . Estos dos analisis tienen que tener en encuenta la Percepció , Marca , Mesuras i Unitats 2024 hay que buscar conclusiones y/o cluster que nos ayuden a mejor el pricing para incrementar las ventas Unitats 2024
- Assistant
Para implementar esta funcionalidad, podemos usar un programa o script, dependiendo de cómo estés realizando los cálculos actualmente. Aquí te proporciono una idea general de cómo podría estructurarse este flujo de trabajo utilizando, por ejemplo, Excel y VBA o Python para automatizar el proceso:
Paso 1: Realizar los Cálculos Actuales
Supongamos que ya tienes un conjunto de datos con los cálculos necesarios de ventas, incluyendo campos como PVP Oferta, PVP NEX, Costo Neto, y Margen por Unidad.
Paso 2: Añadir Función para Análisis de Ventas
Al final del proceso de cálculos, presentar una pregunta al usuario que determine si desea proceder con un análisis adicional:
Sub AnalizarVentas() Dim respuesta As VbMsgBoxResult respuesta = MsgBox("¿Quieres hacer un análisis de las ventas?", vbYesNo) If respuesta = vbYes Then Call GenerarAnalisisVentas End If End SubPaso 3: Generar el Análisis de Ventas
Crear una nueva pestaña para el análisis de ventas. Aquí puedes usar VBA en Excel o, si prefieres, un script en Python que maneje la exportación y análisis de datos en Pandas.
Sub GenerarAnalisisVentas() Dim wsActual As Worksheet Dim wsAnalisis As Worksheet Dim wsMargenes As Worksheet ' Referencia a la hoja actual Set wsActual = ThisWorkbook.Sheets("Datos") ' Crear nueva pestaña para el análisis de ventas Set wsAnalisis = ThisWorkbook.Sheets.Add wsAnalisis.Name = "Analisis Ventas" ' Crear nueva pestaña para el análisis de márgenes Set wsMargenes = ThisWorkbook.Sheets.Add wsMargenes.Name = "Analisis Margenes" ' Analizar por referencia las ventas usando PVP Oferta, PVP NEX, PVP NEW ' Calculando PVP NEW = (Costo Neto + Margen por Unidad) With wsAnalisis .Cells(1, 1).Value = "Referencia" .Cells(1, 2).Value = "Ventas PVP Oferta" .Cells(1, 3).Value = "Ventas PVP NEX" .Cells(1, 4).Value = "Ventas PVP NEW" ' Llena tus datos aquí... End With ' Análisis de márgenes actuales y comparativos With wsMargenes .Cells(1, 1).Value = "Referencia" .Cells(1, 2).Value = "Margen Actual" .Cells(1, 3).Value = "Margen por Unidad Calculado" ' Llena tus datos aquí... End With End SubPaso 4: Análisis y Clustering
Una vez que los datos están organizados en las nuevas pestañas, puedes proceder a analizarlos buscando patrones o clusters para mejorar el pricing. Esto puede incluir:
- Comparaciones entre márgenes actuales y calculados.
- Análisis por percepción, marca, medidas, y unidades.
Este paso puede realizarse manualmente o usando herramientas estadísticas o de machine learning para identificar patrones en los datos.
Conclusión:
Al final del análisis, puedes sacar conclusiones sobre cómo ajustar el pricing para incrementar las ventas en 2024. Esta implementación proporcionará un enfoque sistemático y estandarizado para analizar tus datos de ventas y márgenes, permitiéndote tomar decisiones informadas en tu estrategia de precios.
- User
añadir esto al codigo
- Assistant
Para añadir la funcionalidad que describiste al código VBA proporcionado, primero debemos asegurarnos de que los datos relevantes están estructurados en tu hoja de cálculo. Para el propósito de este ejemplo, asumiré que tus datos están en una hoja llamada "Datos" y que tienes columnas para las referencias, PVP Oferta, PVP NEX, Costo Neto, Margen por Unidad, y otros detalles relevantes.
Aquí tienes una continuación del código anterior, con una lógica básica para generar los cálculos y análisis dentro de las nuevas pestañas:
Sub AnalizarVentas() Dim respuesta As VbMsgBoxResult respuesta = MsgBox("¿Quieres hacer un análisis de las ventas?", vbYesNo) If respuesta = vbYes Then Call GenerarAnalisisVentas End If End Sub Sub GenerarAnalisisVentas() Dim wsDatos As Worksheet Dim wsAnalisis As Worksheet Dim wsMargenes As Worksheet Dim ultimaFila As Long Dim i As Long ' Referencia a la hoja actual que contiene los datos Set wsDatos = ThisWorkbook.Sheets("Datos") ultimaFila = wsDatos.Cells(wsDatos.Rows.Count, 1).End(xlUp).Row ' Crear nueva pestaña para el análisis de ventas Set wsAnalisis = ThisWorkbook.Sheets.Add(After:=wsDatos) wsAnalisis.Name = "Analisis Ventas" ' Crear nueva pestaña para el análisis de márgenes Set wsMargenes = ThisWorkbook.Sheets.Add(After:=wsAnalisis) wsMargenes.Name = "Analisis Margenes" ' Encabezados para el análisis de ventas With wsAnalisis .Cells(1, 1).Value = "Referencia" .Cells(1, 2).Value = "Ventas PVP Oferta" .Cells(1, 3).Value = "Ventas PVP NEX" .Cells(1, 4).Value = "Ventas PVP NEW" End With ' Encabezados para el análisis de márgenes With wsMargenes .Cells(1, 1).Value = "Referencia" .Cells(1, 2).Value = "Margen Actual" .Cells(1, 3).Value = "Margen por Unidad Calculado" End With ' Rellenar los datos de análisis For i = 2 To ultimaFila Dim referencia As String Dim pvpOferta As Double Dim pvpNex As Double Dim costoNeto As Double Dim margenUnidad As Double referencia = wsDatos.Cells(i, 1).Value pvpOferta = wsDatos.Cells(i, 2).Value pvpNex = wsDatos.Cells(i, 3).Value costoNeto = wsDatos.Cells(i, 4).Value margenUnidad = wsDatos.Cells(i, 5).Value Dim pvpNew As Double pvpNew = costoNeto + margenUnidad ' Llenar la hoja de análisis de ventas With wsAnalisis .Cells(i, 1).Value = referencia .Cells(i, 2).Value = pvpOferta .Cells(i, 3).Value = pvpNex .Cells(i, 4).Value = pvpNew End With ' Calcular y llenar la hoja de análisis de márgenes With wsMargenes .Cells(i, 1).Value = referencia .Cells(i, 2).Value = pvpOferta - costoNeto ' Margen Actual .Cells(i, 3).Value = margenUnidad ' Margen por Unidad Calculado End With Next i End SubConsideraciones:
-
Revisar las Columnas: El código asume que tus datos están en columnas específicas. Asegúrate de ajustar los índices de columna (
referencia,pvpOferta,pvpNex,costoNeto,margenUnidad) para que coincidan con la disposición de tus datos en la hoja de trabajo "Datos". -
Concluir el Análisis: Este script crea dos nuevas pestañas, "Analisis Ventas" y "Analisis Margenes", comparando los valores de coste y márgenes. Podrías complementar esto con gráficos o análisis adicionales para identificar clusters y extraer insights específicos.
-
Test y Validación: Ejecuta el script con un subconjunto de tus datos o en un entorno de pruebas para asegurarte de que el análisis refleja correctamente tus requisitos y que los cálculos son precisos.
-
- User
añadir esta funcionalidad a este codigo y que los resultados sean muy visuales y agradables para un ejecutivo
- Assistant
Para mejorar la presentación de los resultados y hacerlos más visuales y adecuados para un ejecutivo, te recomiendo utilizar herramientas de formato y gráficos en Excel. El código VBA proporcionado se puede extender para añadir funcionalidades como la aplicación automática de formato de tabla, gráficos y otras mejoras de visualización. Aquí tienes una implementación mejorada:
Sub AnalizarVentas() Dim respuesta As VbMsgBoxResult respuesta = MsgBox("¿Quieres hacer un análisis de las ventas?", vbYesNo) If respuesta = vbYes Then Call GenerarAnalisisVentas End If End Sub Sub GenerarAnalisisVentas() Dim wsDatos As Worksheet Dim wsAnalisis As Worksheet Dim wsMargenes As Worksheet Dim ultimaFila As Long Dim i As Long ' Referencia a la hoja actual que contiene los datos Set wsDatos = ThisWorkbook.Sheets("Datos") ultimaFila = wsDatos.Cells(wsDatos.Rows.Count, 1).End(xlUp).Row ' Crear nuevas pestañas para el análisis de ventas y márgenes Set wsAnalisis = ThisWorkbook.Sheets.Add(After:=wsDatos) wsAnalisis.Name = "Analisis Ventas" Set wsMargenes = ThisWorkbook.Sheets.Add(After:=wsAnalisis) wsMargenes.Name = "Analisis Margenes" ' Encabezados para el análisis de ventas With wsAnalisis .Cells(1, 1).Value = "Referencia" .Cells(1, 2).Value = "Ventas PVP Oferta" .Cells(1, 3).Value = "Ventas PVP NEX" .Cells(1, 4).Value = "Ventas PVP NEW" End With ' Encabezados para el análisis de márgenes With wsMargenes .Cells(1, 1).Value = "Referencia" .Cells(1, 2).Value = "Margen Actual" .Cells(1, 3).Value = "Margen por Unidad Calculado" End With ' Rellenar los datos de análisis For i = 2 To ultimaFila Dim referencia As String Dim pvpOferta As Double Dim pvpNex As Double Dim costoNeto As Double Dim margenUnidad As Double referencia = wsDatos.Cells(i, 1).Value pvpOferta = wsDatos.Cells(i, 2).Value pvpNex = wsDatos.Cells(i, 3).Value costoNeto = wsDatos.Cells(i, 4).Value margenUnidad = wsDatos.Cells(i, 5).Value Dim pvpNew As Double pvpNew = costoNeto + margenUnidad ' Llenar la hoja de análisis de ventas With wsAnalisis .Cells(i, 1).Value = referencia .Cells(i, 2).Value = pvpOferta .Cells(i, 3).Value = pvpNex .Cells(i, 4).Value = pvpNew End With ' Calcular y llenar la hoja de análisis de márgenes With wsMargenes .Cells(i, 1).Value = referencia .Cells(i, 2).Value = pvpOferta - costoNeto ' Margen Actual .Cells(i, 3).Value = margenUnidad ' Margen por Unidad Calculado End With Next i ' Aplicar formato de tabla a las hojas de análisis FormatearComoTabla wsAnalisis FormatearComoTabla wsMargenes ' Crear gráficos CrearGrafico wsAnalisis, "Graficos Ventas", "Ventas PVP" CrearGrafico wsMargenes, "Graficos Margenes", "Márgenes" End Sub Sub FormatearComoTabla(ws As Worksheet) Dim tblRango As Range Set tblRango = ws.Range(ws.Cells(1, 1), ws.Cells(ws.Cells(ws.Rows.Count, 1).End(xlUp).Row, ws.Cells(1, ws.Columns.Count).End(xlToLeft).Column)) ws.ListObjects.Add(xlSrcRange, tblRango, , xlYes).Name = ws.Name & "Tabla" ws.ListObjects(ws.Name & "Tabla").TableStyle = "TableStyleMedium9" End Sub Sub CrearGrafico(ws As Worksheet, nombreHoja As String, titulo As String) Dim chartObj As ChartObject Set chartObj = ws.ChartObjects.Add(Left:=300, Width:=400, Top:=10, Height:=250) With chartObj.Chart .SetSourceData Source:=ws.Range("B1:B" & ws.Cells(ws.Rows.Count, 2).End(xlUp).Row) .ChartType = xlColumnClustered .HasTitle = True .ChartTitle.Text = titulo .Axes(xlCategory, xlPrimary).HasTitle = True .Axes(xlCategory, xlPrimary).AxisTitle.Text = "Referencias" .Axes(xlValue, xlPrimary).HasTitle = True .Axes(xlValue, xlPrimary).AxisTitle.Text = "Valores" End With End SubExplicación de Mejoras:
-
Formato de Tabla:
- Se aplicó un estilo de tabla a los datos de cada pestaña para hacerlos más visuales y fáciles de leer.
-
Gráficos:
- Se añadieron gráficos de columnas para las ventas y márgenes, proporcionando una representación visual clara de los datos.
-
Estilo:
- El estilo
TableStyleMedium9es usado para darle un toque profesional. Puedes cambiarlo según tus preferencias.
- El estilo
-
Ubicación de Gráficos:
- Los gráficos están situados junto a los datos, pero puedes modificar la posición modificando los parámetros
Left,Width,Top, yHeight.
- Los gráficos están situados junto a los datos, pero puedes modificar la posición modificando los parámetros
Estos cambios aseguran que los datos y resultados sean fácilmente comprensibles por los ejecutivos, con visualizaciones atractivas y bien estructuradas en Excel.
-
- User
añadir a este codigo: import pandas as pd import numpy as np import tkinter as tk from tkinter import messagebox from tkinter import filedialog
def abrir_limites_margen(): """Función para abrir el submenú y configurar los límites de margen por percepción""" limite_window = tk.Toplevel(app) limite_window.title("Límites de Margen por Percepción")
tk.Label(limite_window, text="Configura los límites de margen para cada percepción:").grid(row=0, columnspan=2, pady=5) row_num = 1 for percepcion, limite_var in limites_margen.items(): tk.Label(limite_window, text=f"Límite para {percepcion}:").grid(row=row_num, column=0, pady=5) tk.Entry(limite_window, textvariable=limite_var).grid(row=row_num, column=1, pady=5) row_num += 1 tk.Button(limite_window, text="Confirmar", command=limite_window.destroy).grid(row=row_num, columnspan=2, pady=10)def crear_ventana_parametros(): param_window = tk.Toplevel(app) param_window.title("Parámetros de Cálculo de Márgenes")
# Entradas y etiquetas para los diferentes parámetros de margen tk.Label(param_window, text="Margen Mínimo por Unidad:").grid(row=0, column=0, pady=5) margen_minimo_entry = tk.Entry(param_window) margen_minimo_entry.grid(row=0, column=1, pady=5) margen_minimo_entry.insert(0, "10") tk.Label(param_window, text="Margen Máximo por Unidad:").grid(row=1, column=0, pady=5) margen_maximo_entry = tk.Entry(param_window) margen_maximo_entry.grid(row=1, column=1, pady=5) margen_maximo_entry.insert(0, "25") tk.Label(param_window, text="Porcentaje Máximo Margen:").grid(row=2, column=0, pady=5) porcentaje_margen_entry = tk.Entry(param_window) porcentaje_margen_entry.grid(row=2, column=1, pady=5) porcentaje_margen_entry.insert(0, "0.35") tk.Label(param_window, text="Margen Objetivo Mínimo:").grid(row=3, column=0, pady=5) margen_min_entry = tk.Entry(param_window) margen_min_entry.grid(row=3, column=1, pady=5) margen_min_entry.insert(0, "16") tk.Label(param_window, text="Margen Objetivo Máximo:").grid(row=4, column=0, pady=5) margen_max_entry = tk.Entry(param_window) margen_max_entry.grid(row=4, column=1, pady=5) margen_max_entry.insert(0, "17") tk.Button(param_window, text="Calcular", command=lambda: ejecutar_calculo( margen_minimo_entry.get(), margen_maximo_entry.get(), porcentaje_margen_entry.get(), margen_min_entry.get(), margen_max_entry.get(), param_window)).grid(row=5, columnspan=2, pady=10)def validar_entrada(valor): """Función para validar entradas numéricas""" try: val = float(valor) if val < 0: raise ValueError return val except ValueError: raise ValueError("Por favor, introduce un número válido y mayor o igual a cero.")
Método para calcular los márgenes ajustados
def calcular_margen(df, margen_minimo_por_unidad, margen_maximo_por_unidad, porcentaje_maximo_margen, margen_objetivo_min, margen_objetivo_max): df_resultado = pd.DataFrame() margen_objetivo_promedio = (margen_objetivo_min + margen_objetivo_max) / 2
# Comprobación de la existencia de columnas necesarias for column in ['Percepció', 'Costo neto', 'Unitats 2024', 'PVP NEX']: if column not in df.columns: raise ValueError(f"La columna '{column}' no se encuentra en el DataFrame.") for perception, grupo in df.groupby('Percepció'): multiplicador = percepcion_margen.get(perception, 1.0) # Calcular un margen inicial ajustado por percepción grupo['Margen por Unidad'] = grupo['Costo neto'] * multiplicador * porcentaje_maximo_margen grupo['Margen por Unidad'] = np.clip(grupo['Margen por Unidad'], margen_minimo_por_unidad, margen_maximo_por_unidad) # Aplicar la nueva restricción de margen basado en PVP NEX limite_margen_percepcion = limites_margen.get(perception).get() for idx, row in grupo.iterrows(): if pd.notna(row['PVP NEX']) and row['PVP NEX'] > 0: pvp_final = row['Costo neto'] + row['Margen por Unidad'] diferencia = row['PVP NEX'] - pvp_final # Ajustar el margen para asegurar que la diferencia esté dentro del rango permitido if diferencia < 0 or diferencia > limite_margen_percepcion: margen_ajuste = min(max(0, diferencia), limite_margen_percepcion) nuevo_pvp_final = row['PVP NEX'] - margen_ajuste grupo.at[idx, 'Margen por Unidad'] = max(0, nuevo_pvp_final - row['Costo neto']) grupo['Check'] = np.where(grupo['PVP NEX'] > 0, grupo['Costo neto'] + grupo['Margen por Unidad'] - grupo['PVP NEX'], np.nan) df_resultado = pd.concat([df_resultado, grupo]) margen_promedio_ponderado_final = (df_resultado['Margen por Unidad'] * df_resultado['Unitats 2024']).sum() / df_resultado['Unitats 2024'].sum() return df_resultado, margen_promedio_ponderado_finaldef ejecutar_calculo(margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max, window): try: margen_minimo = validar_entrada(margen_minimo) margen_maximo = validar_entrada(margen_maximo) porcentaje_margen = validar_entrada(porcentaje_margen) margen_min = validar_entrada(margen_min) margen_max = validar_entrada(margen_max)
df_ajustado, margen_promedio = calcular_margen( df, margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max ) messagebox.showinfo("Resultado", f"Margen promedio ponderado final: {margen_promedio:.2f}") # Guardar el archivo file_path = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx")]) if file_path: with pd.ExcelWriter(file_path, engine='openpyxl') as writer: df_ajustado.to_excel(writer, sheet_name='Datos Ajustados', index=False) messagebox.showinfo("Guardado", "Archivo guardado exitosamente.") except ValueError as e: messagebox.showerror("Error de Validación", str(e)) except Exception as e: messagebox.showerror("Error", f"Error en el cálculo: {str(e)}") finally: window.destroy()Crear la interfaz gráfica de usuario primero
app = tk.Tk() app.title("Calculadora de Márgenes")
Definir la ruta al archivo Excel
file_path = r'C:\Users\ismael.gallardo\Documents\Tabla de comparación neumáticos €.xlsx'
Cargar la hoja "Data" en un DataFrame
df = pd.read_excel(file_path, sheet_name='Data', engine='openpyxl')
Imprimir columnas disponibles para verificar nombres
print("Columnas en el DataFrame:") print(df.columns)
Definiciones de percepción de margen
percepcion_margen = { 'Top Gama': 1.3, 'Premium': 1.2, 'Regular': 1.1, 'Budget': 1.0, 'Low Cost': 0.9 }
Límites de margen por percepción (vinculado con la nueva UI)
limites_margen = { 'Top Gama': tk.DoubleVar(value=2.0), 'Premium': tk.DoubleVar(value=2.0), 'Regular': tk.DoubleVar(value=1.5), 'Budget': tk.DoubleVar(value=1.5), 'Low Cost': tk.DoubleVar(value=1.0) }
Creación del menú inicial con botones para las dos configuraciones
tk.Button(app, text="Configurar Límites de Margen", command=abrir_limites_margen).pack(pady=10) tk.Button(app, text="Configurar Parámetros de Cálculo", command=crear_ventana_parametros).pack(pady=10)
Ejecutar la aplicación
app.mainloop()
- Assistant
Integrar un sistema de interfaces gráficas (GUI) utilizando Tkinter con funcionalidades de cálculo avanzado en Pandas y visualización en Excel es una tarea bastante interesante. Ya tienes un código que crea una interfaz para ajustar parámetros de margen y realizar cálculos avanzados. Sin embargo, para integrar ambos mundos (VBA y Python), generalmente el enfoque es usar Excel para almacenamiento/visualización, mientras las operaciones computacionales y lógicas las maneja Python.
Dado que tu objetivo podría estar más en mostrar resultados visuales aptos para ejecutivos y tener el cálculo en Python, podrías considerar el siguiente flujo:
-
Python para Cálculos Avanzados: Usa tus funciones en Python para calcular márgenes basados en parámetros personalizados.
-
Excel para Visualización: Una vez hechos los cálculos en Python, exporta los resultados a Excel y aplícale estilos y gráficos usando Python con
openpyxloxlsxwriter.
Aquí te doy una idea de cómo podrías vincular ciertas partes del código para que trabajen juntos:
Explicación e Integración:
-
Gestión de Parámetros y Cálculos en Python: Puedes mantener la lógica de cómo manejas el input de usuario, validación de datos, y cálculo de márgenes dentro de tu interfaz de
tkinter, asegurando la flexibilidad y robustez de tu aplicación. -
Exportación a Excel: Después de calcular, puedes aprovechar
pandaspara exportar los resultados a un archivo Excel, y usar librerías Python adicionales comoopenpyxlpara añadir mejoras visuales, como estilos de tabla y gráficos.
import pandas as pd import numpy as np import tkinter as tk from tkinter import messagebox from tkinter import filedialog from openpyxl import Workbook from openpyxl.styles import NamedStyle from openpyxl.utils.dataframe import dataframe_to_rows def abrir_limites_margen(): # Aquí queda como en tu implementación. pass def crear_ventana_parametros(): # Aquí también procede como en tu implementación. pass def validar_entrada(valor): # Mantener implementación pass def calcular_margen(df, margen_minimo_por_unidad, margen_maximo_por_unidad, porcentaje_maximo_margen, margen_objetivo_min, margen_objetivo_max): # Aquí queda tu lógica de cálculo pass def ejecutar_calculo(margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max, window): try: # Validación de entrada y cálculo margen_minimo = validar_entrada(margen_minimo) margen_maximo = validar_entrada(margen_maximo) porcentaje_margen = validar_entrada(porcentaje_margen) margen_min = validar_entrada(margen_min) margen_max = validar_entrada(margen_max) df_ajustado, margen_promedio = calcular_margen( df, margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max ) # Guardar archivo file_path = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx")]) if file_path: # Crea un libro y exporta DataFrame wb = Workbook() ws = wb.active ws.title = "Datos Ajustados" for r in dataframe_to_rows(df_ajustado, index=False, header=True): ws.append(r) # Aplicar estilos visuales estilo = NamedStyle(name="estilo_excel", font=Font(bold=True)) for cell in ws[1]: # Aplica estilo a la fila de encabezado cell.style = estilo # Inserta un gráfico ejemplo (ajusta según necesidad) # Aquí se puede agregar código para gráficos usando `openpyxl` wb.save(file_path) messagebox.showinfo("Guardado", "Archivo guardado exitosamente con un margen promedio ponderado final de {:.2f}".format(margen_promedio)) except ValueError as e: messagebox.showerror("Error de Validación", str(e)) except Exception as e: messagebox.showerror("Error", f"Error en el cálculo: {str(e)}") finally: window.destroy() # Primitiva interfaz gráfica app = tk.Tk() app.title("Calculadora de Márgenes") # Cargar datos file_path = r'C:\Users\ismael.gallardo\Documents\Tabla de comparación neumáticos €.xlsx' df = pd.read_excel(file_path, sheet_name='Data', engine='openpyxl') # Configuración inicial de interfaz tk.Button(app, text="Configurar Límites de Margen", command=abrir_limites_margen).pack(pady=10) tk.Button(app, text="Configurar Parámetros de Cálculo", command=crear_ventana_parametros).pack(pady=10) # Ejecutar programa app.mainloop()Características Mejoradas Propuestas:
-
Estilos de Excel: Se ejemplifica la adición de estilos a Excel con
openpyxl, pero se puede mejorar mucho más con formatos condicionales y otros estilos. -
Gráficos: Usar
openpyxlo librerías Python para gráficos (matplotlib,seaborn) y exportarlos, también permitiendo embeber gráficos en Excel. -
Modularidad y Prueba: Al calcular márgenes ampliamente con
numpyypandas, puedes realizar pruebas y validaciones robustas antes de escribir en Excel.
Este enfoque tiene el potencial de ofrecer potente procesamiento de datos mientras garantiza que los resultados sean atractivos y comprensibles mediante la exportación a Excel.
-
- User
quiero todo en el mismo codigo el programa mas la nueva funiconalidad visual
- Assistant
Entendiendo que deseas combinar una aplicación que utilice tanto Tkinter para la interfaz gráfica como Pandas y NumPy para el procesamiento de datos, junto con capacidades de exportación a Excel con una presentación visual mejorada, aquí tienes un código completo que combina estos aspectos.
El código proporcionado hará lo siguiente:
- Utilizar Tkinter para la interfaz gráfica donde se configuran límites de margen y parámetros de cálculo.
- Utilizar Pandas y NumPy para manejar los cálculos.
- Usar OpenPyXL para manipular y visualizar los datos en Excel con estilo y gráficos básicos.
import pandas as pd import numpy as np import tkinter as tk from tkinter import messagebox from tkinter import filedialog from openpyxl import Workbook from openpyxl.utils.dataframe import dataframe_to_rows from openpyxl.chart import BarChart, Reference from openpyxl.styles import Font from openpyxl.styles import NamedStyle # Ruta al archivo Excel file_path = r'C:\Users\ismael.gallardo\Documents\Tabla de comparación neumáticos €.xlsx' # Cargar la hoja "Data" en un DataFrame df = pd.read_excel(file_path, sheet_name='Data', engine='openpyxl') # Diccionario de multiplicadores de percepción percepcion_margen = { 'Top Gama': 1.3, 'Premium': 1.2, 'Regular': 1.1, 'Budget': 1.0, 'Low Cost': 0.9 } # Límites de margen por percepción (vinculado con la nueva UI) limites_margen = { 'Top Gama': tk.DoubleVar(value=2.0), 'Premium': tk.DoubleVar(value=2.0), 'Regular': tk.DoubleVar(value=1.5), 'Budget': tk.DoubleVar(value=1.5), 'Low Cost': tk.DoubleVar(value=1.0) } def abrir_limites_margen(): """Función para abrir el submenú y configurar los límites de margen por percepción""" limite_window = tk.Toplevel(app) limite_window.title("Límites de Margen por Percepción") tk.Label(limite_window, text="Configura los límites de margen para cada percepción:").grid(row=0, columnspan=2, pady=5) row_num = 1 for percepcion, limite_var in limites_margen.items(): tk.Label(limite_window, text=f"Límite para {percepcion}:").grid(row=row_num, column=0, pady=5) tk.Entry(limite_window, textvariable=limite_var).grid(row=row_num, column=1, pady=5) row_num += 1 tk.Button(limite_window, text="Confirmar", command=limite_window.destroy).grid(row=row_num, columnspan=2, pady=10) def crear_ventana_parametros(): param_window = tk.Toplevel(app) param_window.title("Parámetros de Cálculo de Márgenes") # Entradas y etiquetas para los diferentes parámetros de margen tk.Label(param_window, text="Margen Mínimo por Unidad:").grid(row=0, column=0, pady=5) margen_minimo_entry = tk.Entry(param_window) margen_minimo_entry.grid(row=0, column=1, pady=5) margen_minimo_entry.insert(0, "10") tk.Label(param_window, text="Margen Máximo por Unidad:").grid(row=1, column=0, pady=5) margen_maximo_entry = tk.Entry(param_window) margen_maximo_entry.grid(row=1, column=1, pady=5) margen_maximo_entry.insert(0, "25") tk.Label(param_window, text="Porcentaje Máximo Margen:").grid(row=2, column=0, pady=5) porcentaje_margen_entry = tk.Entry(param_window) porcentaje_margen_entry.grid(row=2, column=1, pady=5) porcentaje_margen_entry.insert(0, "0.35") tk.Label(param_window, text="Margen Objetivo Mínimo:").grid(row=3, column=0, pady=5) margen_min_entry = tk.Entry(param_window) margen_min_entry.grid(row=3, column=1, pady=5) margen_min_entry.insert(0, "16") tk.Label(param_window, text="Margen Objetivo Máximo:").grid(row=4, column=0, pady=5) margen_max_entry = tk.Entry(param_window) margen_max_entry.grid(row=4, column=1, pady=5) margen_max_entry.insert(0, "17") tk.Button(param_window, text="Calcular", command=lambda: ejecutar_calculo( margen_minimo_entry.get(), margen_maximo_entry.get(), porcentaje_margen_entry.get(), margen_min_entry.get(), margen_max_entry.get(), param_window)).grid(row=5, columnspan=2, pady=10) def validar_entrada(valor): """Función para validar entradas numéricas""" try: val = float(valor) if val < 0: raise ValueError return val except ValueError: raise ValueError("Por favor, introduce un número válido y mayor o igual a cero.") # Método para calcular los márgenes ajustados def calcular_margen(df, margen_minimo_por_unidad, margen_maximo_por_unidad, porcentaje_maximo_margen, margen_objetivo_min, margen_objetivo_max): df_resultado = pd.DataFrame() margen_objetivo_promedio = (margen_objetivo_min + margen_objetivo_max) / 2 # Comprobación de la existencia de columnas necesarias for column in ['Percepció', 'Costo neto', 'Unitats 2024', 'PVP NEX']: if column not in df.columns: raise ValueError(f"La columna '{column}' no se encuentra en el DataFrame.") for perception, grupo in df.groupby('Percepció'): multiplicador = percepcion_margen.get(perception, 1.0) # Calcular un margen inicial ajustado por percepción grupo['Margen por Unidad'] = grupo['Costo neto'] * multiplicador * porcentaje_maximo_margen grupo['Margen por Unidad'] = np.clip(grupo['Margen por Unidad'], margen_minimo_por_unidad, margen_maximo_por_unidad) # Aplicar la nueva restricción de margen basado en PVP NEX limite_margen_percepcion = limites_margen.get(perception).get() for idx, row in grupo.iterrows(): if pd.notna(row['PVP NEX']) and row['PVP NEX'] > 0: pvp_final = row['Costo neto'] + row['Margen por Unidad'] diferencia = row['PVP NEX'] - pvp_final # Ajustar el margen para asegurar que la diferencia esté dentro del rango permitido if diferencia < 0 or diferencia > limite_margen_percepcion: margen_ajuste = min(max(0, diferencia), limite_margen_percepcion) nuevo_pvp_final = row['PVP NEX'] - margen_ajuste grupo.at[idx, 'Margen por Unidad'] = max(0, nuevo_pvp_final - row['Costo neto']) grupo['Check'] = np.where(grupo['PVP NEX'] > 0, grupo['Costo neto'] + grupo['Margen por Unidad'] - grupo['PVP NEX'], np.nan) df_resultado = pd.concat([df_resultado, grupo]) margen_promedio_ponderado_final = (df_resultado['Margen por Unidad'] * df_resultado['Unitats 2024']).sum() / df_resultado['Unitats 2024'].sum() return df_resultado, margen_promedio_ponderado_final def ejecutar_calculo(margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max, window): try: margen_minimo = validar_entrada(margen_minimo) margen_maximo = validar_entrada(margen_maximo) porcentaje_margen = validar_entrada(porcentaje_margen) margen_min = validar_entrada(margen_min) margen_max = validar_entrada(margen_max) df_ajustado, margen_promedio = calcular_margen( df, margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max ) messagebox.showinfo("Resultado", f"Margen promedio ponderado final: {margen_promedio:.2f}") # Guardar el archivo file_path = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx")]) if file_path: # Crear un libro de Excel y exportar el DataFrame wb = Workbook() ws = wb.active ws.title = "Datos Ajustados" # Convertir DataFrame a filas de Excel for r in dataframe_to_rows(df_ajustado, index=False, header=True): ws.append(r) # Estilizar la primera fila como encabezado encabezado_estilo = NamedStyle(name="encabezado_estilo", font=Font(bold=True)) for cell in ws[1]: cell.style = encabezado_estilo # Crear un gráfico de barras que muestra la relación de las unidades por margen c1 = BarChart() c1.type = "col" c1.style = 10 c1.title = "Unidades por Margen" c1.y_axis.title = 'Unidades 2024' c1.x_axis.title = 'Referencia' datos = Reference(ws, min_col=6, min_row=1, max_row=ws.max_row, max_col=7) c1.add_data(datos, titles_from_data=True) referencias = Reference(ws, min_col=1, min_row=2, max_row=ws.max_row) c1.set_categories(referencias) ws.add_chart(c1, "J2") # Guardar el archivo Excel wb.save(file_path) messagebox.showinfo("Guardado", "Archivo guardado exitosamente.") except ValueError as e: messagebox.showerror("Error de Validación", str(e)) except Exception as e: messagebox.showerror("Error", f"Error en el cálculo: {str(e)}") finally: window.destroy() # Crear la interfaz gráfica de usuario app = tk.Tk() app.title("Calculadora de Márgenes") # Botones para la configuración de límites y parámetros tk.Button(app, text="Configurar Límites de Margen", command=abrir_limites_margen).pack(pady=10) tk.Button(app, text="Configurar Parámetros de Cálculo", command=crear_ventana_parametros).pack(pady=10) # Ejecutar la aplicación app.mainloop()Explicación del Código:
- Tkinter UI: Se usa para seleccionar parámetros de cálculo y aplicar límites según la percepción del producto.
- Pandas y NumPy: Realizan cálculos complejos sobre el DataFrame cargado desde el archivo de Excel.
- OpenPyXL: Crea un nuevo archivo de Excel con los resultados, estilo de tablas mejorado, y un gráfico de barras simple que muestra la relación entre las unidades proyectadas para 2024 y el margen calculado.
Puedes necesitar ajustar las columnas y los nombres de las columnas utilizadas al igual que la ruta del archivo y las configuraciones según tus datos reales. Al ejecutar el programa, se abrirá una interfaz gráfica donde puedes ajustar los parámetros, realizar cálculos, y finalmente guardar estos resultados en un archivo Excel elegante y comprensible para la presentación.
- User
Cell In[1], line 87 Características Mejoradas Propuestas: ^ SyntaxError: invalid syntax
- Assistant
Mis disculpas, parece que hubo un error de copiado. Vamos a corregir el enfoque y asegurarnos de que el código sea funcional sin errores de sintaxis. La descripción anterior fue simplemente un comentario sobre el código, por lo que debería estar separado del código ejecutable. A continuación, te proporciono el código corregido y funcional:
import pandas as pd import numpy as np import tkinter as tk from tkinter import messagebox from tkinter import filedialog from openpyxl import Workbook from openpyxl.utils.dataframe import dataframe_to_rows from openpyxl.chart import BarChart, Reference from openpyxl.styles import Font from openpyxl.styles import NamedStyle # Cargar la hoja "Data" en un DataFrame # Reemplaza esta ruta con la ubicación de tu archivo file_path = r'C:\path\to\your\file.xlsx' df = pd.read_excel(file_path, sheet_name='Data', engine='openpyxl') # Diccionario de multiplicadores de percepción percepcion_margen = { 'Top Gama': 1.3, 'Premium': 1.2, 'Regular': 1.1, 'Budget': 1.0, 'Low Cost': 0.9 } # Límites de margen por percepción (vinculado con la nueva UI) limites_margen = { 'Top Gama': tk.DoubleVar(value=2.0), 'Premium': tk.DoubleVar(value=2.0), 'Regular': tk.DoubleVar(value=1.5), 'Budget': tk.DoubleVar(value=1.5), 'Low Cost': tk.DoubleVar(value=1.0) } def abrir_limites_margen(): """Función para abrir el submenú y configurar los límites de margen por percepción""" limite_window = tk.Toplevel(app) limite_window.title("Límites de Margen por Percepción") tk.Label(limite_window, text="Configura los límites de margen para cada percepción:").grid(row=0, columnspan=2, pady=5) row_num = 1 for percepcion, limite_var in limites_margen.items(): tk.Label(limite_window, text=f"Límite para {percepcion}:").grid(row=row_num, column=0, pady=5) tk.Entry(limite_window, textvariable=limite_var).grid(row=row_num, column=1, pady=5) row_num += 1 tk.Button(limite_window, text="Confirmar", command=limite_window.destroy).grid(row=row_num, columnspan=2, pady=10) def crear_ventana_parametros(): param_window = tk.Toplevel(app) param_window.title("Parámetros de Cálculo de Márgenes") # Entradas y etiquetas para los diferentes parámetros de margen tk.Label(param_window, text="Margen Mínimo por Unidad:").grid(row=0, column=0, pady=5) margen_minimo_entry = tk.Entry(param_window) margen_minimo_entry.grid(row=0, column=1, pady=5) margen_minimo_entry.insert(0, "10") tk.Label(param_window, text="Margen Máximo por Unidad:").grid(row=1, column=0, pady=5) margen_maximo_entry = tk.Entry(param_window) margen_maximo_entry.grid(row=1, column=1, pady=5) margen_maximo_entry.insert(0, "25") tk.Label(param_window, text="Porcentaje Máximo Margen:").grid(row=2, column=0, pady=5) porcentaje_margen_entry = tk.Entry(param_window) porcentaje_margen_entry.grid(row=2, column=1, pady=5) porcentaje_margen_entry.insert(0, "0.35") tk.Label(param_window, text="Margen Objetivo Mínimo:").grid(row=3, column=0, pady=5) margen_min_entry = tk.Entry(param_window) margen_min_entry.grid(row=3, column=1, pady=5) margen_min_entry.insert(0, "16") tk.Label(param_window, text="Margen Objetivo Máximo:").grid(row=4, column=0, pady=5) margen_max_entry = tk.Entry(param_window) margen_max_entry.grid(row=4, column=1, pady=5) margen_max_entry.insert(0, "17") tk.Button(param_window, text="Calcular", command=lambda: ejecutar_calculo( margen_minimo_entry.get(), margen_maximo_entry.get(), porcentaje_margen_entry.get(), margen_min_entry.get(), margen_max_entry.get(), param_window)).grid(row=5, columnspan=2, pady=10) def validar_entrada(valor): """Función para validar entradas numéricas""" try: val = float(valor) if val < 0: raise ValueError return val except ValueError: raise ValueError("Por favor, introduce un número válido y mayor o igual a cero.") # Método para calcular los márgenes ajustados def calcular_margen(df, margen_minimo_por_unidad, margen_maximo_por_unidad, porcentaje_maximo_margen, margen_objetivo_min, margen_objetivo_max): df_resultado = pd.DataFrame() margen_objetivo_promedio = (margen_objetivo_min + margen_objetivo_max) / 2 # Comprobación de la existencia de columnas necesarias for column in ['Percepció', 'Costo neto', 'Unitats 2024', 'PVP NEX']: if column not in df.columns: raise ValueError(f"La columna '{column}' no se encuentra en el DataFrame.") for perception, grupo in df.groupby('Percepció'): multiplicador = percepcion_margen.get(perception, 1.0) # Calcular un margen inicial ajustado por percepción grupo['Margen por Unidad'] = grupo['Costo neto'] * multiplicador * porcentaje_maximo_margen grupo['Margen por Unidad'] = np.clip(grupo['Margen por Unidad'], margen_minimo_por_unidad, margen_maximo_por_unidad) # Aplicar la nueva restricción de margen basado en PVP NEX limite_margen_percepcion = limites_margen.get(perception).get() for idx, row in grupo.iterrows(): if pd.notna(row['PVP NEX']) and row['PVP NEX'] > 0: pvp_final = row['Costo neto'] + row['Margen por Unidad'] diferencia = row['PVP NEX'] - pvp_final # Ajustar el margen para asegurar que la diferencia esté dentro del rango permitido if diferencia < 0 or diferencia > limite_margen_percepcion: margen_ajuste = min(max(0, diferencia), limite_margen_percepcion) nuevo_pvp_final = row['PVP NEX'] - margen_ajuste grupo.at[idx, 'Margen por Unidad'] = max(0, nuevo_pvp_final - row['Costo neto']) grupo['Check'] = np.where(grupo['PVP NEX'] > 0, grupo['Costo neto'] + grupo['Margen por Unidad'] - grupo['PVP NEX'], np.nan) df_resultado = pd.concat([df_resultado, grupo]) margen_promedio_ponderado_final = (df_resultado['Margen por Unidad'] * df_resultado['Unitats 2024']).sum() / df_resultado['Unitats 2024'].sum() return df_resultado, margen_promedio_ponderado_final def ejecutar_calculo(margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max, window): try: margen_minimo = validar_entrada(margen_minimo) margen_maximo = validar_entrada(margen_maximo) porcentaje_margen = validar_entrada(porcentaje_margen) margen_min = validar_entrada(margen_min) margen_max = validar_entrada(margen_max) df_ajustado, margen_promedio = calcular_margen( df, margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max ) messagebox.showinfo("Resultado", f"Margen promedio ponderado final: {margen_promedio:.2f}") # Guardar archivo file_path = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx")]) if file_path: # Crear el libro de Excel y exportar el DataFrame wb = Workbook() ws = wb.active ws.title = "Datos Ajustados" # Convertir el DataFrame a filas de Excel for r in dataframe_to_rows(df_ajustado, index=False, header=True): ws.append(r) # Aplicar estilo al encabezado encabezado_estilo = NamedStyle(name="encabezado_estilo", font=Font(bold=True)) for cell in ws[1]: cell.style = encabezado_estilo # Crear un gráfico de barras c1 = BarChart() c1.type = "col" c1.style = 10 c1.title = "Unidades por Margen" c1.y_axis.title = 'Unidades 2024' c1.x_axis.title = 'Referencia' datos = Reference(ws, min_col=6, min_row=1, max_row=ws.max_row, max_col=7) c1.add_data(datos, titles_from_data=True) referencias = Reference(ws, min_col=1, min_row=2, max_row=ws.max_row) c1.set_categories(referencias) ws.add_chart(c1, "J2") # Guardar el archivo Excel wb.save(file_path) messagebox.showinfo("Guardado", "Archivo guardado exitosamente.") except ValueError as e: messagebox.showerror("Error de Validación", str(e)) except Exception as e: messagebox.showerror("Error", f"Error en el cálculo: {str(e)}") finally: window.destroy() # Crear la interfaz gráfica de usuario app = tk.Tk() app.title("Calculadora de Márgenes") # Botones para la configuración de límites y parámetros tk.Button(app, text="Configurar Límites de Margen", command=abrir_limites_margen).pack(pady=10) tk.Button(app, text="Configurar Parámetros de Cálculo", command=crear_ventana_parametros).pack(pady=10) # Ejecutar la aplicación app.mainloop()Instrucciones de Uso:
- Ruta de Archivo: Asegúrate de cambiar la variable
file_patha la ubicación de tu archivo de Excel. - Interfaz de Usuario: Al ejecutar, la GUI de Tkinter te permitirá ajustar parámetros y límites para calcular márgenes.
- Exportación: Los cálculos se guardan en un nuevo archivo de Excel junto con un gráfico de barras.
Este código combina la lógica de cálculo y una interfaz de usuario para personalizar los parámetros, brindando un resultado visual en un archivo de Excel.
- Ruta de Archivo: Asegúrate de cambiar la variable
- User
FileNotFoundError Traceback (most recent call last) Cell In[3], line 15 12 # Cargar la hoja "Data" en un DataFrame 13 # Reemplaza esta ruta con la ubicación de tu archivo 14 file_path = r'C:\path\to\your\file.xlsx' ---> 15 df = pd.read_excel(file_path, sheet_name='Data', engine='openpyxl') 17 # Diccionario de multiplicadores de percepción 18 percepcion_margen = { 19 'Top Gama': 1.3, 20 'Premium': 1.2, (...) 23 'Low Cost': 0.9 24 }
File ~\AppData\Local\anaconda3\Lib\site-packages\pandas\io\excel_base.py:495, in read_excel(io, sheet_name, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skiprows, nrows, na_values, keep_default_na, na_filter, verbose, parse_dates, date_parser, date_format, thousands, decimal, comment, skipfooter, storage_options, dtype_backend, engine_kwargs) 493 if not isinstance(io, ExcelFile): 494 should_close = True --> 495 io = ExcelFile( 496 io, 497 storage_options=storage_options, 498 engine=engine, 499 engine_kwargs=engine_kwargs, 500 ) 501 elif engine and engine != io.engine: 502 raise ValueError( 503 "Engine should not be specified when passing " 504 "an ExcelFile - ExcelFile already has the engine set" 505 )
File ~\AppData\Local\anaconda3\Lib\site-packages\pandas\io\excel_base.py:1567, in ExcelFile.init(self, path_or_buffer, engine, storage_options, engine_kwargs) 1564 self.engine = engine 1565 self.storage_options = storage_options -> 1567 self._reader = self._engines[engine]( 1568 self._io, 1569 storage_options=storage_options, 1570 engine_kwargs=engine_kwargs, 1571 )
File ~\AppData\Local\anaconda3\Lib\site-packages\pandas\io\excel_openpyxl.py:553, in OpenpyxlReader.init(self, filepath_or_buffer, storage_options, engine_kwargs) 541 """ 542 Reader using openpyxl engine. 543 (...) 550 Arbitrary keyword arguments passed to excel engine. 551 """ 552 import_optional_dependency("openpyxl") --> 553 super().init( 554 filepath_or_buffer, 555 storage_options=storage_options, 556 engine_kwargs=engine_kwargs, 557 )
File ~\AppData\Local\anaconda3\Lib\site-packages\pandas\io\excel_base.py:563, in BaseExcelReader.init(self, filepath_or_buffer, storage_options, engine_kwargs) 559 self.handles = IOHandles( 560 handle=filepath_or_buffer, compression={"method": None} 561 ) 562 if not isinstance(filepath_or_buffer, (ExcelFile, self._workbook_class)): --> 563 self.handles = get_handle( 564 filepath_or_buffer, "rb", storage_options=storage_options, is_text=False 565 ) 567 if isinstance(self.handles.handle, self._workbook_class): 568 self.book = self.handles.handle
File ~\AppData\Local\anaconda3\Lib\site-packages\pandas\io\common.py:882, in get_handle(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options) 873 handle = open( 874 handle, 875 ioargs.mode, (...) 878 newline="", 879 ) 880 else: 881 # Binary mode --> 882 handle = open(handle, ioargs.mode) 883 handles.append(handle) 885 # Convert BytesIO or file objects passed with an encoding
FileNotFoundError: [Errno 2] No such file or directory: 'C:\path\to\your\file.xlsx'
- Assistant
El error
FileNotFoundErrorindica que el programa no pudo encontrar el archivo de Excel en la ubicación especificada. Esto sucede porque la ruta'C:\path\to\your\file.xlsx'es solo un marcador de posición. Necesitas reemplazar esta ruta con la ruta real del archivo de Excel que deseas utilizar.A continuación te muestro cómo podrías ajustar el código para manejar correctamente el archivo y también cómo permitir que el usuario seleccione el archivo mediante un diálogo si lo deseas:
Opción 1: Cambiar la Ruta del Archivo
Reemplaza la línea donde se define
file_pathcon la ruta real del archivo de Excel en tu sistema:file_path = r'C:\Users\TuUsuario\Documents\TuArchivo.xlsx'Asegúrate de que el nombre del archivo y la extensión sean correctos y que el archivo se encuentre en esa ubicación.
Opción 2: Uso de
filedialogpara Seleccionar el ArchivoSi prefieres que el usuario seleccione el archivo a través de un diálogo, puedes usar
filedialog.askopenfilename()para seleccionar el archivo. Así, el programa no dependerá de una ruta escrita en el código:import pandas as pd import numpy as np import tkinter as tk from tkinter import messagebox from tkinter import filedialog from openpyxl import Workbook from openpyxl.utils.dataframe import dataframe_to_rows from openpyxl.chart import BarChart, Reference from openpyxl.styles import Font from openpyxl.styles import NamedStyle # Crear la interfaz gráfica de usuario app = tk.Tk() app.withdraw() # Ocultar la ventana principal de Tkinter # Abrir el diálogo para seleccionar el archivo file_path = filedialog.askopenfilename(filetypes=[("Excel files", "*.xlsx")]) if not file_path: raise FileNotFoundError("No se seleccionó ningún archivo.") # Cargar la hoja "Data" en un DataFrame df = pd.read_excel(file_path, sheet_name='Data', engine='openpyxl') # Diccionario de multiplicadores de percepción percepcion_margen = { 'Top Gama': 1.3, 'Premium': 1.2, 'Regular': 1.1, 'Budget': 1.0, 'Low Cost': 0.9 } # Límites de margen por percepción (vinculado con la nueva UI) limites_margen = { 'Top Gama': tk.DoubleVar(value=2.0), 'Premium': tk.DoubleVar(value=2.0), 'Regular': tk.DoubleVar(value=1.5), 'Budget': tk.DoubleVar(value=1.5), 'Low Cost': tk.DoubleVar(value=1.0) } # El resto del código se mantiene igual def abrir_limites_margen(): # Función preexistente que configura los márgenes... pass # Continuar el resto de la implementación como antes... # Rehabilitar la creación de la ventana principal app.deiconify() # Añadir el resto del código tal como se configuró antes # ... # Botones para la configuración de límites y parámetros tk.Button(app, text="Configurar Límites de Margen", command=abrir_limites_margen).pack(pady=10) tk.Button(app, text="Configurar Parámetros de Cálculo", command=crear_ventana_parametros).pack(pady=10) # Ejecutar la aplicación app.mainloop()En este ajuste, la aplicación comienza por mostrar un diálogo que permite al usuario seleccionar cualquier archivo de Excel. Esto garantiza que no se dependa de una ruta codificada, adaptando el programa a diversos entornos y usuarios.
- User
a este codigo : import pandas as pd import numpy as np import tkinter as tk from tkinter import messagebox from tkinter import filedialog
def abrir_limites_margen(): """Función para abrir el submenú y configurar los límites de margen por percepción""" limite_window = tk.Toplevel(app) limite_window.title("Límites de Margen por Percepción")
tk.Label(limite_window, text="Configura los límites de margen para cada percepción:").grid(row=0, columnspan=2, pady=5) row_num = 1 for percepcion, limite_var in limites_margen.items(): tk.Label(limite_window, text=f"Límite para {percepcion}:").grid(row=row_num, column=0, pady=5) tk.Entry(limite_window, textvariable=limite_var).grid(row=row_num, column=1, pady=5) row_num += 1 tk.Button(limite_window, text="Confirmar", command=limite_window.destroy).grid(row=row_num, columnspan=2, pady=10)def crear_ventana_parametros(): param_window = tk.Toplevel(app) param_window.title("Parámetros de Cálculo de Márgenes")
# Entradas y etiquetas para los diferentes parámetros de margen tk.Label(param_window, text="Margen Mínimo por Unidad:").grid(row=0, column=0, pady=5) margen_minimo_entry = tk.Entry(param_window) margen_minimo_entry.grid(row=0, column=1, pady=5) margen_minimo_entry.insert(0, "10") tk.Label(param_window, text="Margen Máximo por Unidad:").grid(row=1, column=0, pady=5) margen_maximo_entry = tk.Entry(param_window) margen_maximo_entry.grid(row=1, column=1, pady=5) margen_maximo_entry.insert(0, "25") tk.Label(param_window, text="Porcentaje Máximo Margen:").grid(row=2, column=0, pady=5) porcentaje_margen_entry = tk.Entry(param_window) porcentaje_margen_entry.grid(row=2, column=1, pady=5) porcentaje_margen_entry.insert(0, "0.35") tk.Label(param_window, text="Margen Objetivo Mínimo:").grid(row=3, column=0, pady=5) margen_min_entry = tk.Entry(param_window) margen_min_entry.grid(row=3, column=1, pady=5) margen_min_entry.insert(0, "16") tk.Label(param_window, text="Margen Objetivo Máximo:").grid(row=4, column=0, pady=5) margen_max_entry = tk.Entry(param_window) margen_max_entry.grid(row=4, column=1, pady=5) margen_max_entry.insert(0, "17") tk.Button(param_window, text="Calcular", command=lambda: ejecutar_calculo( margen_minimo_entry.get(), margen_maximo_entry.get(), porcentaje_margen_entry.get(), margen_min_entry.get(), margen_max_entry.get(), param_window)).grid(row=5, columnspan=2, pady=10)def validar_entrada(valor): """Función para validar entradas numéricas""" try: val = float(valor) if val < 0: raise ValueError return val except ValueError: raise ValueError("Por favor, introduce un número válido y mayor o igual a cero.")
Método para calcular los márgenes ajustados
def calcular_margen(df, margen_minimo_por_unidad, margen_maximo_por_unidad, porcentaje_maximo_margen, margen_objetivo_min, margen_objetivo_max): df_resultado = pd.DataFrame() margen_objetivo_promedio = (margen_objetivo_min + margen_objetivo_max) / 2
# Comprobación de la existencia de columnas necesarias for column in ['Percepció', 'Costo neto', 'Unitats 2024', 'PVP NEX']: if column not in df.columns: raise ValueError(f"La columna '{column}' no se encuentra en el DataFrame.") for perception, grupo in df.groupby('Percepció'): multiplicador = percepcion_margen.get(perception, 1.0) # Calcular un margen inicial ajustado por percepción grupo['Margen por Unidad'] = grupo['Costo neto'] * multiplicador * porcentaje_maximo_margen grupo['Margen por Unidad'] = np.clip(grupo['Margen por Unidad'], margen_minimo_por_unidad, margen_maximo_por_unidad) # Aplicar la nueva restricción de margen basado en PVP NEX limite_margen_percepcion = limites_margen.get(perception).get() for idx, row in grupo.iterrows(): if pd.notna(row['PVP NEX']) and row['PVP NEX'] > 0: pvp_final = row['Costo neto'] + row['Margen por Unidad'] diferencia = row['PVP NEX'] - pvp_final # Ajustar el margen para asegurar que la diferencia esté dentro del rango permitido if diferencia < 0 or diferencia > limite_margen_percepcion: margen_ajuste = min(max(0, diferencia), limite_margen_percepcion) nuevo_pvp_final = row['PVP NEX'] - margen_ajuste grupo.at[idx, 'Margen por Unidad'] = max(0, nuevo_pvp_final - row['Costo neto']) grupo['Check'] = np.where(grupo['PVP NEX'] > 0, grupo['Costo neto'] + grupo['Margen por Unidad'] - grupo['PVP NEX'], np.nan) df_resultado = pd.concat([df_resultado, grupo]) margen_promedio_ponderado_final = (df_resultado['Margen por Unidad'] * df_resultado['Unitats 2024']).sum() / df_resultado['Unitats 2024'].sum() return df_resultado, margen_promedio_ponderado_finaldef ejecutar_calculo(margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max, window): try: margen_minimo = validar_entrada(margen_minimo) margen_maximo = validar_entrada(margen_maximo) porcentaje_margen = validar_entrada(porcentaje_margen) margen_min = validar_entrada(margen_min) margen_max = validar_entrada(margen_max)
df_ajustado, margen_promedio = calcular_margen( df, margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max ) messagebox.showinfo("Resultado", f"Margen promedio ponderado final: {margen_promedio:.2f}") # Guardar el archivo file_path = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx")]) if file_path: with pd.ExcelWriter(file_path, engine='openpyxl') as writer: df_ajustado.to_excel(writer, sheet_name='Datos Ajustados', index=False) messagebox.showinfo("Guardado", "Archivo guardado exitosamente.") except ValueError as e: messagebox.showerror("Error de Validación", str(e)) except Exception as e: messagebox.showerror("Error", f"Error en el cálculo: {str(e)}") finally: window.destroy()Crear la interfaz gráfica de usuario primero
app = tk.Tk() app.title("Calculadora de Márgenes")
Definir la ruta al archivo Excel
file_path = r'C:\Users\ismael.gallardo\Documents\Tabla de comparación neumáticos €.xlsx'
Cargar la hoja "Data" en un DataFrame
df = pd.read_excel(file_path, sheet_name='Data', engine='openpyxl')
Imprimir columnas disponibles para verificar nombres
print("Columnas en el DataFrame:") print(df.columns)
Definiciones de percepción de margen
percepcion_margen = { 'Top Gama': 1.3, 'Premium': 1.2, 'Regular': 1.1, 'Budget': 1.0, 'Low Cost': 0.9 }
Límites de margen por percepción (vinculado con la nueva UI)
limites_margen = { 'Top Gama': tk.DoubleVar(value=2.0), 'Premium': tk.DoubleVar(value=2.0), 'Regular': tk.DoubleVar(value=1.5), 'Budget': tk.DoubleVar(value=1.5), 'Low Cost': tk.DoubleVar(value=1.0) }
Creación del menú inicial con botones para las dos configuraciones
tk.Button(app, text="Configurar Límites de Margen", command=abrir_limites_margen).pack(pady=10) tk.Button(app, text="Configurar Parámetros de Cálculo", command=crear_ventana_parametros).pack(pady=10)
Ejecutar la aplicación
app.mainloop()
me gustaria añadir una tercera Funcionalidad final una vez ejecutamos el "calclular" en el programa te debe preguntar si quieres hacer un analisis de las ventas si le dices que"SI" debe generar una pestaña nueva con un analisis de las referencias según sus ventas utilizando PVP Oferta, PVP NEX y PVP NEW = ( Costo neto + Margen por Unidad) tambien hay que analizar por referencia los margenes actuales= PVP Oferta - Coste Neto y comparar con el Margen por Unidad calculado por el programa . Estos dos analisis tienen que tener en en cuenta la Percepció , Marca , Mesuras i Unitats 2024 y hay que buscar conclusiones y/o cluster que nos ayuden a mejor el pricing para incrementar las ventas Unitats 2024. Es importarte que este analisis sea muy visual
- Assistant
Para implementar esta funcionalidad adicional que deseas, puedes integrar un paso después del cálculo actual que ofrezca realizar un análisis más detallado. Esto incluiría la creación de nuevas hojas en Excel para visualizar los datos de ventas y márgenes de manera más visible. Para esto, podríamos usar
openpyxlpara manejar las funcionalidades avanzadas de Excel.A continuación, te muestro cómo puedes añadir esta funcionalidad al código existente:
import pandas as pd import numpy as np import tkinter as tk from tkinter import messagebox from tkinter import filedialog from openpyxl import Workbook from openpyxl.utils.dataframe import dataframe_to_rows from openpyxl.chart import BarChart, Reference def abrir_limites_margen(): limite_window = tk.Toplevel(app) limite_window.title("Límites de Margen por Percepción") tk.Label(limite_window, text="Configura los límites de margen para cada percepción:").grid(row=0, columnspan=2, pady=5) row_num = 1 for percepcion, limite_var in limites_margen.items(): tk.Label(limite_window, text=f"Límite para {percepcion}:").grid(row=row_num, column=0, pady=5) tk.Entry(limite_window, textvariable=limite_var).grid(row=row_num, column=1, pady=5) row_num += 1 tk.Button(limite_window, text="Confirmar", command=limite_window.destroy).grid(row=row_num, columnspan=2, pady=10) def crear_ventana_parametros(): param_window = tk.Toplevel(app) param_window.title("Parámetros de Cálculo de Márgenes") tk.Label(param_window, text="Margen Mínimo por Unidad:").grid(row=0, column=0, pady=5) margen_minimo_entry = tk.Entry(param_window) margen_minimo_entry.grid(row=0, column=1, pady=5) margen_minimo_entry.insert(0, "10") tk.Label(param_window, text="Margen Máximo por Unidad:").grid(row=1, column=0, pady=5) margen_maximo_entry = tk.Entry(param_window) margen_maximo_entry.grid(row=1, column=1, pady=5) margen_maximo_entry.insert(0, "25") tk.Label(param_window, text="Porcentaje Máximo Margen:").grid(row=2, column=0, pady=5) porcentaje_margen_entry = tk.Entry(param_window) porcentaje_margen_entry.grid(row=2, column=1, pady=5) porcentaje_margen_entry.insert(0, "0.35") tk.Label(param_window, text="Margen Objetivo Mínimo:").grid(row=3, column=0, pady=5) margen_min_entry = tk.Entry(param_window) margen_min_entry.grid(row=3, column=1, pady=5) margen_min_entry.insert(0, "16") tk.Label(param_window, text="Margen Objetivo Máximo:").grid(row=4, column=0, pady=5) margen_max_entry = tk.Entry(param_window) margen_max_entry.grid(row=4, column=1, pady=5) margen_max_entry.insert(0, "17") tk.Button(param_window, text="Calcular", command=lambda: ejecutar_calculo( margen_minimo_entry.get(), margen_maximo_entry.get(), porcentaje_margen_entry.get(), margen_min_entry.get(), margen_max_entry.get(), param_window)).grid(row=5, columnspan=2, pady=10) def validar_entrada(valor): try: val = float(valor) if val < 0: raise ValueError return val except ValueError: raise ValueError("Por favor, introduce un número válido y mayor o igual a cero.") def calcular_margen(df, margen_minimo_por_unidad, margen_maximo_por_unidad, porcentaje_maximo_margen, margen_objetivo_min, margen_objetivo_max): df_resultado = pd.DataFrame() margen_objetivo_promedio = (margen_objetivo_min + margen_objetivo_max) / 2 for column in ['Percepció', 'Costo neto', 'Unitats 2024', 'PVP NEX']: if column not in df.columns: raise ValueError(f"La columna '{column}' no se encuentra en el DataFrame.") for perception, grupo in df.groupby('Percepció'): multiplicador = percepcion_margen.get(perception, 1.0) grupo['Margen por Unidad'] = grupo['Costo neto'] * multiplicador * porcentaje_maximo_margen grupo['Margen por Unidad'] = np.clip(grupo['Margen por Unidad'], margen_minimo_por_unidad, margen_maximo_por_unidad) limite_margen_percepcion = limites_margen.get(perception).get() for idx, row in grupo.iterrows(): if pd.notna(row['PVP NEX']) and row['PVP NEX'] > 0: pvp_final = row['Costo neto'] + row['Margen por Unidad'] diferencia = row['PVP NEX'] - pvp_final if diferencia < 0 or diferencia > limite_margen_percepcion: margen_ajuste = min(max(0, diferencia), limite_margen_percepcion) nuevo_pvp_final = row['PVP NEX'] - margen_ajuste grupo.at[idx, 'Margen por Unidad'] = max(0, nuevo_pvp_final - row['Costo neto']) grupo['Check'] = np.where(grupo['PVP NEX'] > 0, grupo['Costo neto'] + grupo['Margen por Unidad'] - grupo['PVP NEX'], np.nan) df_resultado = pd.concat([df_resultado, grupo]) margen_promedio_ponderado_final = (df_resultado['Margen por Unidad'] * df_resultado['Unitats 2024']).sum() / df_resultado['Unitats 2024'].sum() return df_resultado, margen_promedio_ponderado_final def analizar_ventas(df_ajustado): # Calcula PVP NEW y el margen actual df_ajustado['PVP NEW'] = df_ajustado['Costo neto'] + df_ajustado['Margen por Unidad'] df_ajustado['Margen Actual'] = df_ajustado['PVP Oferta'] - df_ajustado['Costo neto'] # Guarda el resultado en un nuevo archivo Excel file_path = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx")]) if file_path: with pd.ExcelWriter(file_path, engine='openpyxl') as writer: df_ajustado.to_excel(writer, sheet_name='Datos Ajustados', index=False) # Añadir análisis de ventas wb = writer.book ws_analisis = wb.create_sheet(title='Analisis Ventas') # Pasa todos los datos al nuevo sheet for r in dataframe_to_rows(df_ajustado, index=False, header=True): ws_analisis.append(r) # Añadir un gráfico chart = BarChart() chart.type = "col" chart.title = "Análisis de Ventas" chart.y_axis.title = 'Unidades' chart.x_axis.title = 'Referencias' data = Reference(ws_analisis, min_col=3, min_row=1, max_row=ws_analisis.max_row, max_col=3) chart.add_data(data, titles_from_data=True) ws_analisis.add_chart(chart, "I10") writer.save() messagebox.showinfo("Guardado", f"Archivo de análisis guardado exitosamente en {file_path}.") def ejecutar_calculo(margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max, window): try: margen_minimo = validar_entrada(margen_minimo) margen_maximo = validar_entrada(margen_maximo) porcentaje_margen = validar_entrada(porcentaje_margen) margen_min = validar_entrada(margen_min) margen_max = validar_entrada(margen_max) df_ajustado, margen_promedio = calcular_margen( df, margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max ) messagebox.showinfo("Resultado", f"Margen promedio ponderado final: {margen_promedio:.2f}") # Preguntar si hacer análisis de ventas if messagebox.askyesno("Análisis de Ventas", "¿Desea realizar un análisis de ventas y márgenes?"): analizar_ventas(df_ajustado) except ValueError as e: messagebox.showerror("Error de Validación", str(e)) except Exception as e: messagebox.showerror("Error", f"Error en el cálculo: {str(e)}") finally: window.destroy() # Crear la interfaz gráfica de usuario app = tk.Tk() app.title("Calculadora de Márgenes") # Cargar el archivo de Excel (deberás actualizar la ruta) file_path = r'C:\Users\ismael.gallardo\Documents\Tabla de comparación neumáticos €.xlsx' df = pd.read_excel(file_path, sheet_name='Data', engine='openpyxl') percepcion_margen = { 'Top Gama': 1.3, 'Premium': 1.2, 'Regular': 1.1, 'Budget': 1.0, 'Low Cost': 0.9 } limites_margen = { 'Top Gama': tk.DoubleVar(value=2.0), 'Premium': tk.DoubleVar(value=2.0), 'Regular': tk.DoubleVar(value=1.5), 'Budget': tk.DoubleVar(value=1.5), 'Low Cost': tk.DoubleVar(value=1.0) } # Añade botones para la configuración tk.Button(app, text="Configurar Límites de Margen", command=abrir_limites_margen).pack(pady=10) tk.Button(app, text="Configurar Parámetros de Cálculo", command=crear_ventana_parametros).pack(pady=10) # Iniciar la aplicación app.mainloop()Resumen de Cambios:
-
Análisis de Ventas:
- Se añade una función
analizar_ventasque se encarga de crear un análisis visual de los datos, aumentando el detalle de los márgenes y usando al menos dos métricas (PVP NEX, PVP NEW).
- Se añade una función
-
Gráfico Visual:
- Un gráfico de barras que muestra las unidades con respecto a las referencias para ayudar a visualizar rápidamente los datos en el análisis.
-
Confirmación Adicional:
- Luego de que se calculan los márgenes, se pregunta si se desea realizar el análisis de ventas, ofreciéndose guardar este análisis en un archivo Excel.
Este script debe ser adaptado para verificar que los nombres de las columnas (
Percepció,Costo neto,Unitats 2024, etc.) corresponden exactamente a tus datos y ajustar según necesites. -
- User
al guardar me dice Error en calculo: OpenpyxlWriter object has no attribute 'save'
- Assistant
El error
OpenpyxlWriter object has no attribute 'save'indica que el métodosave()no es necesario ni válido cuando se utiliza un contexto de administrador (comowith) para manejar el archivo de Excel enpandas.ExcelWriter. Esto se debe a que el contexto se encarga automáticamente de cerrar y guardar el archivo una vez que sales del bloquewith.Puedes corregir este error eliminando la llamada a
writer.save()dentro del bloquewith. A continuación te muestro cómo debería lucir la funciónanalizar_ventas:def analizar_ventas(df_ajustado): # Calcula PVP NEW y el margen actual df_ajustado['PVP NEW'] = df_ajustado['Costo neto'] + df_ajustado['Margen por Unidad'] df_ajustado['Margen Actual'] = df_ajustado['PVP Oferta'] - df_ajustado['Costo neto'] # Guarda el resultado en un nuevo archivo Excel file_path = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx")]) if file_path: with pd.ExcelWriter(file_path, engine='openpyxl') as writer: df_ajustado.to_excel(writer, sheet_name='Datos Ajustados', index=False) # Añadir análisis de ventas wb = writer.book ws_analisis = wb.create_sheet(title='Analisis Ventas') # Pasa todos los datos al nuevo sheet for r in dataframe_to_rows(df_ajustado, index=False, header=True): ws_analisis.append(r) # Añadir un gráfico chart = BarChart() chart.type = "col" chart.title = "Análisis de Ventas" chart.y_axis.title = 'Unidades' chart.x_axis.title = 'Referencias' data = Reference(ws_analisis, min_col=3, min_row=1, max_row=ws_analisis.max_row, max_col=3) chart.add_data(data, titles_from_data=True) ws_analisis.add_chart(chart, "I10") messagebox.showinfo("Guardado", f"Archivo de análisis guardado exitosamente en {file_path}.")Resumen de Cambios:
- Eliminar
writer.save(): La gestión del guardado ya está implícita al salir del bloquewith.
Así, al ejecutar
analizar_ventas, el archivo será adecuadamente guardado y cerrado sin necesidad de llamadas adicionales al métodosave()sobre el objetoExcelWriter. - Eliminar
- User
añadir esta solución al codigo
- Assistant
Integraré la corrección que discutimos en el código completo. Se eliminará la llamada a
writer.save()en la funciónanalizar_ventas, ya quepandas.ExcelWriterse encarga de guardar el archivo automáticamente cuando se utiliza dentro de un bloquewith.Aquí tienes el código actualizado:
import pandas as pd import numpy as np import tkinter as tk from tkinter import messagebox from tkinter import filedialog from openpyxl import Workbook from openpyxl.utils.dataframe import dataframe_to_rows from openpyxl.chart import BarChart, Reference def abrir_limites_margen(): limite_window = tk.Toplevel(app) limite_window.title("Límites de Margen por Percepción") tk.Label(limite_window, text="Configura los límites de margen para cada percepción:").grid(row=0, columnspan=2, pady=5) row_num = 1 for percepcion, limite_var in limites_margen.items(): tk.Label(limite_window, text=f"Límite para {percepcion}:").grid(row=row_num, column=0, pady=5) tk.Entry(limite_window, textvariable=limite_var).grid(row=row_num, column=1, pady=5) row_num += 1 tk.Button(limite_window, text="Confirmar", command=limite_window.destroy).grid(row=row_num, columnspan=2, pady=10) def crear_ventana_parametros(): param_window = tk.Toplevel(app) param_window.title("Parámetros de Cálculo de Márgenes") tk.Label(param_window, text="Margen Mínimo por Unidad:").grid(row=0, column=0, pady=5) margen_minimo_entry = tk.Entry(param_window) margen_minimo_entry.grid(row=0, column=1, pady=5) margen_minimo_entry.insert(0, "10") tk.Label(param_window, text="Margen Máximo por Unidad:").grid(row=1, column=0, pady=5) margen_maximo_entry = tk.Entry(param_window) margen_maximo_entry.grid(row=1, column=1, pady=5) margen_maximo_entry.insert(0, "25") tk.Label(param_window, text="Porcentaje Máximo Margen:").grid(row=2, column=0, pady=5) porcentaje_margen_entry = tk.Entry(param_window) porcentaje_margen_entry.grid(row=2, column=1, pady=5) porcentaje_margen_entry.insert(0, "0.35") tk.Label(param_window, text="Margen Objetivo Mínimo:").grid(row=3, column=0, pady=5) margen_min_entry = tk.Entry(param_window) margen_min_entry.grid(row=3, column=1, pady=5) margen_min_entry.insert(0, "16") tk.Label(param_window, text="Margen Objetivo Máximo:").grid(row=4, column=0, pady=5) margen_max_entry = tk.Entry(param_window) margen_max_entry.grid(row=4, column=1, pady=5) margen_max_entry.insert(0, "17") tk.Button(param_window, text="Calcular", command=lambda: ejecutar_calculo( margen_minimo_entry.get(), margen_maximo_entry.get(), porcentaje_margen_entry.get(), margen_min_entry.get(), margen_max_entry.get(), param_window)).grid(row=5, columnspan=2, pady=10) def validar_entrada(valor): try: val = float(valor) if val < 0: raise ValueError return val except ValueError: raise ValueError("Por favor, introduce un número válido y mayor o igual a cero.") def calcular_margen(df, margen_minimo_por_unidad, margen_maximo_por_unidad, porcentaje_maximo_margen, margen_objetivo_min, margen_objetivo_max): df_resultado = pd.DataFrame() margen_objetivo_promedio = (margen_objetivo_min + margen_objetivo_max) / 2 for column in ['Percepció', 'Costo neto', 'Unitats 2024', 'PVP NEX']: if column not in df.columns: raise ValueError(f"La columna '{column}' no se encuentra en el DataFrame.") for perception, grupo in df.groupby('Percepció'): multiplicador = percepcion_margen.get(perception, 1.0) grupo['Margen por Unidad'] = grupo['Costo neto'] * multiplicador * porcentaje_maximo_margen grupo['Margen por Unidad'] = np.clip(grupo['Margen por Unidad'], margen_minimo_por_unidad, margen_maximo_por_unidad) limite_margen_percepcion = limites_margen.get(perception).get() for idx, row in grupo.iterrows(): if pd.notna(row['PVP NEX']) and row['PVP NEX'] > 0: pvp_final = row['Costo neto'] + row['Margen por Unidad'] diferencia = row['PVP NEX'] - pvp_final if diferencia < 0 or diferencia > limite_margen_percepcion: margen_ajuste = min(max(0, diferencia), limite_margen_percepcion) nuevo_pvp_final = row['PVP NEX'] - margen_ajuste grupo.at[idx, 'Margen por Unidad'] = max(0, nuevo_pvp_final - row['Costo neto']) grupo['Check'] = np.where(grupo['PVP NEX'] > 0, grupo['Costo neto'] + grupo['Margen por Unidad'] - grupo['PVP NEX'], np.nan) df_resultado = pd.concat([df_resultado, grupo]) margen_promedio_ponderado_final = (df_resultado['Margen por Unidad'] * df_resultado['Unitats 2024']).sum() / df_resultado['Unitats 2024'].sum() return df_resultado, margen_promedio_ponderado_final def analizar_ventas(df_ajustado): df_ajustado['PVP NEW'] = df_ajustado['Costo neto'] + df_ajustado['Margen por Unidad'] df_ajustado['Margen Actual'] = df_ajustado['PVP Oferta'] - df_ajustado['Costo neto'] file_path = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx")]) if file_path: with pd.ExcelWriter(file_path, engine='openpyxl') as writer: df_ajustado.to_excel(writer, sheet_name='Datos Ajustados', index=False) wb = writer.book ws_analisis = wb.create_sheet(title='Analisis Ventas') for r in dataframe_to_rows(df_ajustado, index=False, header=True): ws_analisis.append(r) chart = BarChart() chart.type = "col" chart.title = "Análisis de Ventas" chart.y_axis.title = 'Unidades' chart.x_axis.title = 'Referencias' data = Reference(ws_analisis, min_col=3, min_row=1, max_row=ws_analisis.max_row, max_col=3) chart.add_data(data, titles_from_data=True) ws_analisis.add_chart(chart, "I10") messagebox.showinfo("Guardado", f"Archivo de análisis guardado exitosamente en {file_path}.") def ejecutar_calculo(margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max, window): try: margen_minimo = validar_entrada(margen_minimo) margen_maximo = validar_entrada(margen_maximo) porcentaje_margen = validar_entrada(porcentaje_margen) margen_min = validar_entrada(margen_min) margen_max = validar_entrada(margen_max) df_ajustado, margen_promedio = calcular_margen( df, margen_minimo, margen_maximo, porcentaje_margen, margen_min, margen_max ) messagebox.showinfo("Resultado", f"Margen promedio ponderado final: {margen_promedio:.2f}") if messagebox.askyesno("Análisis de Ventas", "¿Desea realizar un análisis de ventas y márgenes?"): analizar_ventas(df_ajustado) except ValueError as e: messagebox.showerror("Error de Validación", str(e)) except Exception as e: messagebox.showerror("Error", f"Error en el cálculo: {str(e)}") finally: window.destroy() app = tk.Tk() app.title("Calculadora de Márgenes") file_path = r'C:\Users\ismael.gallardo\Documents\Tabla de comparación neumáticos €.xlsx' df = pd.read_excel(file_path, sheet_name='Data', engine='openpyxl') percepcion_margen = { 'Top Gama': 1.3, 'Premium': 1.2, 'Regular': 1.1, 'Budget': 1.0, 'Low Cost': 0.9 } limites_margen = { 'Top Gama': tk.DoubleVar(value=2.0), 'Premium': tk.DoubleVar(value=2.0), 'Regular': tk.DoubleVar(value=1.5), 'Budget': tk.DoubleVar(value=1.5), 'Low Cost': tk.DoubleVar(value=1.0) } tk.Button(app, text="Configurar Límites de Margen", command=abrir_limites_margen).pack(pady=10) tk.Button(app, text="Configurar Parámetros de Cálculo", command=crear_ventana_parametros).pack(pady=10) app.mainloop()Cambios Clave:
- Eliminé la llamada innecesaria a
writer.save()ya que el uso del administrador de contextowithenpd.ExcelWriterse encarga de guardar automáticamente el archivo al finalizar. - Solicitud de análisis posterior al cálculo: Si el usuario decide realizar un análisis adicional, se crea una nueva hoja de Excel con el análisis y se guarda.
Este ajuste debería resolver el problema de guardado mientras se mantiene la funcionalidad existente. Asegúrate de que las rutas de archivo y nombres de las columnas coincidan exactamente con tu configuración.
- Eliminé la llamada innecesaria a