Tkinter, обновляйте виджеты в режиме реального времени, если список изменен

Поэтому я решил, что если я хочу нажать кнопку, эта кнопка должна иметь возможность обновлять список. Следовательно, я привязываю несвязанные кнопки в виджете к этой функции:

   def sidebar_button_event(self):
    global x
    x=10
    self.scrollable_frame.destroy()
    self.after(0,self.update())

Что затем вызовет функцию обновления, которая сохранит значение изменения, а функция обновления просто перезапишет сетку:

    def update(self):
    self.scrollable_frame = customtkinter.CTkScrollableFrame(self, label_text = "CTkScrollableFrame")
    self.scrollable_frame.grid(row=1, column=2, padx=(20, 0), pady=(20, 0), sticky = "nsew")
    self.scrollable_frame.grid_columnconfigure(0, weight=1)
    self.scrollable_frame_switches = []
    for i in range(x,100):
        switch = customtkinter.CTkSwitch(master=self.scrollable_frame, text=f"CTkSwitch {i}")
        switch.grid(row=i, column=0, padx=10, pady=(0, 20))
        self.scrollable_frame_switches.append(switch)

Как я уже говорил ранее, хотя существующий ответ может работать, он может быть неэффективным, поскольку вы уничтожаете и создаете новые виджеты каждый раз, когда происходит изменение. Вместо этого вы можете создать функцию, которая будет проверять, есть ли изменение, а затем, если есть лишние или меньшие элементы, изменения произойдут:

from tkinter import *
import random

root = Tk()


def fetch_changed_list():
    """Function that will change the list and return the new list"""
    MAX = random.randint(5, 15)

    # Create a list with random text and return it
    items = [f'Button {x+1}' for x in range(MAX)]
    return items


def calculate():
    global items

    # Fetch the new list
    new_items = fetch_changed_list()

    # Store the length of the current list and the new list
    cur_len, new_len = len(items), len(new_items)

    # If the length of new list is more than current list then
    if new_len > cur_len:
        diff = new_len - cur_len

        # Change text of existing widgets
        for idx, wid in enumerate(items_frame.winfo_children()):
            wid.config(text=new_items[idx])

        # Make the rest of the widgets required
        for i in range(diff):
            Button(items_frame, text=new_items[cur_len+i]).pack()

    # If the length of current list is more than new list then
    elif new_len < cur_len:
        extra = cur_len - new_len

        # Change the text for the existing widgets
        for idx in range(new_len):
            wid = items_frame.winfo_children()[idx]
            wid.config(text=new_items[idx])

        # Get the extra widgets that need to be removed
        extra_wids = [wid for wid in items_frame.winfo_children()
                      [-1:-extra-1:-1]]  # The indexing is a way to pick the last 'n' items from a list

        # Remove the extra widgets
        for wid in extra_wids:
            wid.destroy()

        # Also can shorten the last 2 steps into a single line using
        # [wid.destroy() for wid in items_frame.winfo_children()[-1:-extra-1:-1]]

    items = new_items  # Update the value of the main list to be the new list
    root.after(1000, calculate)  # Repeat the function every 1000ms


items = [f'Button {x+1}' for x in range(8)]  # List that will keep mutating

items_frame = Frame(root)  # A parent with only the dynamic widgets
items_frame.pack()

for item in items:
    Button(items_frame, text=item).pack()

root.after(1000, calculate)

root.mainloop()

Код прокомментирован, чтобы сделать его понятным построчно. Здесь важно отметить items_frame, который позволяет получать все динамически созданные виджеты напрямую, без необходимости сохранять их в списке вручную.

Функция fetch_changed_list изменяет список и возвращает его. Если вы не хотите повторять calculate каждые 1000 мс (это хорошая идея, чтобы не повторять бесконечно), вы можете вызывать функцию calculate каждый раз, когда вы меняете список.

def change_list():
    # Logic to change the list
    ...

    calculate() # To make the changes

Подсчитав время выполнения функций, я обнаружил следующее:

Где «до» — это уничтожение и воссоздание, а «после» — это выполнение только тогда, когда необходимы изменения.