如何在Tkinter中传递参数到按钮命令?

假设我在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))

这只是立即调用方法，按下按钮什么也不做。

参见Python参数绑定器了解解决问题的标准技术(不是特定于tkinter的)。在Tkinter(或其他GUI框架)中使用回调有一些特殊的考虑，因为回调的返回值是无用的。

如果你试图在一个循环中创建多个按钮，根据循环计数器传递每个不同的参数，你可能会遇到问题，因为所谓的后期绑定。详情请参见tkinter在for循环中创建按钮，传递命令参数。

417081 次浏览
小开
最佳答案

我个人更喜欢在这种情况下使用lambdas，因为在我看来，它更清晰、更简单，而且如果你不能控制被调用的方法，也不会强迫你写很多包装器方法，但这当然是个人品味的问题。

这就是你使用lambda的方式(注意，在函数模块中也有一些curry的实现，所以你也可以使用它):

button = Tk.Button(master=frame, text='press', command= lambda: action(someNumber))
小开

Python为函数参数提供默认值的能力为我们提供了一条出路。

def fce(x=myX, y=myY):
myFunction(x,y)
button = Tk.Button(mainWin, text='press', command=fce)

看:https://tkdocs.com/shipman/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))
小开

这也可以通过使用标准库functools中的partial来实现，如下所示:

from functools import partial
#(...)
action_with_arg = partial(action, arg)
button = Tk.Button(master=frame, text='press', command=action_with_arg)
小开

它立即调用方法而不按按钮的原因是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()
小开

如果你有更多的操作要执行，使用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

这将把事件中的信息传递给按钮函数。可能有更多python式的方法来写这个，但它适合我。

小开

JasonPy -一些事情…

如果你在一个循环中插入一个按钮，它将会被一遍又一遍地创建……这可能不是你想要的。(也许是)……

它总是得到最后一个索引的原因是lambda事件在您单击它们时运行，而不是在程序启动时运行。我不确定100%你在做什么，但也许试着在创建时存储值，然后用按钮调用它。

例:(不要使用这段代码，只是一个例子)

for entry in stuff_that_is_happening:
value_store[entry] = stuff_that_is_happening

然后你可以说....

button... command: lambda: value_store[1]

希望这能有所帮助!

小开

一种简单的方法是使用lambda配置button，如下所示:

button['command'] = lambda arg1 = local_var1, arg2 = local_var2 : function(arg1, arg2)
小开

GUI示例:

假设我有一个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选项应该设置为，对我们想要调用的方法的引用，类似于button_press_handle中的callback。

当按钮被按下时调用方法(回调)

< em > < / em >参数

因此，如果我想在按钮按下时print某个东西，我需要设置:

btn['command'] = print # default to print is new line

使用print方法密切注意()的缺乏，该方法被省略的含义是:"这是方法名，我想让你在按时调用它但时不要立即调用它"然而，我没有为print传递任何参数，因此它在不带参数的调用时打印它打印的任何东西。

< em >与< / em >参数(s)

现在，如果我想在按下按钮时也将参数传递给我想被调用的方法，我可以使用匿名函数，该函数可以用λ语句创建，在本例中为print内置方法，如下所示:

btn['command'] = lambda arg1="Hello", arg2=" ", arg3="World!" : print(arg1 + arg2 + arg3)

当按钮被按下时调用多个方法

< em > < / em >参数

你也可以使用lambda语句来实现，但这被认为是不好的做法，因此我不会在这里包括它。好的做法是定义一个单独的方法multiple_methods，它调用所需的方法，然后将其设置为按钮按下的回调:

def multiple_methods():
print("Vicariously") # the first inner callback
print("I") # another inner callback

< em >与< / em >参数(s)

为了将参数传递给调用其他方法的方法，再次使用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()

镜子< a href = " https://stackoverflow.com/a/47980499/7032856 " > < / >

小开

对于后代:您还可以使用类来实现类似的功能。例如:

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来改变函数参数。

小开 
button = Tk.Button(master=frame, text='press', command=lambda: action(someNumber))

应该能解决这个问题

小开

基于Matt thompson的回答:一个类可以被设置为可调用的，这样它就可以代替函数使用:

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()
小开

最好的方法是使用lambda，如下所示:

button = Tk.Button(master=frame, text='press', command=lambda: action(someNumber))
小开

我迟到了，但有一个很简单的方法。

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()

您只需将想要使用的函数包装到另一个函数中，并在按下按钮时调用第二个函数。

小开

Lambdas都很好，但你也可以试试这个(顺便说一句，它在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”等。如果需要一个参数或事件属性以外的多个参数。只需创建一个字典来存储它们。

小开
我以前也遇到过这个问题。 你可以使用lambda:

button = Tk.Button(master=frame, text='press',command=lambda: action(someNumber))
小开

你需要使用lambda:

button = Tk.Button(master=frame, text='press', command=lambda: action(someNumber))
小开

使用λ

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
小开

为了让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，该变量的值在定义按钮时得到固定。


提交答案