如何基于Tkinter实现字典列表编辑功能（适配工具栏编辑标签）

Great question! Let’s walk through implementing this step by step. I’ll assume you have a main Tkinter application window with a dictionary list (let’s call it dictionary_entries) that you want users to modify.

Step 1: Add an "Edit" Menu to Your Toolbar/Menu Bar #

First, let’s add an Edit menu option to your existing toolbar or menu bar. If you don’t have a menu bar yet, here’s how to create one with an Edit entry:

import tkinter as tk
from tkinter import ttk, messagebox

# Your existing dictionary list (replace with your actual data)
dictionary_entries = [{"name": "Alice", "age": "30"}, {"name": "Bob", "age": "25"}]

class MainApp(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Dictionary Editor")
        
        # Create menu bar
        menu_bar = tk.Menu(self)
        self.config(menu=menu_bar)
        
        # Add Edit menu
        edit_menu = tk.Menu(menu_bar, tearoff=0)
        menu_bar.add_cascade(label="Edit", menu=edit_menu)
        edit_menu.add_command(label="Edit Dictionary List", command=self.open_edit_dialog)
        
        # Rest of your existing app code goes here...
    
    def open_edit_dialog(self):
        # Launch the edit dialog we'll define next
        EditDictionaryDialog(self, dictionary_entries)

Step 2: Create the Edit Dictionary Dialog #

This dialog will let users view, edit, add, and delete entries from your dictionary list. We’ll use a Treeview widget to display entries, plus input fields for modifying them:

class EditDictionaryDialog(tk.Toplevel):
    def __init__(self, parent, data_list):
        super().__init__(parent)
        self.title("Edit Dictionary List")
        self.data_list = data_list  # Reference to the main app's dictionary list
        self.selected_item = None  # Track the currently selected entry
        
        # Set window size
        self.geometry("600x400")
        
        # Treeview to display dictionary entries
        self.tree = ttk.Treeview(self, columns=("Key", "Value"), show="headings")
        self.tree.heading("Key", text="Key")
        self.tree.heading("Value", text="Value")
        self.tree.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # Populate Treeview with existing data
        self.refresh_tree()
        
        # Bind selection event to populate input fields
        self.tree.bind("<<TreeviewSelect>>", self.on_select)
        
        # Input fields for editing key/value
        input_frame = ttk.Frame(self)
        input_frame.pack(fill=tk.X, padx=10, pady=5)
        
        ttk.Label(input_frame, text="Key:").grid(row=0, column=0, padx=5, pady=5)
        self.key_entry = ttk.Entry(input_frame)
        self.key_entry.grid(row=0, column=1, padx=5, pady=5, sticky="ew")
        
        ttk.Label(input_frame, text="Value:").grid(row=0, column=2, padx=5, pady=5)
        self.value_entry = ttk.Entry(input_frame)
        self.value_entry.grid(row=0, column=3, padx=5, pady=5, sticky="ew")
        
        # Make input fields expand with window
        input_frame.grid_columnconfigure(1, weight=1)
        input_frame.grid_columnconfigure(3, weight=1)
        
        # Action buttons
        button_frame = ttk.Frame(self)
        button_frame.pack(fill=tk.X, padx=10, pady=10)
        
        ttk.Button(button_frame, text="Add Entry", command=self.add_entry).pack(side=tk.LEFT, padx=5)
        ttk.Button(button_frame, text="Save Changes", command=self.save_changes).pack(side=tk.LEFT, padx=5)
        ttk.Button(button_frame, text="Delete Entry", command=self.delete_entry).pack(side=tk.LEFT, padx=5)
        ttk.Button(button_frame, text="Close", command=self.destroy).pack(side=tk.RIGHT, padx=5)
    
    def refresh_tree(self):
        # Clear existing items and repopulate with current data
        for item in self.tree.get_children():
            self.tree.delete(item)
        
        for entry in self.data_list:
            for key, value in entry.items():
                self.tree.insert("", tk.END, values=(key, value))
    
    def on_select(self, event):
        # Populate input fields when an entry is selected
        selected_items = self.tree.selection()
        if selected_items:
            self.selected_item = selected_items[0]
            key, value = self.tree.item(self.selected_item, "values")
            self.key_entry.delete(0, tk.END)
            self.key_entry.insert(0, key)
            self.value_entry.delete(0, tk.END)
            self.value_entry.insert(0, value)
    
    def add_entry(self):
        # Add new key-value pair to the dictionary list
        key = self.key_entry.get().strip()
        value = self.value_entry.get().strip()
        if key and value:
            self.data_list.append({key: value})
            self.refresh_tree()
            self.key_entry.delete(0, tk.END)
            self.value_entry.delete(0, tk.END)
        else:
            messagebox.showwarning("Warning", "Both key and value must be filled!")
    
    def save_changes(self):
        # Update selected entry with new key/value
        if not self.selected_item:
            messagebox.showwarning("Warning", "Select an entry to edit first!")
            return
        
        old_key, old_value = self.tree.item(self.selected_item, "values")
        new_key = self.key_entry.get().strip()
        new_value = self.value_entry.get().strip()
        
        if not new_key or not new_value:
            messagebox.showwarning("Warning", "Both key and value must be filled!")
            return
        
        # Find and update the entry in the original list
        for entry in self.data_list:
            if old_key in entry and entry[old_key] == old_value:
                del entry[old_key]
                entry[new_key] = new_value
                break
        
        self.refresh_tree()
        self.selected_item = None
        self.key_entry.delete(0, tk.END)
        self.value_entry.delete(0, tk.END)
    
    def delete_entry(self):
        # Remove selected entry from the dictionary list
        if not self.selected_item:
            messagebox.showwarning("Warning", "Select an entry to delete first!")
            return
        
        key, value = self.tree.item(self.selected_item, "values")
        self.data_list = [entry for entry in self.data_list if not (key in entry and entry[key] == value)]
        
        self.refresh_tree()
        self.selected_item = None
        self.key_entry.delete(0, tk.END)
        self.value_entry.delete(0, tk.END)

Step 3: Integrate with Your Existing Code #

• Replace the example dictionary_entries with your actual dictionary list variable from your code.
• If you already have a menu bar, just add the Edit menu cascade to it instead of creating a new one.
• The EditDictionaryDialog class can be added alongside your existing My_QueryString class.

Key Notes #

• The dialog directly modifies the original dictionary list (passed by reference), so changes will be reflected in your main app immediately.
• The Treeview displays each key-value pair as a row—if your dictionaries have multiple keys, adjust the logic to handle that (the example assumes each entry is a single key-value dict, which is common for list-based dictionaries).
• Basic validation ensures users don’t add empty entries or try to edit/delete without selecting an item.

To run the example, add this at the bottom of your code:

if __name__ == "__main__":
    app = MainApp()
    app.mainloop()

内容的提问来源于stack exchange，提问作者stamno