问题描述：

Button假设我使用 Python 中的 Tkinter 完成了以下内容：

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 循环中创建按钮并传递命令参数以了解详细信息。

解决方案 1：

这可以使用 来完成lambda，如下所示：

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

这是一种绑定参数的简单方法，无需使用显式的包装方法或修改原始方法action。

解决方案 2：

partial这也可以通过使用标准库functools来完成，如下所示：

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

解决方案 3：

示例 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选项应该设置为我们想要调用的方法的引用，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_handlewith内部调用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()

镜子

解决方案 4：

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

解决方案 5：

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

解决方案 6：

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

解决方案 7：

使用 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

解决方案 8：

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”等。如果您需要除事件属性之外的一个或多个参数，只需创建一个字典来存储它们即可。

解决方案 9：

一种简单的方法是button使用lambda以下语法进行配置：

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

解决方案 10：

它立即调用该方法而按下按钮不执行任何操作的原因是，它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()

解决方案 11：

我已经很晚了，但是这是一个非常简单的实现方法。

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

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

解决方案 12：

另一种方法是定义一个类并使用实例属性来记住回调的参数。要实现回调，我们可以简单地使用类的一个方法来查找属性值self- 它根本不需要单独的参数。

像这样创建类：

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
# when `button1` is clicked later and `instance1.func` is called,
# `self.x` will use the new value.

解决方案 13：

如果您有更多操作要执行，请使用 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 风格的编写方法，但对我来说，这种方法很有效。

解决方案 14：

首先：如果将创建按钮的代码放在循环中，则Button每次循环时都会重新创建实例，这可能是或可能不是所希望的。

它总是获取最后一个索引的原因是回调在单击按钮时运行，而不是在程序启动时运行。尝试在创建按钮时存储变量的值，然后使用lambda存储的值。

例如：

for entry in stuff_that_is_happening:
    value_store[entry] = stuff_that_is_happening

然后，稍后：

Button(..., command= lambda: value_store[1])