Python matplotlib内存阻塞（未清除）

matplotlib没有清除内存（我假设）有问题。我试着在谷歌上四处看看，但没有用。我希望每次关闭matplotlib figure（由“绘图”按钮调用）后都能清除内存。提前谢谢

################
#IMPORT MODULES#
################

from Tkinter import *
import matplotlib.pyplot as plt

#####
#GUI#
#####

class Application(Frame):
    #read entry values and estimate the plot(s)
    def run_brussel(self):
        #read entry values
        t_start = float(self.t_start_entry.get())
        t_end = float(self.t_end_entry.get())
        t_diff = float(self.t_diff_entry.get())
        k1 = float(self.k1_entry.get())
        k2 = float(self.k2_entry.get())
        k3 = float(self.k3_entry.get())
        k4 = float(self.k4_entry.get())
        A = float(self.A_entry.get())
        B = float(self.B_entry.get())
        X = float(self.X_entry.get())
        Y = float(self.Y_entry.get())

        mode = self.mode.get()

        #estimate the values of the Brusselator X and Y functions
        brussel = brussel_func(t_start, t_end, t_diff, k1, k2, k3, k4, A, B, X, Y)

        t_list = brussel[0]
        X_list = brussel[1]
        Y_list = brussel[2]

        #plot the functions
        plot_brussel(mode, t_list, X_list, Y_list)

    #define labels, entries, radio buttons and buttons
    def createWidgets(self):
        self.t_start_label = Label(self, text="Start time:")
        self.t_start_label.grid(row=0, column=0, sticky=W)
        self.t_start_entry = Entry(self)
        self.t_start_entry.delete(0, END)
        self.t_start_entry.insert(0, "0.0")
        self.t_start_entry.grid(row=0, column=1)

        self.t_end_label = Label(self, text="End time:")
        self.t_end_label.grid(row=1, column=0, sticky=W)
        self.t_end_entry = Entry(self)
        self.t_end_entry.delete(0, END)
        self.t_end_entry.insert(0, "100.0")
        self.t_end_entry.grid(row=1, column=1)

        self.t_diff_label = Label(self, text="Time precision:")
        self.t_diff_label.grid(row=2, column=0, sticky=W)
        self.t_diff_entry = Entry(self)
        self.t_diff_entry.delete(0, END)
        self.t_diff_entry.insert(0, "0.0001")
        self.t_diff_entry.grid(row=2, column=1)

        self.k1_label = Label(self, text="Constant k1 value:")
        self.k1_label.grid(row=3, column=0, sticky=W)
        self.k1_entry = Entry(self)
        self.k1_entry.delete(0, END)
        self.k1_entry.insert(0, "1.0")
        self.k1_entry.grid(row=3, column=1)

        self.k2_label = Label(self, text="Constant k2 value:")
        self.k2_label.grid(row=4, column=0, sticky=W)
        self.k2_entry = Entry(self)
        self.k2_entry.delete(0, END)
        self.k2_entry.insert(0, "1.0")
        self.k2_entry.grid(row=4, column=1)

        self.k3_label = Label(self, text="Constant k3 value:")
        self.k3_label.grid(row=5, column=0, sticky=W)
        self.k3_entry = Entry(self)
        self.k3_entry.delete(0, END)
        self.k3_entry.insert(0, "1.0")
        self.k3_entry.grid(row=5, column=1)

        self.k4_label = Label(self, text="Constant k4 value:")
        self.k4_label.grid(row=6, column=0, sticky=W)
        self.k4_entry = Entry(self)
        self.k4_entry.delete(0, END)
        self.k4_entry.insert(0, "1.0")
        self.k4_entry.grid(row=6, column=1)

        self.A_label = Label(self, text="Initial A concentration:")
        self.A_label.grid(row=7, column=0, sticky=W)
        self.A_entry = Entry(self)
        self.A_entry.delete(0, END)
        self.A_entry.insert(0, "1.0")
        self.A_entry.grid(row=7, column=1)

        self.B_label = Label(self, text="Initial B concentration:")
        self.B_label.grid(row=8, column=0, sticky=W)
        self.B_entry = Entry(self)
        self.B_entry.delete(0, END)
        self.B_entry.insert(0, "2.5")
        self.B_entry.grid(row=8, column=1)

        self.X_label = Label(self, text="Initial X concentration:")
        self.X_label.grid(row=9, column=0, sticky=W)
        self.X_entry = Entry(self)
        self.X_entry.delete(0, END)
        self.X_entry.insert(0, "0.0")
        self.X_entry.grid(row=9, column=1)

        self.Y_label = Label(self, text="Initial Y concentration:")
        self.Y_label.grid(row=10, column=0, sticky=W)
        self.Y_entry = Entry(self)
        self.Y_entry.delete(0, END)
        self.Y_entry.insert(0, "0.0")
        self.Y_entry.grid(row=10, column=1)

        self.mode = IntVar()
        self.modus_operandi_label = Label(self, text="Plot type:")
        self.modus_operandi_label.grid(row=11, column=0, sticky=W)
        self.modus_operandi_button1 = Radiobutton(self, text="X : Y", variable=self.mode, value=True).grid(row=11, column=1, sticky=W)
        self.modus_operandi_button2 = Radiobutton(self, text="X, Y : time", variable=self.mode, value=False).grid(row=12, column=1, sticky=W)

        self.plot = Button(self)
        self.plot["text"] = "PLOT",
        self.plot["command"] = self.run_brussel
        self.plot.grid(row=13, column=0, columnspan=2, sticky=N+S+W+E)

        self.QUIT = Button(self)
        self.QUIT["text"] = "QUIT"
        self.QUIT["fg"]   = "red"
        self.QUIT["command"] =  self.quit_pressed
        self.QUIT.grid(row=14, column=0, columnspan=2, sticky=N+S+W+E)

    #invoke the window
    def __init__(self, master=None):
        Frame.__init__(self, master)
        self.grid()
        self.createWidgets()

    #destroy the window
    def quit_pressed(self):
        quit()

