Como Passar Argumentos ao Comando do Botão Tkinter

A opção command de um botão Tkinter espera um objeto chamável. Para passar argumentos, associe-os agora e deixe o Tkinter chamar esse objeto quando o usuário clicar. Escrever command=show_message("Saved") chama a função enquanto o botão está sendo criado; use partial ou uma função envolvente com lambda para adiar a chamada.

Passar argumentos com functools.partial

Use functools.partial para associar argumentos a uma função existente. Ela retorna um objeto chamável com esses valores associados, que pode ser atribuído diretamente à opção command de um botão. Esta simulação sem interface gráfica representa o espaço command de um botão para mostrar o comportamento da chamada de retorno sem abrir uma janela. Execute este exemplo:

from functools import partial

def show_message(message):
    print(message)

class Button:
    def __init__(self, command):
        self.command = command

    def click(self):
        self.command()

save_button = Button(command=partial(show_message, "Saved"))
remove_button = Button(command=partial(show_message, "Removed"))
save_button.click()
remove_button.click()

Saved
Removed

Cada clique simulado chama o objeto chamável armazenado e imprime a mensagem associada. Para abrir uma janela de verdade, execute este script completo com Tkinter e clique em qualquer um dos botões; o rótulo exibe a mensagem e a categoria correspondentes. O texto visível dos botões e do rótulo permanece em inglês, porque os blocos de código e de saída são preservados sem alterações:

from functools import partial


def show_message(message, category):
    result.config(text=f"{message} ({category})")


try:
    import tkinter as tk
except ImportError as error:
    print(f"Tkinter is unavailable: {error}")
else:
    try:
        root = tk.Tk()
    except tk.TclError as error:
        print(f"A graphical display is required to open the Tkinter window: {error}")
    else:
        root.title("Button callbacks with partial")
        result = tk.Label(root, text="Choose an action")
        result.pack(padx=12, pady=8)

        tk.Button(
            root,
            text="Save profile",
            command=partial(show_message, "Saved", "profile"),
        ).pack(padx=12, pady=4)
        tk.Button(
            root,
            text="Remove draft",
            command=partial(show_message, "Removed", "draft"),
        ).pack(padx=12, pady=4)

        root.mainloop()

A chamada de retorno aceita message e category, correspondendo aos dois valores associados em cada chamada de partial. partial é útil quando a função de destino já tem a assinatura adequada e você quer deixar visível a associação de um ou mais valores na atribuição de command.

Passar argumentos com uma função lambda

Uma função lambda pode envolver uma chamada e fornecer os argumentos quando o Tkinter a invocar. A expressão lambda: show_message("Saved") cria um objeto chamável sem argumentos; a chamada da função dentro do corpo só acontece depois, quando há um clique. Para uma função lambda com parâmetros, a sintaxe é lambda parameters: expression.

Esta simulação sem interface gráfica armazena cada função lambda em um espaço command semelhante ao de um botão e a invoca para representar um clique. Execute este exemplo:

def greet(name):
    print(f"Hello, {name}!")

class Button:
    def __init__(self, command):
        self.command = command

    def click(self):
        self.command()

ada_button = Button(command=lambda: greet("Ada"))
sam_button = Button(command=lambda: greet("Sam"))
ada_button.click()
sam_button.click()

Hello, Ada!
Hello, Sam!

Cada clique simulado invoca a função lambda armazenada e imprime a saudação selecionada. Para abrir uma janela de verdade, execute este script completo com Tkinter e clique em qualquer um dos botões; o rótulo muda para a saudação selecionada:

def greet(name):
    result.config(text=f"Hello, {name}!")


try:
    import tkinter as tk
except ImportError as error:
    print(f"Tkinter is unavailable: {error}")
else:
    try:
        root = tk.Tk()
    except tk.TclError as error:
        print(f"A graphical display is required to open the Tkinter window: {error}")
    else:
        root.title("Button callbacks with lambda")
        result = tk.Label(root, text="Choose a greeting")
        result.pack(padx=12, pady=8)

        tk.Button(
            root,
            text="Greet Ada",
            command=lambda: greet("Ada"),
        ).pack(padx=12, pady=4)
        tk.Button(
            root,
            text="Greet Sam",
            command=lambda: greet("Sam"),
        ).pack(padx=12, pady=4)

        root.mainloop()

Escolha partial quando quiser associar valores a uma função existente e deixar essa associação visível na atribuição de command. Escolha uma função lambda quando a chamada precisar de um pequeno ajuste em linha ou quando quiser explicitar a expressão da chamada de retorno junto ao botão. Uma função lambda também pode passar vários argumentos, como em lambda: show_message("Saved", "profile"); defina a função de destino para aceitar esses valores. Em ambos os casos, atribua o próprio objeto chamável a command. Acrescentar parênteses à chamada de retorno durante a configuração do botão executa a função imediatamente, antes que alguém possa clicar. Se o botão parecer não fazer nada, confira se o nome da chamada de retorno está correto, se os argumentos correspondem à assinatura da função e se o corpo da função produz algum efeito observável, como imprimir algo ou atualizar um widget.