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

应该能解决这个问题

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

我要做的是创建一个类，其对象将包含所需的每个变量和根据需要更改这些变量的方法:

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

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

---

镜子

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

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

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

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

应该能解决这个问题

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

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