######################
#FUNCTION DEFINITIONS#
######################

#Brusselator X and Y values estimation
def brussel_func(t_start, t_end, t_diff, k1, k2, k3, k4, A, B, X, Y):
    t = t_start
    t_list = []
    t_list.append(0)
    X_list = [X]
    Y_list = [Y]
    step = 0

    while t < t_end:
        X_diff = t_diff * (k1 * A - k2 * B * X_list[step] + k3 * X_list[step]**2 * Y_list[step] - k4 * X_list[step])
        Y_diff = t_diff * (k2 * B * X_list[step] - k3 * X_list[step]**2 * Y_list[step])
        X_list.append(X)
        Y_list.append(Y)
        t_list.append(t)
        t += t_diff
        X += X_diff
        Y += Y_diff
        step += 1

    return [t_list, X_list, Y_list]

#plot       
def plot_brussel(mode, t_list, X_list, Y_list):
    p = []

    #plots X : Y    
    if mode == True:
        p = plt.plot(X_list, Y_list)
        plt.xlabel('x')
        plt.ylabel('y')

    #plots X, Y : time
    else:
        p = plt.plot(t_list, X_list, label="X")
        p += plt.plot(t_list, Y_list, label="Y")
        plt.legend(loc="upper left", bbox_to_anchor=(1,1))
        plt.xlabel('time')

    #displays chosen plot
    plt.show(p)
    plt.clf(p)
    plt.close(p)

def main():
    root = Tk()
    root.wm_title("Brusselator")
    app = Application(master=root)
    app.mainloop()

#############
#SCRIPT BODY#
#############

if __name__ == '__main__':
    main()

