提问人：salk 提问时间：4/24/2011 最后编辑：Karl Knechtelsalk 更新时间：4/4/2023 访问量：41388
为什么我的 Button 的命令在我创建 Button 时立即执行，而不是在我单击它时执行？[复制]
Why is my Button's command executed immediately when I create the Button, and not when I click it? [duplicate]
问：
我的代码是：
from Tkinter import *
admin = Tk()
def button(an):
print(an)
print('het')
b = Button(admin, text='as', command=button('hey'))
b.pack()
mainloop()
按钮不起作用，它会在没有我的命令的情况下打印“嘿”和“嘿”一次，然后，当我按下按钮时，什么也没发生。
答：
16赞
Lukáš Lalinský
4/24/2011
#1
您需要创建一个不带参数的函数，该函数可用作命令：
b = Button(admin, text='as', command=lambda: button('hey'))
请参阅本文档的“将参数传递给回调”部分。
124赞
Bryan Oakley
4/25/2011
#2
请考虑以下代码：
b = Button(admin, text='as', command=button('hey'))
它的作用与此完全相同：
result = button('hey')
b = button(admin, text='as', command=result)
同样，如果创建如下绑定：
listbox.bind("<<ListboxSelect>>", some_function())
...和这个一样：
result = some_function()
listbox.bind("<<ListboxSelect>>", result)
该选项采用对函数的引用，这是一种花哨的说法，您需要将函数的名称传递给它。若要传递引用，必须仅使用名称，而不使用括号或参数。例如：command
b = Button(... command = button)
如果要传递诸如“hey”之类的参数，则必须使用一些额外的代码：
- 您可以创建一个中间函数，该函数可以在没有参数的情况下调用，然后调用您的函数，
button - 您可以使用它来创建所谓的匿名函数。在各个方面，它都是一个函数，只是它没有名称。调用该命令时，它会返回对所创建函数的引用，这意味着它可以用于按钮的选项值。
lambdalambdacommand - 可以使用 functools.partial
对我来说，是最简单的，因为它不需要像 do 那样的任何额外导入，尽管有些人认为这更容易理解。lambdafunctools.partialfunctools.partial
要创建一个使用参数调用函数的 lambda 函数，您可以执行如下操作：button
lambda: button('hey')
您最终会得到一个功能等效于以下函数的函数：
def some_name():
return button('hey')
正如我之前所说，返回对这个无名函数的引用。由于引用是该选项所期望的，因此您可以在创建按钮时直接使用：lambdacommandlambda
b = Button(... command = lambda: button('hey'))
这个网站上有一个问题，总的来说，有很多关于 lambda 的有趣评论。请参阅问题为什么 Python lambda 有用？。同样的讨论有一个答案，它显示了当您需要将变量传递给回调时如何在循环中使用 lambda。
最后，请参阅标题为 Tkinter Callbacks 的 zone.effbot.org 文章，以获取一个不错的教程。覆盖范围非常薄弱，但那里的信息可能仍然有用。lambda
15赞
Nae
12/26/2017
#3
GUI 示例：
假设我有 GUI：
import tkinter as tk
root = tk.Tk()
btn = tk.Button(root, text="Press")
btn.pack()
root.mainloop()
按下按钮时会发生什么
可以看到，当按下时，它会调用自己的函数，这与以下示例非常相似：btnbutton_press_handle
def button_press_handle(callback=None):
if callback:
callback() # Where exactly the method assigned to btn['command'] is being callled
跟：
button_press_handle(btn['command'])
您可以简单地认为该选项应该设置为对我们想要调用的方法的引用，类似于 中。commandcallbackbutton_press_handle
按下按钮时调用方法（回调）
没有参数
因此，如果我想在按下按钮时做某事，我需要设置：print
btn['command'] = print # default to print is new line
请密切注意方法的缺失，该方法在以下含义中被省略：“这是方法的名称，我希望你在按下时调用它，但不要只是现在调用它。但是，我没有传递任何参数，因此它在没有参数的情况下调用时打印了任何打印的内容。()printprint
跟参数
现在，如果我还想将参数传递给我希望在按下按钮时被调用的方法，我可以使用匿名函数，这些函数可以使用 lambda 语句创建，在本例中为内置方法，如下所示：print
btn['command'] = lambda arg1="Hello", arg2=" ", arg3="World!" : print(arg1 + arg2 + arg3)
按下按钮时调用多个方法
没有参数
您也可以使用 语句实现这一点，但这被认为是不好的做法，因此我不会在这里包含它。好的做法是定义一个单独的方法，调用所需的方法，然后将其设置为按钮按下的回调：lambdamultiple_methods
def multiple_methods():
print("Vicariously") # the first inner callback
print("I") # another inner callback
跟参数
为了将参数传递给调用其他方法的方法，请再次使用语句，但首先：lambda
def multiple_methods(*args, **kwargs):
print(args[0]) # the first inner callback
print(kwargs['opt1']) # another inner callback
然后设置：
btn['command'] = lambda arg="live", kw="as the" : a_new_method(arg, opt1=kw)
从回调返回对象
还要进一步注意，不能真的，因为它只在里面调用，而不是 .它确实如此，但不在该功能之外的任何地方。因此，您应该修改在当前范围内可访问的对象。callbackreturnbutton_press_handlecallback()return callback()return
具有全局对象修改的完整示例
下面的示例将调用一个方法，该方法在每次按下按钮时更改文本：btn
import tkinter as tk
i = 0
def text_mod():
global i, btn # btn can be omitted but not sure if should be
txt = ("Vicariously", "I", "live", "as", "the", "whole", "world", "dies")
btn['text'] = txt[i] # the global object that is modified
i = (i + 1) % len(txt) # another global object that gets modified
root = tk.Tk()
btn = tk.Button(root, text="My Button")
btn['command'] = text_mod
btn.pack(fill='both', expand=True)
root.mainloop()
4赞
C.Vergnaud
11/1/2018
#4
引擎在为“...命令 = ...”
“command”期望返回一个函数，这就是为什么使用 lambda 可以完成这项工作的原因，因为它正在创建一个异常函数，该函数在评估期间返回给“command”。 你也可以编写自己的函数，它也会完成这项工作。
以下是使用 lambda 和不使用 lambda 的示例：
#!/usr/bin/python
# coding=utf-8
from Tkinter import *
# Creation de la fenêtre principale (main window)
Mafenetre = Tk()
res1 = StringVar()
res2 = StringVar()
def isValidInput(obj):
if hasattr(obj, 'get') and callable(getattr(obj, 'get')):
return TRUE
return FALSE
# stupid action 2 (return 12 on purpose to show potential mistake)
def action1(*arguments):
print "action1 running"
for arg in arguments:
if isValidInput(arg):
print "input value: ", arg.get()
res1.set(arg.get())
else:
print "other value:", arg
print "\n"
return 12
# stupid action 2
def action2(*arguments):
print "action2 running"
a = arguments[0]
b = arguments[1]
if isValidInput(a) and isValidInput(b):
c = a.get() + b.get()
res2.set(c)
print c
print "\n"
# a stupid workflow manager ordered by name
def start_tasks(*arguments, **keywords):
keys = sorted(keywords.keys())
for kw in keys:
print kw, "plugged "
keywords[kw](*arguments)
# valid callback wrapper with lambda
def action1_callback(my_input):
return lambda args=[my_input]: action1(*args)
# valid callback wrapper without lambda
def action1_callback_nolambda(*args, **kw):
def anon():
action1(*args)
return anon
# first input string
input1 = StringVar()
input1.set("delete me...")
f1 = Entry(Mafenetre, textvariable=input1, bg='bisque', fg='maroon')
f1.focus_set()
f1.pack(fill="both", expand="yes", padx="5", pady=5)
# failed callback because the action1 function is evaluated, it will return 12.
# in this case the button won't work at all, because the assignement expect a function
# in order to have the button command to execute something
ba1 = Button(Mafenetre)
ba1['text'] = "show input 1 (ko)"
ba1['command'] = action1(input1)
ba1.pack(fill="both", expand="yes", padx="5", pady=5)
# working button using a wrapper
ba3 = Button(Mafenetre)
ba3['text'] = "show input 1 (ok)"
# without a lambda it is also working if the assignment is a function
#ba1['command'] = action1_callback_nolambda(input1)
ba3['command'] = action1_callback(input1)
ba3.pack(fill="both", expand="yes", padx="5", pady=5)
# display result label
Label1 = Label(Mafenetre, text="Action 1 result:")
Label1.pack(fill="both", expand="yes", padx="5", pady=5)
# display result value
resl1 = Label(Mafenetre, textvariable=res1)
resl1.pack(fill="both", expand="yes", padx="5", pady=5)
# second input string
input2 = StringVar()
f2 = Entry(Mafenetre, textvariable=input2, bg='bisque', fg='maroon')
f2.focus_set()
f2.pack(fill="both", expand="yes", padx="5", pady=5)
# third test without wrapper, but making sure that several arguments are well handled by a lambda function
ba2 = Button(Mafenetre)
ba2['text'] = "execute action 2"
ba2['command'] = lambda args=[input1, input2], action=action2: start_tasks(*args, do=action)
ba2.pack(fill="both", expand="yes", padx="5", pady=5)
# display result label
Label2 = Label(Mafenetre, text="Action 2 result:")
Label2.pack(fill="both", expand="yes", padx="5", pady=5)
# display result value
resl2 = Label(Mafenetre, textvariable=res2)
resl2.pack(fill="both", expand="yes", padx="5", pady=5)
Mafenetre.mainloop()
3赞
Deer Lawson
8/29/2020
#5
我认为解决这个问题的最好方法是使用 lambda 函数。
from tkinter import *
admin= Tk()
def button(an):
print(an)
print("het")
b = Button(admin, text="as", command=lambda: button("hey"))
b.pack()
mainloop()
如果不想使用 command 关键字，可以改用 .bind（） 方法：
from tkinter import *
admin= Tk()
def button(an):
print(an)
print("het")
b = Button(admin, text="as")
b.pack()
b.bind("<Button-1>", lambda bb: button("hey"))
mainloop()
使用拥有要调用的子函数（至少 1 个参数）的母函数（无参数）是愚蠢的。
只是为了和你分享，这是我的程序之一：
import tkinter
window = tkinter.Tk()
def plus_them(field_1, field_2, field_3):
field_3.delete(0, 'end')
num1 = 0
num2 = 0
try:
num1 = int(field_1.get())
num2 = int(field_2.get())
except:
print("Exception occurs")
else:
print("Continue")
result = num1 + num2
field_3.insert(tkinter.END, str(result))
return result
def minus_them(field_1, field_2, field_3):
field_3.delete(0, 'end')
num1 = 0
num2 = 0
try:
num1 = int(field_1.get())
num2 = int(field_2.get())
except:
print("Exception occurs")
else:
print("Continue")
result = num1 - num2
field_3.insert(tkinter.END, str(result))
return result
#Input Panel:
label_1 = tkinter.Label(window, text="First Number:")
label_1.grid(row=0, column=0)
label_2 = tkinter.Label(window, text="Second Number:")
label_2.grid(row=1, column=0)
entry_1 = tkinter.Entry(window)
entry_1.grid(row=0, column=1)
entry_2 = tkinter.Entry(window)
entry_2.grid(row=1, column=1)
#Button Panel:
button_1 = tkinter.Button(window, text="Plus")
button_1.grid(row=2, column=0)
button_2 = tkinter.Button(window, text="Minus")
button_2.grid(row=2, column=1)
#Answer Panel:
label_3 = tkinter.Label(window, text="The Answer:")
label_3.grid(row=3, column=0)
entry_3 = tkinter.Entry(window)
entry_3.grid(row=3, column=1)
#Event Handling:
button_1.bind("<Button-1>", lambda p: plus_them(entry_1, entry_2, entry_3))
button_2.bind("<Button-1>", lambda m: minus_them(entry_1, entry_2, entry_3))
#Window Stuff:
window.title("Plus and Minus Calculator")
window.mainloop()
就是这样。
评论