假设我在Python中使用Tkinter制作了以下Button：
import Tkinter as Tk
win = Tk.Toplevel()
frame = Tk.Frame(master=win).grid(row=1, column=1)
button = Tk.Button(master=frame, text='press', command=action)
当我按下按钮时调用方法action，但是如果我想将一些参数传递给方法action怎么办？
我尝试过使用以下代码：
button = Tk.Button(master=frame, text='press', command=action(someNumber))
这只是立即调用方法，按下按钮什么也不做。
答案 0 :(得分：198)
我个人更喜欢在这种情况下使用lambdas，因为它更清晰，更简单，如果你无法控制被调用的方法，也不会强迫你编写大量的包装器方法，但是这当然是一种品味问题。
这就是你用lambda做的事情（注意功能模块中还有一些currying的实现，所以你也可以使用它）：
button = Tk.Button(master=frame, text='press', command= lambda: action(someNumber))
答案 1 :(得分：60)
也可以使用标准库functools中的partial来完成此操作，如下所示：
from functools import partial
#(...)
action_with_arg = partial(action, arg)
button = Tk.Button(master=frame, text='press', command=action_with_arg)
答案 2 :(得分：9)
假设我有GUI：
import tkinter as tk
root = tk.Tk()
btn = tk.Button(root, text="Press")
btn.pack()
root.mainloop()
请注意，当按下btn时，它会调用自己的函数，该函数与以下示例中的button_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'])
您可以简单地认为应将command选项设置为我们要调用的方法的引用，类似于callback中的button_press_handle。
没有参数
因此，如果我想在按下按钮时print，我需要设置：
btn['command'] = print # default to print is new line
使用()方法密切关注print的缺少，其中含义为：“这是我想要的方法名称按时调用，但暂时不调用它。“但是，我没有为print传递任何参数，所以它打印了它打印的任何内容在没有参数的情况下调用。
使用参数
现在如果我想在按下按钮的同时将参数传递给我想要调用的方法，我可以使用匿名函数，可以使用lambda创建语句，在本例中为print内置方法，如下所示：
btn['command'] = lambda arg1="Hello", arg2=" ", arg3="World!" : print(arg1 + arg2 + arg3)
没有参数
您也可以使用lambda语句来实现这一点，但这被认为是不好的做法，因此我不会在此处包含它。好的做法是定义一个单独的方法multiple_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)
另外请注意，callback实际上不能return，因为它仅在button_press_handle内调用callback()而不是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()
答案 3 :(得分：8)
Python为函数参数提供默认值的能力为我们提供了一条出路。
def fce(x=myX, y=myY):
myFunction(x,y)
button = Tk.Button(mainWin, text='press', command=fce)
请参阅：http://infohost.nmt.edu/tcc/help/pubs/tkinter/web/extra-args.html
如需更多按钮，您可以创建一个返回功能的功能：
def fce(myX, myY):
def wrapper(x=myX, y=myY):
pass
pass
pass
return x+y
return wrapper
button1 = Tk.Button(mainWin, text='press 1', command=fce(1,2))
button2 = Tk.Button(mainWin, text='press 2', command=fce(3,4))
button3 = Tk.Button(mainWin, text='press 3', command=fce(9,8))
答案 4 :(得分：1)
只是让Nae的答案更加详尽，这是一个完整的示例，其中包括将变量传递给回调的可能性，该回调包含每个按钮的不同值：
import tkinter as tk
def callback(text):
print(text)
top = tk.Tk()
Texts=["text1", "text2", "text3"]
Buttons=[]
for i, z in enumerate(Texts):
Buttons.append(tk.Button(top, text=z, command= lambda ztemp=z : callback(ztemp)))
Buttons[i].pack(side=tk.LEFT, padx=5)
top.mainloop()
通过定义临时变量ztemp，在定义按钮时该变量的值将固定。
答案 5 :(得分：1)
使用lambda
import tkinter as tk
root = tk.Tk()
def go(text):
print(text)
b = tk.Button(root, text="Click", command=lambda: go("hello"))
b.pack()
root.mainloop()
输出：
hello
答案 6 :(得分：1)
您需要使用lambda:
button = Tk.Button(master=frame, text='press', command=lambda: action(someNumber))
答案 7 :(得分：1)
button = Tk.Button(master=frame, text='press', command=lambda: action(someNumber))
我认为应该解决这个问题
答案 8 :(得分：1)
一种简单的方法是使用button配置lambda，如下面的语法：
button['command'] = lambda arg1 = local_var1, arg2 = local_var2 : function(arg1, arg2)
答案 9 :(得分：1)
它立即调用方法并按下按钮的原因是action(somenumber)被评估，其返回值被归为按钮的命令。因此，如果action打印某些内容告诉您它已运行并返回None，则只需运行action来评估其返回值，并将None作为按钮的命令。
要使按钮调用具有不同参数的函数，您可以使用全局变量，但我无法推荐它：
import Tkinter as Tk
frame = Tk.Frame(width=5, height=2, bd=1, relief=Tk.SUNKEN)
frame.grid(row=2,column=2)
frame.pack(fill=Tk.X, padx=5, pady=5)
def action():
global output
global variable
output.insert(Tk.END,variable.get())
button = Tk.Button(master=frame, text='press', command=action)
button.pack()
variable = Tk.Entry(master=frame)
variable.pack()
output = Tk.Text(master=frame)
output.pack()
if __name__ == '__main__':
Tk.mainloop()
我要做的是创建一个class，其对象将包含所需的每个变量以及根据需要更改这些变量的方法：
import Tkinter as Tk
class Window:
def __init__(self):
self.frame = Tk.Frame(width=5, height=2, bd=1, relief=Tk.SUNKEN)
self.frame.grid(row=2,column=2)
self.frame.pack(fill=Tk.X, padx=5, pady=5)
self.button = Tk.Button(master=self.frame, text='press', command=self.action)
self.button.pack()
self.variable = Tk.Entry(master=self.frame)
self.variable.pack()
self.output = Tk.Text(master=self.frame)
self.output.pack()
def action(self):
self.output.insert(Tk.END,self.variable.get())
if __name__ == '__main__':
window = Window()
Tk.mainloop()
答案 10 :(得分：0)
对于后代：你也可以使用类来实现类似的东西。例如：
class Function_Wrapper():
def __init__(self, x, y, z):
self.x, self.y, self.z = x, y, z
def func(self):
return self.x + self.y + self.z # execute function
然后可以通过以下方式简单地创建按钮：
instance1 = Function_Wrapper(x, y, z)
button1 = Button(master, text = "press", command = instance1.func)
此方法还允许您通过设置instance1.x = 3来更改函数参数。
答案 11 :(得分：0)
在Matt Thompsons的基础上回答：一个类可以调用，因此可以使用它而不是函数：
import tkinter as tk
class Callback:
def __init__(self, func, *args, **kwargs):
self.func = func
self.args = args
self.kwargs = kwargs
def __call__(self):
self.func(*self.args, **self.kwargs)
def default_callback(t):
print("Button '{}' pressed.".format(t))
root = tk.Tk()
buttons = ["A", "B", "C"]
for i, b in enumerate(buttons):
tk.Button(root, text=b, command=Callback(default_callback, b)).grid(row=i, column=0)
tk.mainloop()
答案 12 :(得分：0)
最好的方法是如下使用lambda：
button = Tk.Button(master=frame, text='press', command=lambda: action(someNumber))
答案 13 :(得分：0)
Lambda都很好，但是您也可以尝试一下（在for循环中顺便说一句）：
root = Tk()
dct = {"1": [*args], "2": [*args]}
def keypress(event):
*args = dct[event.char]
for arg in args:
pass
for i in range(10):
root.bind(str(i), keypress)
之所以起作用，是因为设置了绑定后，按键将事件作为参数传递。然后，您可以取消事件的属性，例如event.char，以获取“ 1”或“ UP”等。如果需要一个或多个事件属性以外的参数。只需创建一个字典来存储它们。
答案 14 :(得分：0)
我以前也遇到过这个问题。 您可以只使用lambda：
button = Tk.Button(master=frame, text='press',command=lambda: action(someNumber))
答案 15 :(得分：0)
JasonPy - 一些事情......
如果你在循环中粘贴一个按钮，它将一遍又一遍地创建......这可能不是你想要的。 （也许是）......
它总是获取最后一个索引的原因是单击它们时运行的lambda事件 - 而不是程序启动时。我不确定你正在做什么，但可能会尝试存储它的值，然后用lambda按钮调用它。
例如:(不要使用此代码，只是一个例子）
for entry in stuff_that_is_happening:
value_store[entry] = stuff_that_is_happening
然后你可以说......
button... command: lambda: value_store[1]
希望这有帮助！
答案 16 :(得分：0)
如果您要执行更多操作，请使用lambda将条目数据传递给命令函数，如下所示（我试图使其成为通用的，所以只需适应）：
event1 = Entry(master)
button1 = Button(master, text="OK", command=lambda: test_event(event1.get()))
def test_event(event_text):
if not event_text:
print("Nothing entered")
else:
print(str(event_text))
# do stuff
这会将事件中的信息传递给按钮功能。可能有更多的Pythonesque写作方式，但它适用于我。
答案 17 :(得分：-1)
我来晚了，但是这是完成它的一种非常简单的方法。
import tkinter as tk
def function1(param1, param2):
print(str(param1) + str(param2))
var1 = "Hello "
var2 = "World!"
def function2():
function1(var1, var2)
root = tk.Tk()
myButton = tk.Button(root, text="Button", command=function2)
root.mainloop()
您只需将要使用的功能包装到另一个功能中，然后在按下按钮时调用第二个功能。