blocks|key|363548|text|Tkinter支持一种称为的机制。这里，术语协议指的是应用程序和窗口管理器之间的交互。最常用的协议称为WM_DELETE_WINDOW，用于定义当用户使用窗口管理器显式关闭窗口时发生的情况。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|363549|您可以使用protocol方法安装此协议的处理程序(小部件必须是Tk或Toplevel小部件)：|363550|这里有一个具体的例子：|363551|import+tkinter+as+tk
from+tkinter+import+messagebox

root+=+tk.Tk()

def+on_closing():
++++if+messagebox.askokcancel("Quit",+"Do+you+want+to+quit?"):
++++++++root.destroy()

root.protocol("WM_DELETE_WINDOW",+on_closing)
root.mainloop()|code-block|syntax|javascript|363552|entityMap^0|1F|G|0|5|8|W|2|Z|8|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|11|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

Tkinter supports a mechanism called <a href="http://web.archive.org/web/20201111215134/http://effbot.org/tkinterbook/tkinter-events-and-bindings.htm#protocols" rel="noreferrer">protocol handlers</a>. Here, the term protocol refers to the interaction between the application and the window manager. The most commonly used protocol is called <code>WM_DELETE_WINDOW</code>, and is used to define what happens when the user explicitly closes a window using the window manager.
You can use the <code>protocol</code> method to install a handler for this protocol (the widget must be a <code>Tk</code> or <code>Toplevel</code> widget):
Here you have a concrete example:
<pre><code>import tkinter as tk
from tkinter import messagebox

root = tk.Tk()

def on_closing():
 if messagebox.askokcancel(&quot;Quit&quot;, &quot;Do you want to quit?&quot;):
 root.destroy()

root.protocol(&quot;WM_DELETE_WINDOW&quot;, on_closing)
root.mainloop()
</code></pre>

blocks|key|3155904|text|根据Tkinter活动，尤其是在使用Tkinter.after时，使用destroy()停止此活动--即使使用协议()、按钮等--将干扰此活动(“执行时”错误)，而不只是终止它。在几乎所有情况下，最好的解决方案都是使用标志。下面是一个关于如何使用它的简单、愚蠢的示例(尽管我确信大多数人不需要它！)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3155905|from+Tkinter+import+*

def+close_window():
++global+running
++running+=+False++#+turn+off+while+loop
++print(+"Window+closed")

root+=+Tk()
root.protocol("WM_DELETE_WINDOW",+close_window)
cv+=+Canvas(root,+width=200,+height=200)
cv.pack()

