Как передать аргументы команде Button в Tkinter?
Предположим, у меня есть следующее Button сделано с Tkinter в Python:
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))
Это сразу вызывает метод, и нажатие кнопки ничего не делает.
11 ответов
Я лично предпочитаю использовать lambdas в таком сценарии, потому что imo все яснее и проще, а также не заставляет вас писать множество методов-оболочек, если у вас нет контроля над вызываемым методом, но это, безусловно, дело вкуса.
Вот как вы бы сделали это с лямбдой (обратите внимание, что в функциональном модуле также есть некоторая реализация каррирования), так что вы также можете использовать это):
button = Tk.Button(master=frame, text='press', command= lambda: action(someNumber))
Это также можно сделать с помощью partial из стандартной библиотеки functools, вот так:
from functools import partial
#(...)
action_with_arg = partial(action, arg)
button = Tk.Button(master=frame, text='press', command=action_with_arg)
Пример 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()
Способность 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))
Чтобы сделать ответ Наэ немного более сложным, вот полноценный пример, который включает возможность передать переменную в обратный вызов, которая содержит разные значения для каждой кнопки:
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 значение этой переменной фиксируется в момент определения кнопки.
Опираясь на ответ Мэтта Томпсона: класс может быть вызван так, чтобы его можно было использовать вместо функции:
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()
Используйте лямбда
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
Одним простым способом было бы настроить button с lambda как следующий синтаксис:
button['command'] = lambda arg1 = local_var1, arg2 = local_var2 : function(arg1, arg2)
Лямбды - это все хорошо, но вы также можете попробовать это (кстати, это работает в цикле 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" или "ВВЕРХ" и т. д. Если вам нужен аргумент или несколько аргументов, кроме атрибутов события. просто создайте словарь для их хранения.
button = Tk.Button(master=frame, text='press', command=lambda: action(someNumber))
Я считаю, что это нужно исправить
Я тоже сталкивался с этой проблемой раньше. Вы можете просто использовать лямбда:
button = Tk.Button(master=frame, text='press',command=lambda: action(someNumber))
Для потомков: вы также можете использовать классы для достижения чего-то похожего. Например:
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))
Я очень опоздал, но вот очень простой способ добиться этого.
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()
Вы просто оборачиваете функцию, которую хотите использовать, в другую функцию и вызываете вторую функцию при нажатии кнопки.
Причина, по которой он вызывает метод немедленно и нажатие кнопки ничего не делает, заключается в том, что 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:
button = Tk.Button(master=frame, text='press', command=lambda: action(someNumber))
Используйте лямбду для передачи входных данных в командную функцию, если вам нужно выполнить больше действий, например, вот так (я попытался сделать их общими, поэтому просто адаптируйтесь):
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 способов написания этого, но это работает для меня.
JasonPy - несколько вещей...
если вы вставите кнопку в цикл, она будет создаваться снова и снова... что, вероятно, не то, что вам нужно. (Может быть это)...
Причина, по которой он всегда получает последний индекс, заключается в том, что лямбда-события запускаются при нажатии на них, а не при запуске программы. Я не уверен на 100%, что вы делаете, но, возможно, попробуйте сохранить значение, когда оно будет сделано, затем вызовите его позже с помощью лямбда-кнопки.
Например: (не используйте этот код, просто пример)
for entry in stuff_that_is_happening:
value_store[entry] = stuff_that_is_happening
тогда ты можешь сказать....
button... command: lambda: value_store[1]
надеюсь это поможет!