Short answer: you cannot. Callbacks can't return anything because there's nowhere to return it to -- except the event loop, which doesn't do anything with return values.

In an event based application, what you typically will do is set an attribute on a class. Or, if you're a beginner, you can set a global variable. Using a global variable isn't a good idea for real code that has to be maintained over time but it's OK for experimentation.

So, for example, since C appears to be a global variable in your example, you would do something like:

def button():
    global C
    mylabel = Label(myGui, text = "hi").grid(row = 0, column = 0)
    A = B.get()
    C = A

The whole point of attaching a command to a button is to implement the answer to the question "what do I want to happen when I click the button?". In your case, the answer is "I want it to a) get the value from an entry widget, b) calculate a new value, and c) append it to a list".

So, write a function that does that, and then call that function from your button. In this case you don't need lambda since you have a 1:1 relationship between the button and entry widget. There's nothing wrong with lambda per se, but in this case it adds complexity without providing any value so I recommend not using it. By not using lambda, the code will be easier to debug and maintain over time since it's hard to set breakpoints or add additional functionality inside a lambda.

For example:

def f(x):
    y=x**2
    z=x-1

def do_calculation():
    x_value = float(x.get())
    result = f(x_value)
    my_list.append(result)

...
tk.Button(..., command=do_calculation)

You don't need to return from the call-back, Instead, you can update the label directly and you used .push() but actually Tkinter widgets uses .grid() , .pack() or .place() to display them?

here is the updated code:

import tkinter as tk

variable = 0
root = tk.Tk()

label = tk.Label(root, text=f"Count: {variable}")
label.pack()

def variable_incrementer():
    global variable
    variable += 1
    label.config(text=f"Count: {variable}") 

click_btn = tk.Button(root, text="Click me", command=variable_incrementer)
click_btn.pack()

root.mainloop()

You can't really do that. The best way to do it is with a function but I'm not sure why you would want to do that. It seems a bit odd... As commented, the a Tkinter script runs differently to a normal Python script so nothing will be able to use the returned value. Store it as a variable if you need it.

I would just create a function that stores it as a variable.

def foo():
    gah=entry.get()
    # return entry.get()
    # stuff or no stuff

button=Button(root, text="ghost", command=foo)

I fixed your example code (I think). The main problem is that this:

command=self.Return()

does not do what you think it does. It just assigns return value from Return() to command. This is incorrect. It should be

command=self.Return

This assigns function Return to command. Subsequently, when ever button is pressed, self.Return() is executed.

The full example is here:

from tkinter import *

class Return_Value_In_Entry():
    def __init__(self):
        self.Master=Tk()

        self.Entry=Entry(self.Master)
        self.Entry.pack()

        self.Button=Button(self.Master,text="Submit",command=self.Return)
        self.Button.pack()            

        self.Master.mainloop()

    def Return(self):
        self.TempVar=self.Entry.get()

        print(self.TempVar)        


Return_Value_In_Entry()  

Now, whenever you press the Button, the value from the Entry widget is saved into self.TempVar and printed out, just to check if its working. Hope this helps.

Gif showing how the example program works:

If you use the class based approach to Tk applications, instead of returning values from event handlers, you can assign them to instance variables. This the best approach, as function-based GUI applications don't scale well precisely because the need to place stuff at module scope.

from Tkinter import *

class Application(Frame):

    def main(self):
        self.filename = askopenfilename(filetypes=[("Jpeg","*.jpg")])

    def createWidgets(self):
        self.button = Button(root,text="Open",command=self.main)
        self.button.pack()

    def __init__(self, master=None):
        Frame.__init__(self, master)
        self.filename = None
        self.pack()
        self.createWidgets()

root = Tk()
root.title("Image Manipulation Program")
app = Application(master=root)
app.mainloop()