fijate en este código de un estudiante y analizalo para ver que es lo que esta mal, haz que haya 2 sliders para ver siempre que vale cada uno y luego se tiene que actualizar correctamente el rectangulo y lo demás: "import tkinter as tk
from tkinter import ttk
import math

# Constante de la proporción áurea
PHI = (1 + math.sqrt(5)) / 2  # ≈ 1.618

class GoldenRectangleApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Rectángulo Dorado Interactivo")

        # Configuración inicial del rectángulo
        self.base_length = 300  # Valor inicial del ancho
        self.orientation = 'width'  # Orientación ajustable: 'width' o 'height'

        # Crear los widgets de la interfaz
        self.create_widgets()
        self.draw_rectangle()

    def create_widgets(self):
        # Marco superior para controles
        control_frame = ttk.Frame(self.root)
        control_frame.pack(side=tk.TOP, fill=tk.X, padx=10, pady=10)

        # Etiqueta y menú desplegable para seleccionar la orientación
        self.orientation_var = tk.StringVar(value='Width')
        orientation_label = ttk.Label(control_frame, text="Ajustar:")
        orientation_label.pack(side=tk.LEFT, padx=(0,5))

        orientation_menu = ttk.OptionMenu(control_frame, self.orientation_var, 'Width', 'Width', 'Height', command=self.update_orientation)
        orientation_menu.pack(side=tk.LEFT, padx=(0,15))

        # Etiqueta para mostrar el valor actual (Debe crearse antes de configurar el Scale)
        self.value_label = ttk.Label(control_frame, text=f"Width: {self.base_length:.1f}")
        self.value_label.pack(side=tk.LEFT, padx=(10,0))

        # **CREACIÓN DEL CANVAS ANTES DEL SCALE**
        # Lienzo para dibujar el rectángulo dorado
        self.canvas = tk.Canvas(self.root, width=600, height=600, bg="white")
        self.canvas.pack(padx=10, pady=10)

        # Control deslizante para ajustar el ancho o la altura
        self.scale = ttk.Scale(control_frame, from_=100, to=500, orient=tk.HORIZONTAL, command=self.on_scale)
        self.scale.set(self.base_length)
        self.scale.pack(side=tk.LEFT, fill=tk.X, expand=True)

    def update_orientation(self, value):
        self.orientation = value.lower()
        # Actualizar la etiqueta
        self.value_label.config(text=f"{value}: {self.scale.get():.1f}")
        self.draw_rectangle()

    def on_scale(self, val):
        val = float(val)
        if self.orientation == 'width':
            width = val
            height = width / PHI
            self.value_label.config(text=f"Width: {width:.1f}")
        else:
            height = val
            width = height * PHI
            self.value_label.config(text=f"Height: {height:.1f}")
        self.draw_rectangle(width, height)

    def draw_rectangle(self, width=None, height=None):
        self.canvas.delete("all")
        if width is None:
            width = self.scale.get() if self.orientation == 'width' else self.scale.get() * PHI
        if height is None:
            height = width / PHI if self.orientation == 'width' else self.scale.get()

        # Escalar para encajar en el lienzo
        scale_factor = min(500 / width, 500 / height)
        scaled_width = width * scale_factor
        scaled_height = height * scale_factor

        # Coordenadas para centrar el rectángulo
        x0 = (600 - scaled_width) / 2
        y0 = (600 - scaled_height) / 2
        x1 = x0 + scaled_width
        y1 = y0 + scaled_height

        # Dibujar el rectángulo dorado
        self.canvas.create_rectangle(x0, y0, x1, y1, outline="black", fill="#f0f0f0", width=2)
        
        # Subdividir el rectángulo en un cuadrado y un rectángulo más pequeño
        if width >= height:
            # Dividir a la derecha
            square_size = height
            # Coordenadas del cuadrado
            self.canvas.create_rectangle(
                x1 - square_size * scale_factor, y0, 
                x1, y0 + square_size * scale_factor, 
                outline="blue", fill="#add8e6", width=2
            )
            # Dibujar el rectángulo más pequeño
            self.draw_recursive(
                x0, y0, 
                x1 - square_size * scale_factor, y0 + square_size * scale_factor, 
                scaled_width - square_size * scale_factor, scaled_height, 
                scale_factor
            )
        else:
            # Dividir en la parte inferior
            square_size = width
            self.canvas.create_rectangle(
                x0, y1 - square_size * scale_factor, 
                x0 + square_size * scale_factor, y1, 
                outline="blue", fill="#add8e6", width=2
            )
            self.draw_recursive(
                x0, y0, 
                x0 + square_size * scale_factor, y1 - square_size * scale_factor, 
                scaled_width, scaled_height - square_size * scale_factor, 
                scale_factor
            )

    def draw_recursive(self, x0, y0, x1, y1, width, height, scale_factor):
        """Dibuja subdivisiones recursivas del rectángulo dorado."""
        depth = 3  # Nivel de profundidad de subdivisión
        current_depth = 0
        stack = [(x0, y0, x1, y1, width, height, current_depth)]

        while stack:
            cx0, cy0, cx1, cy1, cwidth, cheight, depth_now = stack.pop()
            if depth_now >= depth:
                continue

            if cwidth >= cheight:
                # Dividir a la derecha
                square_size = cheight
                self.canvas.create_rectangle(
                    cx1 - square_size * scale_factor, cy0, 
                    cx1, cy0 + square_size * scale_factor, 
                    outline="green", fill="#90ee90", width=1
                )
                # Añadir el nuevo rectángulo a la pila
                new_width = cwidth - square_size
                new_height = cheight
                stack.append((
                    cx0, cy0, 
                    cx1 - square_size * scale_factor, cy0 + square_size * scale_factor, 
                    new_width, new_height, depth_now + 1
                ))
            else:
                # Dividir en la parte inferior
                square_size = cwidth
                self.canvas.create_rectangle(
                    cx0, cy1 - square_size * scale_factor, 
                    cx0 + square_size * scale_factor, cy1, 
                    outline="green", fill="#90ee90", width=1
                )
                # Añadir el nuevo rectángulo a la pila
                new_width = cwidth
                new_height = cheight - square_size
                stack.append((
                    cx0, cy0, 
                    cx0 + square_size * scale_factor, cy1 - square_size * scale_factor, 
                    new_width, new_height, depth_now + 1
                ))

def main():
    root = tk.Tk()
    app = GoldenRectangleApp(root)
    root.mainloop()

if __name__ == "__main__":
    main()"