如何删除for循环中的标签

Question

So, how would I remove all the Tkinter.Label 's generated within my for loop and generate new ones while retaining my method of generation? Cause if I want to lower the number it won't remove the labels of the previous number(Such as, input '6' and you get [3,4,5] and the next number '14' generates [5,12,13] . How could I remove [5,12,13] if my input < 14 ?), if someone has a better method of generating the output for these labels it would be greatly appreciated if you would try and educate me a little. Here's the code:

import Tkinter
import sys
from fractions import gcd


def func(event):
    x = int(e1.get())  # get max number
    row = 0
    column = 0
    count = 0
    for a in range(1, x):  # loops to get each value in range of x
        for b in range(a, x):
            for c in range(b, x):
                if a**2 + b**2 == c**2 and gcd(a, b) == 1:  # if it is a primitive pyth triple, print
                    row += 1
                    l = Tkinter.Label(root, text=('[',a,',',b,',',c,']'))
                    assert isinstance(l, object)
                    l.grid(row=row, column=column, ipadx=5, ipady=5, sticky='W''E')  # display each group of triples to root
                    root.title('Primitive Triples')
                    if count > 1:
                        l.destroy()
                    if row == 7:
                        column += 1
                        row -= 8


def close():  # close program
    Tkinter.sys.exit(0)
    sys.exit(0)


root = Tkinter.Tk()  # establish main gui
root.title('Generator')
e1 = Tkinter.Entry(root)
assert isinstance(e1, object)  # only method I've found to allow for Entry().grid()
e1.grid(ipadx=5, ipady=5, sticky='W''E')
root.bind('<Return>', func)  # bind to Enter, cleaner and quicker than a button
root.mainloop()

Answer 1

Here, I think this is what you wanted: (if python 2, replace import tkinter with import Tkinter as tkinter)

import tkinter
import sys
from fractions import gcd

CURRENT_LABELS = []

def pythagorean_primitive(a, b, c):
    """returns True if a,b,c are pythagorean primitives, False otherwise"""
    return a**2 + b**2 == c**2 and gcd(a, b) == 1

def generate_results(n):
    """lists each triplet of distinct integers <n that is a pythagorean primitive"""
    results = []
    for a in range(1, n):
        for b in range(a, n):
            for c in range(b, n):
                if pythagorean_primitive(a, b, c):
                    results.append([a, b, c])
    return results

def generate_labels(sequence):
    """returns a list of tkinter labels from the sequence provided"""
    labels = []
    for elt in sequence:
        a, b, c = elt[0], elt[1], elt[2]
        labels.append(tkinter.Label(root, text='[' + str(a) + ', '+ str(b) + ", " + str(c) + "]"))
    return labels

def destroy_old():
    """purges the current tkinter labels from root, and destroys them"""
    global CURRENT_LABELS
    for elt in CURRENT_LABELS:
        elt.grid_forget()
        elt.destroy()

def show_new_labels(sequence):
    """assembles a new display of tkinter labels from the sequence provided"""
    r, c = 1, 0
    for label in sequence:
        label.grid(row=r, column=c, ipadx=5, ipady=5, sticky='W''E')
        r += 1
        if not r % 10:
            r = 1
            c += 1

def event_handler(event):
    """deals with the input of a number in the Entry field"""
    global CURRENT_LABELS
    x = int(e1.get())  # get max number
    results = generate_results(x)
    try:
        destroy_old()
    except IndexError:
        pass
    CURRENT_LABELS = generate_labels(results)
    show_new_labels(CURRENT_LABELS)


def close():  # close program
    tkinter.sys.exit(0)
    sys.exit(0)


root = tkinter.Tk()  # establish main gui
root.title('Generator')
e1 = tkinter.Entry(root)
assert isinstance(e1, object)  # only method I've found to allow for Entry().grid()
e1.grid(ipadx=5, ipady=5, sticky='W''E')
root.bind('<Return>', event_handler)  # bind to Enter, cleaner and quicker than a button
root.mainloop()

What has changed from the code originally posted is as follows:

• refactor each coherent step out of a bulky function into separate and mostly independent functions with more eloquent names. The names of the variables was also changed to be more readable.
• Thus the results are calculated independently from their formatting for display.
• The results are aggregated in a list
• the list is passed over to create tkinter.Labels ready for display; these labels are aggregated in a list.
• The (old) labels that displayed the results from a previous calculation are then erased from the display, and destroyed.
• The new labels holding the results of the new calculation are then displayed.

The original code attempted to do all that in one function; it was failing to discard old results; the consequence was that (1) the display was an odd mix of older and newer results (inaccurate and inexact), and (2) discarded, but never destroyed widgets were cluttering the app space.

On OSX, the widget looks like this: