Sorry for being 6 years late, but recently I figured out a good way to do this without making your code messy and hard to maintain. This is pretty much what DaveTheScientist has said, but I just want to expand on it a little. Usually, in Tkinter, if you want to have a button call a function, you do the following:

exampleButton = Button(root, text = 'Example', command = someFunc)

This will simply call someFunc whenever the button is pressed. If this function, however, takes arguments, you need to use lambdas and do something like this:

exampleButton = Button(root, text = 'Example', command = lambda: someFunc(arg1, arg2))

The above line of code will run someFunc and use the variables arg1 and arg2 as arguments for that function. Now, what you could do in a program where, a lot of the times, you would need the functions run by buttons to return values, is create a new function which is called by every button.

This function takes the function you want your button to run as a first argument, and that function's arguments afterwards.

def buttonpress(function, *args):
    value = function(*args)

Then when you create the button, you do:

exampleButton = Button(root, text = 'Example', command = lambda: buttonpress( someFunc, arg1, arg2 ))

This will run the given function (in this case, someFunc) and store the returned value in the value variable. It also has the advantage that you can use as many arguments as you want for the function your button runs.

Long story short: How do I pass a variable by reference?

Example of a mutable object that persists after the callback

import tkinter as tk
from tkinter import messagebox

def function():
    root = tk.Tk()
    returned_values = {} 

    entry = tk.Entry(root)
    entry.pack()
    
    button = tk.Button(root, text = "I'm a button", command=lambda: callback(entry.get(), returned_values))
    button.pack()

    root.mainloop()
    
def callback(info, returned_values):
    returned_values[len(returned_values)+1] = info
    messagebox.showinfo('Success', f"Mutable: {returned_values}")
   
function()

As you can see, returned_values persists because it is a mutable object

I think @Julia has the basically the right architecture for your tkinter application, but her answer could be improved by using a tkinter Variable — because all widgets associated with one will automatically update their displayed value whenever the Variable is changed (by one of them or something else).

Here's a little documentation on Variable Classes. Note that since ttk.Combobox with have all the methods of a tk.Entry widgets, here's a bit of documentation about them (which also happens to illustrate the "pattern" of using of a StringVar in conjunction with one so it also applies to a ttk.Comboboxs).

Generally, you can tell a widget to use a tkinter Variable by specifying an instance of one as the option textvariable= keyword argument when the widget is created. You can also set the option using the partial dictionary interface most widgets support, so assignments like widget['textvariable'] = variable are another way to make use of them — the code below makes use of both of these ways.

Here's Julia's code modified to use a tk.StringVar. Note the Combobox doesn't need a callback function to bind the <<ComboboxSelected>> event to it, so all that complexity has been eliminated.

import tkinter as tk
from tkinter import ttk

class DataChosenForm(tk.Frame):
    def __init__(self, parent):
        super().__init__(parent)

        choice = tk.LabelFrame(self, text="wybór")
        choice.grid(row=0)
        self.combo = ttk.Combobox(choice)
        self.combo['textvariable'] = parent.var  # Use shared variable.
        self.combo['values'] = ('wizzair', 'ryanair', 'lot')
        self.combo.grid(row=0, column=2, padx=80, pady=10)

class ReturnData(tk.Frame):
    def __init__(self, parent):
        super().__init__(parent)

        message_box = tk.LabelFrame(self, text="wynik")
        message_box.grid(row=1)
        mb = tk.Label(message_box, textvariable=parent.var,  # Use shared variable.
                      anchor='nw', width=20)
        mb.pack(padx=120, pady=30)

class Application(tk.Tk):
    def __init__(self):
        super().__init__()

        self.title("program do wyszukiwania cen lotów")
        self.geometry('300x200')
        self.resizable(width=False, height=False)
        self.var = tk.StringVar(value='Dokonać wyboru')  # Create shared variable.

        DataChosenForm(self).grid(row=0, column=0)
        ReturnData(self).grid(row=1)

if __name__ == "__main__":
    app = Application()
    app.mainloop()

You could call C.set from within the button function:

def button:
    mylabel = Label(myGui, text = "hi").grid(row = 0, column = 0)
    A = B.get()
    C.set(A)
    # return A   # return values are useless here

Blender's answer is a clever solution but in case you get thrown off by the function abstraction, here is another possible way to do it. It really just creates a mapping, saved in buttons, from Button widgets to their proper numbers.

import Tkinter as tk
root = tk.Tk()

def myfunction(event):
    print buttons[event.widget]

buttons = {}
for i in range(10):
    b = tk.Button(root, text='button' + str(i))
    buttons[b] = i # save button, index as key-value pair
    b.bind("<Button-1>", myfunction)
    b.place(x=10,y=(10+(25*i)))
root.mainloop()

If you need some variable outside a function you need a global variable

name="" # if you don't call the function it'll remain empty!
def callback():
    global name
    name= askopenfilename() 
    print name