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

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

你可以简单地认为命令选项应该被设置为，我们想要被调用的方法的引用，类似于button_press_handle中的callback。

---

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

不带参数

所以，如果我想在按下按钮时打印一些东西，我需要设置:

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

请密切注意print方法中()的缺失，该方法被省略的含义是:“这是我希望您在按下时调用的方法名称，但不要立即调用它。”然而，我没有为打印传递任何参数，所以它在不带参数的情况下调用时打印任何东西。

论点(年代)

现在，如果我还想将参数传递给我想在按下按钮时被调用的方法，我可以使用匿名函数，它可以用lambda语句创建，在这种情况下用于打印内置方法，如下所示:

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

---

按下按钮时调用多个方法

不带参数

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

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不能真正返回，因为它只在button_press_handle中调用callback()，而不是return callback()。它会返回，但不会在函数之外的任何地方返回。因此，您应该修改当前范围内可访问的对象。

---

全局对象修改的完整示例

下面的例子将调用一个方法，在每次按下按钮时更改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()

---

镜子

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

JasonPy -一些事情…

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

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

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

for entry in stuff_that_is_happening:
    value_store[entry] = stuff_that_is_happening

然后你可以说....

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

希望这能有所帮助!

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

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

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

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