i need to make this for 6 buttons...

If each button modifies the same global variable, then have make_something accept a value parameter:

from tkinter import Tk, Button
variable = 1
def make_something(value):
    global variable
    variable = value
root = Tk()
Button(root, text='Set value to four',command=lambda *args: make_something(4)).pack()
Button(root, text='Set value to eight',command=lambda *args: make_something(8)).pack()
Button(root, text='Set value to fifteen',command=lambda *args: make_something(15)).pack()
#...etc

If each button modifies a different global, then condense all your globals into a single global dict, which make_something can then modify.

from tkinter import Tk, Button
settings = {"foo": 1, "bar": 1, "baz": 1}

def make_something(name):
    settings[name] = 2

root = Tk()
Button(root, text='Set foo',command=lambda *args: make_something("foo")).pack()
Button(root, text='Set bar',command=lambda *args: make_something("bar")).pack()
Button(root, text='Set baz',command=lambda *args: make_something("baz")).pack()
#...etc

In either case, you still only require one function.

If lambdas aren't to your taste, you could use nested functions to create separate callables for each command:

from tkinter import Tk, Button
settings = {"foo": 1, "bar": 1, "baz": 1}

def make_callback(key):
    def make_something(*args):
        settings[key] = 2
    return make_something

root = Tk()
Button(root, text='Set foo',command=make_callback("foo")).pack()
Button(root, text='Set bar',command=make_callback("bar")).pack()
Button(root, text='Set baz',command=make_callback("baz")).pack()
#...etc

... And you can avoid globals by instead using attributes of a class instance:

from tkinter import Tk, Button

class GUI:
    def __init__(self):
        self.settings = {"foo": 1, "bar": 1, "baz": 1}
        self.root = Tk()
        Button(self.root, text='Set foo',command=self.make_callback("foo")).pack()
        Button(self.root, text='Set bar',command=self.make_callback("bar")).pack()
        Button(self.root, text='Set baz',command=self.make_callback("baz")).pack()
        #...etc

    def make_callback(self, key):
        def make_something(*args):
            self.settings[key] = 2
        return make_something

gui = GUI()

By the way, don't do this:

myButton = Button(root).pack()

This assigns the result of pack() to myButton, so myButton will be None instead of referring to your button. Instead, do:

myButton = Button(root)
myButton.pack()

Below code processes entry widget's text when Submit button is pressed.

import tkinter as tk

root = tk.Tk()

aVarOutside = 'asd'
def btn_cmd(obj):

    #use global variable
    global aVarOutside
    #print its unmodified value
    print("aVarOutside: " + aVarOutside)
    #modify it with what's written in Entry widget
    aVarOutside = obj.get()

    #modify lblTextVar, which is essentially modifying Label's text as lblTextVar is its textvariable
    lblTextVar.set(obj.get())

    #print what's inside Entry
    print("Entry: " + obj.get())

txt = tk.Entry(root)
txt.pack()

lblTextVar = tk.StringVar()
lbl = tk.Label(root, textvariable=lblTextVar)
lbl.pack()

btn = tk.Button(text="Submit", command=lambda obj = txt : btn_cmd(obj))
btn.pack()

root.mainloop()

When the button is pressed:

1. Value of a global variable, aVarOutside is printed.
2. Value of aVarOutside is modified to the value of Entry box's (txt's) content.
3. Value of a textvariable used by a label (lbl) is modified. Which means that the text of lbl is updated and can be seen on the GUI.
4. Finally Entry box, txt's content is printed.

This can be done using a lambda, like so:

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

This is a simple way to bind the argument without an explicit wrapper method or modifying the original action.

There are several ways to accomplish your goal.

One way is to write a single function that will take a value to assign to your variable. This way you can have as many buttons as you like and only a single function.

Not if you are using functions you have to either pass the variable to the function or let the function know it is in the global namespace.

import tkinter as tk


root = tk.Tk()
selection = ''


def assign_value(value):
    global selection
    selection = value
    lbl["text"] = value
    print(selection)


lbl = tk.Label(root, text='Selection Goes Here')
lbl.grid(row=0, column=0)
tk.Button(text="General Knowledge", command=lambda: assign_value("General Knowledge")).grid(row=1, column=0)
tk.Button(text="Science", command=lambda: assign_value("Science")).grid(row=2, column=0)
tk.Button(text="Entertainment", command=lambda: assign_value("Entertainment")).grid(row=3, column=0)
tk.Button(text="Miscellaneous", command=lambda: assign_value("Miscellaneous")).grid(row=4, column=0)

root.mainloop()

Or you can assign the value directly from the button.

import tkinter as tk


root = tk.Tk()
selection = tk.StringVar()
selection.set('Selection Goes Here')


lbl = tk.Label(root, textvariable=selection)
lbl.grid(row=0, column=0)
tk.Button(text="General Knowledge", command=lambda: selection.set("General Knowledge")).grid(row=1, column=0)
tk.Button(text="Science", command=lambda: selection.set("Science")).grid(row=2, column=0)
tk.Button(text="Entertainment", command=lambda: selection.set("Entertainment")).grid(row=3, column=0)
tk.Button(text="Miscellaneous", command=lambda: selection.set("Miscellaneous")).grid(row=4, column=0)

root.mainloop()

I am sure if I spent more time on this I could think up something else but the idea is basically write your code in a more DRY (Don't Repeat Yourself) fashion and make sure you are assigning the value to the variable in the global namespace or else it will not work as you expect.