Припустимо, у мене 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))

Це просто викликає метод негайно, а натискання кнопки нічого не робить.

Я особисто вважаю за краще використовуватись lambdasу такому сценарії, тому що imo це зрозуміліше і простіше, а також не змушує вас писати багато методів обгортки, якщо у вас немає контролю над названим методом, але це, безумовно, питання смаку.

Ось як би ви це зробили з лямбда (зауважте, що у функціональному модулі також є деяка реалізація currying, тож ви можете використовувати і це):

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

Це також можна зробити за допомогою partialстандартних функцій бібліотеки , таких як:

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щоб він надрукував все, що друкує, коли викликається без аргументів.

З аргументом

Тепер, якщо я хотів також передати аргументи методу, якого я хочу викликати, коли натискається кнопка, я міг би скористатися анонімними функціями, які можна створити за допомогою лямбда- оператора, в даному випадку для 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

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

Причина, коли він викликає метод негайно, і натискання кнопки нічого не робить, 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()

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

Я вважаю, що слід це виправити

Найкраще робити лямбда так:

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

Ви просто загортаєте функцію, яку хочете використовувати в іншій функції, і натискаєте другу функцію натисканням кнопки.

У лямбдів все добре і добре, але ви також можете спробувати це (що працює у циклі btw):

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отримати ect "1" або "UP". Якщо вам потрібен аргумент або кілька аргументів, крім атрибутів події. просто створіть словник для їх зберігання.

Я і раніше стикався з цією проблемою. Можна просто використовувати лямбда:

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

Це передасть інформацію про подію функції кнопки. Можливо, є ще пітонескій спосіб написання цього, але це працює для мене.

JasonPy - кілька речей ...

якщо ви вставите кнопку в циклі, вона буде створюватися знову і знову ... що, мабуть, не те, що ви хочете. (можливо, так і є) ...

Причина, коли він завжди отримує останній індекс, - це лямбда-події, які виконуються, коли ви клацаєте на них, а не тоді, коли програма запускається. Я не впевнений на 100%, що ви робите, але, можливо, спробуйте зберегти значення, коли воно зроблене, тоді зателефонуйте пізніше за допомогою лямбда-кнопки.

наприклад: (не використовуйте цей код, а лише приклад)

for entry in stuff_that_is_happening:
    value_store[entry] = stuff_that_is_happening

тоді можна сказати….

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

сподіваюся, що це допомагає!

Один з найпростіших способів було б налаштувати buttonз lambdaяк наступний синтаксис:

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

Для нащадків: ви також можете використовувати заняття для досягнення чогось подібного. Наприклад:

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.

Вам потрібно користуватися 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