running+=+True;
#+This+is+an+endless+loop+stopped+only+by+setting+'running'+to+'False'
while+running:+
++for+i+in+range(200):+
++++if+not+running:+
++++++++break
++++cv.create_oval(i,+i,+i%2B1,+i%2B1)
++++root.update()+|code-block|syntax|javascript|3155906|这很好地终止了图形活动。您只需在正确的位置检查running。|3155907|entityMap^0|Z|9|0|0|N|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Depending on the Tkinter activity, and especially when using Tkinter.after, stopping this activity with <code>destroy()</code> -- even by using protocol(), a button, etc. -- will disturb this activity ("while executing" error) rather than just terminate it. The best solution in almost every case is to use a flag. Here is a simple, silly example of how to use it (although I am certain that most of you don't need it! :)

<pre class="lang-py prettyprint-override"><code>from Tkinter import *

def close_window():
 global running
 running = False # turn off while loop
 print( "Window closed")

root = Tk()
root.protocol("WM_DELETE_WINDOW", close_window)
cv = Canvas(root, width=200, height=200)
cv.pack()

running = True;
# This is an endless loop stopped only by setting 'running' to 'False'
while running: 
 for i in range(200): 
 if not running: 
 break
 cv.create_oval(i, i, i+1, i+1)
 root.update() 
</code></pre>

This terminates graphics activity nicely. You only need to check <code>running</code> at the right place(s).

blocks|key|366948|text|尝试简单的版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|366949|import+tkinter

window+=+Tk()

closebutton+=+Button(window,+text='X',+command=window.destroy)
closebutton.pack()

window.mainloop()|code-block|syntax|javascript|366950|或者，如果您想要添加更多命令：|366951|import+tkinter

window+=+Tk()


def+close():
++++window.destroy()
++++#More+Functions


closebutton+=+Button(window,+text='X',+command=close)
closebutton.pack()

window.mainloop()|366952|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Try The Simple Version:

<pre><code>import tkinter

window = Tk()

closebutton = Button(window, text='X', command=window.destroy)
closebutton.pack()

window.mainloop()

</code></pre>

Or If You Want To Add More Commands:

<pre><code>import tkinter

window = Tk()


def close():
 window.destroy()
 #More Functions


closebutton = Button(window, text='X', command=close)
closebutton.pack()

window.mainloop()
</code></pre>

blocks|key|3368872|text|我要感谢Apostolos的回答引起了我的注意。下面是2019年Python+3的一个更详细的示例，具有更清晰的描述和示例代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3368873|3368874|请注意，当用户关闭窗口时，destroy()+(或根本没有自定义窗口关闭处理程序)将立即销毁窗口及其所有正在运行的回调。|offset|length|style|CODE|3368875|这可能对你不好，这取决于你当前的Tkinter活动，特别是在使用tkinter.after+(定期回调)的时候。您可能正在使用一个回调函数来处理一些数据并将其写入磁盘...在这种情况下，您显然希望在不被突然终止的情况下完成数据写入。|3368876|最好的解决方案是使用标志。因此，当用户请求关闭窗口时，您将其标记为标志，然后对其做出反应。|3368877|(注意:我通常将GUI设计为封装得很好的类和独立的工作线程，而且我绝对不使用"global“(我使用类实例变量)，但这是一个简单的简化示例，用于演示Tk如何在用户关闭窗口时突然终止定期回调...)|3368878|from+tkinter+import+*
import+time

#+Try+setting+this+to+False+and+look+at+the+printed+numbers+(1+to+10)
#+during+the+work-loop,+if+you+close+the+window+while+the+periodic_call
#+worker+is+busy+working+(printing).+It+will+abruptly+end+the+numbers,
#+and+kill+the+periodic+callback!+That's+why+you+should+design+most
#+applications+with+a+safe+closing+callback+as+described+in+this+demo.
safe_closing+=+True

#+---------

busy_processing+=+False
close_requested+=+False

def+close_window():
++++global+close_requested
++++close_requested+=+True
++++print("User+requested+close+at:",+time.time(),+"Was+busy+processing:",+busy_processing)

root+=+Tk()
if+safe_closing:
++++root.protocol("WM_DELETE_WINDOW",+close_window)
lbl+=+Label(root)
lbl.pack()

def+periodic_call():
++++global+busy_processing

++++if+not+close_requested:
++++++++busy_processing+=+True
++++++++for+i+in+range(10):
++++++++++++print((i%2B1),+"of+10")
++++++++++++time.sleep(0.2)
++++++++++++lbl["text"]+=+str(time.time())+#+Will+error+if+force-closed.
++++++++++++root.update()+#+Force+redrawing+since+we+change+label+multiple+times+in+a+row.
++++++++busy_processing+=+False
++++++++root.after(500,+periodic_call)
++++else:
++++++++print("Destroying+GUI+at:",+time.time())
++++++++try:+#+"destroy()"+can+throw,+so+you+should+wrap+it+like+this.
++++++++++++root.destroy()
++++++++except:
++++++++++++#+NOTE:+In+most+code,+you'll+wanna+force+a+close+here+via
++++++++++++#+"exit"+if+the+window+failed+to+destroy.+Just+ensure+that
++++++++++++#+you+have+no+code+after+your+`mainloop()`+call+(at+the
++++++++++++#+bottom+of+this+file),+since+the+exit+call+will+cause+the
++++++++++++#+process+to+terminate+immediately+without+running+any+more
++++++++++++#+code.+Of+course,+you+should+NEVER+have+code+after+your
++++++++++++#+`mainloop()`+call+in+well-designed+code+anyway...
++++++++++++#+exit(0)
++++++++++++pass

root.after_idle(periodic_call)
root.mainloop()|code-block|syntax|javascript|3368879|这段代码将向您展示，即使我们的自定义periodic_call()正忙于工作/循环，WM_DELETE_WINDOW处理程序也会运行！|3368880|我们使用了一些非常夸张的.after()值:+500毫秒。这只是为了让您很容易地看到在定期调用忙或不忙时关闭之间的区别……如果您在号码更新时关闭，您将看到在定期调用“忙于处理:+True”时发生了WM_DELETE_WINDOW。如果您在数字暂停时关闭(意味着此时周期性回调没有处理)，您会看到关闭发生在它“不忙”的时候。|3368881|在实际使用中，您的.after()需要大约30-100毫秒的时间才能有一个响应式的图形用户界面。这只是一个演示，帮助您了解如何保护自己免受Tk默认的“关闭时立即中断所有工作”行为的影响。|3368882|总而言之:让WM_DELETE_WINDOW处理程序设置一个标志，然后定期检查该标志，并在窗口安全时(当您的应用程序完成所有工作后)手动.destroy()窗口。|3368883|PS:你也可以使用WM_DELETE_WINDOW来询问用户是否真的想关闭窗口；如果他们回答否，你就不需要设置标志。这很简单。您只需在WM_DELETE_WINDOW中显示一个消息框，并根据用户的回答设置标志即可。|3368884|entityMap^0|0|0|D|9|0|W|D|0|0|0|0|I|F|16|G|0|C|8|2Q|G|0|9|8|0|6|G|1W|A|0|9|G|1V|G|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|C|3|D|5|6|7|17|8|@$E|18|F|19|G|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|1A|8|@$E|1B|F|1C|G|H]]|9|@]|A|$]]|$1|K|3|L|5|6|7|1D|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1E|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1F|8|@]|9|@]|A|$R|S]]|$1|T|3|U|5|6|7|1G|8|@$E|1H|F|1I|G|H]|$E|1J|F|1K|G|H]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1L|8|@$E|1M|F|1N|G|H]|$E|1O|F|1P|G|H]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1Q|8|@$E|1R|F|1S|G|H]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1T|8|@$E|1U|F|1V|G|H]|$E|1W|F|1X|G|H]]|9|@]|A|$]]|$1|11|3|12|5|6|7|1Y|8|@$E|1Z|F|20|G|H]|$E|21|F|22|G|H]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|23|8|@]|9|@]|A|$]]]|14|$]]

