The command lambda does not take any arguments at all; furthermore there is no evt that you can catch. A lambda can refer to variables outside it; this is called a closure. Thus your button code should be:

bouton1 = Button(main_window, text="Enter",
    command = lambda: get(Current_Weight, entree1))

And your get should say:

def get(loot, entree):
    loot = float(entree.get())
    print(loot)

When you use () with a function name(func(args)), then it is immediately calling/invoking the function while python is executing the line, you do not want that. You want to ONLY call the function when the button is clicked. tkinter will internally call the function for you, all you have to do is give the function name.

Why use lambda? Think of it as a function that returns another function, your code can be lengthened to:

func  = lambda: comando_click("Nova_Mensagem")
botao = Button(menu_inicial, text = "Executar", command=func)

func is the function name and if you want to call it, you would say func(). And when you say command=comando_click("Nova_Mensagem") then command has the value returned by command click(because you call the function with ()), which is None and if I'm not wrong, if the given value is None, it will not be called by tkinter. Hence your function is executed just once because of () and as a result of calling the function, you are assigning the value of the function call(None) before the event loop starts processing the events.

Some other methods:

• Using partial from functools:

from functools import partial

botao = Button(.....,command=partial(comando_click,"Nova_Mensagem"))

• Using a helper function:

def helper(args):
    def comando_click():
        print(args)

    return comando_click

botao = Button(...., command=helper("Nova_Mensagem"))

IMO, lambdas are the easiest way to proceed with calling a function with arguments.

You can fix this problem by creating a closure for i and j with the creation of each lambda:

command = lambda i=i, j=j: update_binary_text(i, j)

You could also create a callback factory with references to the button objects themselves:

def callback_factory(button):
    return lambda: button["text"] = "1"

And then in your initialization code:

for j in range(0, number):
    new_button = Button(root, text=" ")
    new_button.configure(command=callback_factory(new_button))
    new_button.pack()
    buttonList.append(new_button)

Can anyone explain to me the importance of the lambda function when creating interface with Tkinter?

Arguably, they aren't important at all. They are just a tool, one of several that can be used when binding widgets to functions.

The problem with the binding in your question is due to the fact that when you use bind to bind an event to a function, tkinter will automatically pass an event object to that function you must define a function that accepts that object.

This is where lambda comes in. The command needs to be a callable. One form of a callable is simply a reference to a function such as the one you're using (eg: command=self.concluir_return). If you don't want to modify your function to accept the parameter you can use lambda to create an anonymous function -- a callable without a name.

So, for your specific case, you can define a lambda that accepts the argument, and then the lambda can call your function without the argument.

But all was solved when I looked into web and modified the line of code with the lambda function.

self.master.bind("<Return>", lambda event: self.concluir_return())

This works because the code is effectively the same as if you did this:

def i_dont_care_what_the_name_is(event):
    self.concluir_return()
self.master.bind("<Return>", i_dont_care_what_the_name_is)

As you can see, lamda isn't required, it's just a convenient tool that lets you create a simple function on the fly that calls another function.