################
#导入模块#
################
从Tkinter进口*
将matplotlib.pyplot作为plt导入
#####
#桂#
#####
课程申请（框架）：
#读取输入值并估计绘图
def run_brussel（自身）：
#读取条目值
t\u start=float（self.t\u start\u entry.get（））
t\u end=float（self.t\u end\u entry.get（））
t_diff=float（self.t_diff_entry.get（））
k1=float（self.k1_entry.get（））
k2=float（self.k2_entry.get（））
k3=浮点（self.k3_entry.get（））
k4=浮点（self.k4_entry.get（））
A=浮点（self.A_entry.get（））
B=浮动（self.B_entry.get（））
X=float（self.X_entry.get（））
Y=float（self.Y\u entry.get（））
mode=self.mode.get（）
#估计Brusselator X和Y函数的值
brussel=brussel_func（t_开始、t_结束、t_差异、k1、k2、k3、k4、A、B、X、Y）
t_list=brussel[0]
X_list=brussel[1]
Y_list=brussel[2]
#绘制函数
布鲁塞尔绘图（模式、t列表、X列表、Y列表）
#定义标签、条目、单选按钮和按钮
def createWidgets（自）：
self.t\u start\u label=标签（self，text=“开始时间：）
self.t\u start\u label.grid（行=0，列=0，粘性=W）
self.t\u start\u entry=条目（self）
self.t\u start\u entry.delete（0，END）
self.t\u start\u entry.insert（0，“0.0”）
self.t\u start\u entry.grid（行=0，列=1）
self.t\u end\u label=标签（self，text=“结束时间：）
self.t_end_label.grid（行=1，列=0，粘性=W）
self.t\u end\u entry=条目（self）
self.t_end_entry.delete（0，end）
self.t_end_entry.insert（0，“100.0”）
self.t\u end\u entry.grid（行=1，列=1）
self.t\u diff\u label=标签（self，text=“时间精度：）
self.t_diff_label.grid（行=2，列=0，粘性=W）
self.t_diff_entry=条目（self）
self.t_diff_entry.delete（0，结束）
self.t_diff_entry.insert（0，“0.0001”）
self.t_diff_entry.grid（行=2，列=1）
self.k1_label=标签（self，text=“常数k1值：”）
self.k1_label.grid（行=3，列=0，粘性=W）
self.k1_entry=条目（self）
self.k1_entry.delete（0，END）
自.k1_条目.插入（0，“1.0”）
self.k1_entry.grid（行=3，列=1）
self.k2_label=标签（self，text=“常数k2值：”）
self.k2_label.grid（行=4，列=0，粘性=W）
self.k2_条目=条目（self）
self.k2_条目.删除（0，结束）
自我。k2_条目。插入（0，“1.0”）
self.k2_entry.grid（行=4，列=1）
self.k3_label=标签（self，text=“常数k3值：”）
self.k3_label.grid（行=5，列=0，粘性=W）
self.k3_entry=条目（self）
self.k3_entry.delete（0，END）
self.k3_条目插入（0，“1.0”）
self.k3_entry.grid（行=5，列=1）
self.k4_label=标签（self，text=“常数k4值：”）
self.k4_label.grid（行=6，列=0，粘性=W）
self.k4_entry=条目（self）
self.k4_条目.删除（0，结束）
自我。k4_条目。插入（0，“1.0”）
self.k4_entry.grid（行=6，列=1）
self.A_label=标签（self，text=“初始A浓度：”）
self.A_label.grid（行=7，列=0，粘性=W）
self.A_entry=条目（self）
self.A_entry.delete（0，END）
self.A_条目插入（0，“1.0”）
self.A_entry.grid（行=7，列=1）
self.B_label=标签（self，text=“初始B浓度：”）
self.B_label.grid（行=8，列=0，粘性=W）
self.B_entry=条目（self）
self.B_条目.删除（0，结束）
自行录入。插入（0，“2.5”）
self.B_entry.grid（行=8，列=1）
self.X_label=标签（self，text=“初始X浓度：”）
self.X_label.grid（行=9，列=0，粘性=W）
self.X_entry=条目（self）
self.X_条目.删除（0，结束）
self.X_条目插入（0，“0.0”）
self.X_entry.grid（行=9，列=1）
self.Y\u label=标签（self，text=“初始Y浓度：”）
self.Y_label.grid（行=10，列=0，粘性=W）
self.Y_entry=条目（self）
self.Y_条目.删除（0，结束）
self.Y_条目插入（0，“0.0”）
self.Y_entry.grid（行=10，列=1）
self.mode=IntVar（）
self.modus\u operani\u label=标签（self，text=“打印类型：”）
self.modus\u operani\u label.grid（行=11，列=0，粘性=W）
self.mode\u operation\u button1=单选按钮（self，text=“X:Y”，变量=self.mode，值=True）。网格（行=11，列=1，粘性=W）
self.mode\u operation\u button2=单选按钮（self，text=“X，Y:time”，变量=self.mode，值=False）。网格（行=12，列=1，粘性=W）
self.plot=按钮（self）
self.plot[“text”]=“plot”，
self.plot[“command”]=self.run\u brussel
self.plot.grid（行=13，列=0，列span=2，粘性=N+S+W+E）
self.QUIT=按钮（self）
self.QUIT[“text”]=“退出”
self.QUIT[“fg”]=“红色”
self.QUIT[“command”]=按下self.QUIT
self.QUIT.grid（行=14，列=0，列span=2，粘性=N+S+W+E）
#调用窗口
def uuu init uuu（self，master=None）：
帧。\uuuu初始化（自，主）
self.grid（）
self.createWidgets（）
#破坏窗户
def quit_按下（自身）：
退出
######################
#函数定义#
######################
#Brusselator X和Y值估计
def brussel_func（t_开始、t_结束、t_差异、k1、k2、k3、k4、A、B、X、Y）：
t=t_开始
t_list=[]
t_list.append（0）
X_列表=[X]
Y_列表=[Y]
步长=0
当t