I'd like to thank the answer by Apostolos for bringing this to my attention. Here's a much more detailed example for Python 3 in the year 2019, with a clearer description and example code.

<hr>

<h2>Beware of the fact that <code>destroy()</code> (or not having a custom window closing handler at all) will destroy the window and all of its running callbacks instantly when the user closes it.</h2>

This can be bad for you, depending on your current Tkinter activity, and especially when using <code>tkinter.after</code> (periodic callbacks). You might be using a callback which processes some data and writes to disk... in that case, you obviously want the data writing to finish without being abruptly killed.

The best solution for that is to use a flag. So when the user requests window closing, you mark that as a flag, and then react to it.

(Note: I normally design GUIs as nicely encapsulated classes and separate worker threads, and I definitely don't use "global" (I use class instance variables instead), but this is meant to be a simple, stripped-down example to demonstrate how Tk abruptly kills your periodic callbacks when the user closes the window...)

<pre class="lang-py prettyprint-override"><code>from tkinter import *
import time

# Try setting this to False and look at the printed numbers (1 to 10)
# during the work-loop, if you close the window while the periodic_call
# worker is busy working (printing). It will abruptly end the numbers,
# and kill the periodic callback! That's why you should design most
# applications with a safe closing callback as described in this demo.
safe_closing = True

# ---------

busy_processing = False
close_requested = False

def close_window():
 global close_requested
 close_requested = True
 print("User requested close at:", time.time(), "Was busy processing:", busy_processing)

root = Tk()
if safe_closing:
 root.protocol("WM_DELETE_WINDOW", close_window)
lbl = Label(root)
lbl.pack()

def periodic_call():
 global busy_processing

 if not close_requested:
 busy_processing = True
 for i in range(10):
 print((i+1), "of 10")
 time.sleep(0.2)
 lbl["text"] = str(time.time()) # Will error if force-closed.
 root.update() # Force redrawing since we change label multiple times in a row.
 busy_processing = False
 root.after(500, periodic_call)
 else:
 print("Destroying GUI at:", time.time())
 try: # "destroy()" can throw, so you should wrap it like this.
 root.destroy()
 except:
 # NOTE: In most code, you'll wanna force a close here via
 # "exit" if the window failed to destroy. Just ensure that
 # you have no code after your `mainloop()` call (at the
 # bottom of this file), since the exit call will cause the
 # process to terminate immediately without running any more
 # code. Of course, you should NEVER have code after your
 # `mainloop()` call in well-designed code anyway...
 # exit(0)
 pass

root.after_idle(periodic_call)
root.mainloop()
</code></pre>

This code will show you that the <code>WM_DELETE_WINDOW</code> handler runs even while our custom <code>periodic_call()</code> is busy in the middle of work/loops!

We use some pretty exaggerated <code>.after()</code> values: 500 milliseconds. This is just meant to make it very easy for you to see the difference between closing while the periodic call is busy, or not... If you close while the numbers are updating, you will see that the <code>WM_DELETE_WINDOW</code> happened while your periodic call "was busy processing: True". If you close while the numbers are paused (meaning that the periodic callback isn't processing at that moment), you see that the close happened while it's "not busy".

In real-world usage, your <code>.after()</code> would use something like 30-100 milliseconds, to have a responsive GUI. This is just a demonstration to help you understand how to protect yourself against Tk's default "instantly interrupt all work when closing" behavior.

In summary: Make the <code>WM_DELETE_WINDOW</code> handler set a flag, and then check that flag periodically and manually <code>.destroy()</code> the window when it's safe (when your app is done with all work).

PS: You can also use <code>WM_DELETE_WINDOW</code> to ask the user if they REALLY want to close the window; and if they answer no, you don't set the flag. It's very simple. You just show a messagebox in your <code>WM_DELETE_WINDOW</code> and set the flag based on the user's answer.

blocks|key|3368896|text|我说更简单的方法是使用break命令，比如|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3368897|import+tkinter+as+tk
win=tk.Tk
def+exit():
++++break
btn=+tk.Button(win,+text="press+to+exit",+command=exit)
win.mainloop()|code-block|syntax|javascript|3368898|或者使用sys.exit()|3368899|import+tkinter+as+tk
import+sys
win=tk.Tk
def+exit():
++++sys.exit
btn=+tk.Button(win,+text="press+to+exit",+command=exit)
win.mainloop()|3368900|entityMap^0|B|5|0|0|4|A|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

i say a lot simpler way would be using the <code>break</code> command, like
<pre><code>import tkinter as tk
win=tk.Tk
def exit():
 break
btn= tk.Button(win, text=&quot;press to exit&quot;, command=exit)
win.mainloop()
</code></pre>
OR use <code>sys.exit()</code>
<pre><code>import tkinter as tk
import sys
win=tk.Tk
def exit():
 sys.exit
btn= tk.Button(win, text=&quot;press to exit&quot;, command=exit)
win.mainloop()
</code></pre>

blocks|key|3155998|text|如果您想更改x按钮的功能，或者使其无法关闭，请尝试此操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3155999|yourwindow.protocol("WM_DELETE_WINDOW",+whatever)|code-block|syntax|javascript|3156000|那就无视“无论”是什么意思|3156001|def+whatever():
++++#+Replace+this+with+your+own+event+for+example:
++++print("oi+don't+press+that+button")|3156002|您还可以这样做，以便在关闭该窗口时可以像这样回调它|3156003|yourwindow.withdraw()+|3156004|这会隐藏窗口，但不会将其关闭|3156005|yourwindow.deiconify()|3156006|这将使窗口再次可见|3156007|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

If you want to change what the x button does or make it so that you cannot close it at all try this.
<pre><code>yourwindow.protocol(&quot;WM_DELETE_WINDOW&quot;, whatever)
</code></pre>
then defy what &quot;whatever&quot; means
<pre><code>def whatever():
 # Replace this with your own event for example:
 print(&quot;oi don't press that button&quot;)
</code></pre>
You can also make it so that when you close that window you can call it back like this
<pre><code>yourwindow.withdraw() 
</code></pre>
This hides the window but does not close it
<pre><code>yourwindow.deiconify()
</code></pre>
This makes the window visible again

blocks|key|3368918|text|您应该使用destroy()关闭tkinter窗口。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3368919|+++from+Tkinter+import+*
+++root+=+Tk()
+++Button(root,+text="Quit",+command=root.destroy).pack()
+++root.mainloop()|code-block|syntax|javascript|3368920|解释：|3368921|root.quit()上面的代码行只是绕过了root.mainloop()，也就是说，如果执行quit()命令，root.mainloop()仍将在后台运行。|offset|length|style|CODE|3368922|root.destroy()而destroy()命令消失root.mainloop()，即root.mainloop()停止。|3368923|因此，由于您只想退出程序，所以您应该使用root.destroy()，因为它将停止主循环()`。|3368924|但是如果你想运行一些无限循环，又不想破坏你的Tk窗口，又想在root.mainloop()行之后执行一些代码，那么你应该使用root.quit()。例如：|3368925|from+Tkinter+import+*
def+quit():
++++global+root
++++root.quit()

root+=+Tk()
while+True:
++++Button(root,+text="Quit",+command=quit).pack()
++++root.mainloop()
++++#do+something|3368926|entityMap^0|0|0|0|0|B|M|F|1B|6|1K|F|0|0|E|F|9|S|F|19|F|0|K|E|0|U|F|1Q|B|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|11|8|@$K|12|L|13|M|N]|$K|14|L|15|M|N]|$K|16|L|17|M|N]|$K|18|L|19|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$K|1B|L|1C|M|N]|$K|1D|L|1E|M|N]|$K|1F|L|1G|M|N]|$K|1H|L|1I|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@$K|1K|L|1L|M|N]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1M|8|@$K|1N|L|1O|M|N]|$K|1P|L|1Q|M|N]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|X|$]]

You should use destroy() to close a tkinter window.
<pre><code> from Tkinter import *
 root = Tk()
 Button(root, text=&quot;Quit&quot;, command=root.destroy).pack()
 root.mainloop()
</code></pre>
Explanation:
<code>root.quit()</code>
The above line just Bypasses the <code>root.mainloop()</code> i.e <code>root.mainloop()</code> will still be running in background if <code>quit()</code> command is executed.
<code>root.destroy()</code>
While <code>destroy()</code> command vanish out <code>root.mainloop()</code> i.e <code>root.mainloop()</code> stops.
So as you just want to quit the program so you should use <code>root.destroy()</code> as it will it stop the mainloop()`.
But if you want to run some infinite loop and you don't want to destroy your Tk window and want to execute some code after <code>root.mainloop()</code> line then you should use <code>root.quit()</code>.
Ex:
<pre><code>from Tkinter import *
def quit():
 global root
 root.quit()

root = Tk()
while True:
 Button(root, text=&quot;Quit&quot;, command=quit).pack()
 root.mainloop()
 #do something
</code></pre>

blocks|key|3368938|text|最简单的代码是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3368939|from+tkinter+import+*
window+=+Tk()|code-block|syntax|javascript|3368940|用于隐藏窗口：window.withdraw()|offset|length|style|CODE|3368941|用于显示窗口：window.deiconify()|3368942|用于从窗口退出：exit()|3368943|用于从窗口退出(如果您已经创建了.exe文件)：|3368944|from+tkinter+import+*
import+sys
window+=+Tk()
sys.exit()|3368945|当然，您必须放置一个按钮并在函数中使用上面的代码，以便可以在按钮的命令部分中键入函数的名称|3368946|entityMap^0|0|0|7|H|0|7|I|0|8|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@$I|14|J|15|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@$I|17|J|18|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|X|$]]

The easiest code is:
<pre><code>from tkinter import *
window = Tk()
</code></pre>
For hiding the window : <code>window.withdraw()</code>
For appearing the window : <code>window.deiconify()</code>
For exiting from the window : <code>exit()</code>
For exiting from the window(If you've made a .exe file) :
<pre><code>from tkinter import *
import sys
window = Tk()
sys.exit()
</code></pre>
And of course you have to place a button and use the codes above in a function so you can type the function's name in the command part of the button

How do I handle the window close event (user clicking the 'X' button) in a Python Tkinter program?

How do I handle the window close event in Tkinter?

Python

如何处理Python Tkinter程序中的窗口关闭事件(用户单击“X”按钮)？

问如何处理Tkinter中的窗口关闭事件？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何处理Tkinter中的窗口关闭事件？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何处理Tkinter中的窗口关闭事件？
EN