I am not aware of any internal tkinter method to check if a button is pressed.

However you could connect the Button with a function that changes the value of a global variable, like in the following:

from Tkinter import *

master = Tk()

def callback():
    global buttonClicked
    buttonClicked = not buttonClicked 


buttonClicked  = False # Bfore first click

b = Button(master, text="Smth", command=callback)
b.pack()

mainloop()

The code, changes the variable value from False to True (or reverse) every time you press the button.

It's simple, define a function which will be called after button press. Like so:

def addCredit():
    global credit
    credit+=10

And then assign this simple function to your button:

tenbutton = Button(insert, text="10p", command=addCredit).grid(row=2, column=1)

By the way, your code is badly asking for a class somewhere. Using so many globals is generally a bad practice. Another nitpick is from tkinter import *, it destroys readability. I'd suggest import tkinter as tk.

You could set each button's command option to a lambda like this:

self.button1 = Tkinter.Button(self, ..., command=lambda: self.OnButtonClick(1))
...
self.button2 = Tkinter.Button(self, ..., command=lambda: self.OnButtonClick(2))

Then, make self.OnButtonClick accept an argument that will be the button's "id". It would be something like this:

def OnButtonClick(self, button_id):
    if button_id == 1:
        # self.button1 was clicked; do something
    elif button_id == 2:
        # self.button2 was clicked; do something

Use a Boolean flag.

Define isClicked as False near the beginning of your code, and then set isClicked as True in your create_window() function.

This way, other functions and variables in your code can see whether the button's been clicked (if isClicked).

Here is something you can try. The main function is printing a number every second, and you can interrupt it by typing "s" + the Enter key :

import threading
import time

a = True

def main():
    for i in range(10):
        if a:
            time.sleep(1)
            print(i) 

def interrupt():
    global a # otherwise you can only read, and not modify "a" value globally
    if input("You can type 's' to stop :") == "s":
        print("interrupt !")
        a = False


t1 = threading.Thread(target=main)
t1.start()
interrupt()

Depending on how your circuit is wired you should use

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)

inputPin = "YOUR_PIN_GOES_HERE"
GPIO.setup(inputPin,GPIO.IN,pull_up_down=GPIO.PUD_UP)

def buttonPress(channel):
     #stuff

def buttonRelease(channel):
     #stuff


GPIO.add_event_detect(channel,GPIO.RISING,callback=buttonPress)
#OR
GPIO.add_event_detect(channel,GPIO.FALLING,callback=buttonRelease)

while(1):
      keypressed = raw_input('Press q to quit: ')
      if keypressed == 'q':
           break
      elif keypressed == 'SOME OTHER KEY':
           #code for some other thing
      else
           print("Unknown input")

These are events that will be trigged where there is a change on your input pin. Your raw_input can still handle whatver code you want because the event loop is running in the background.

Pulled from here

Edits: put the event defs above event declaration because I am teh dumb

While(1)'s are ugly. For the sake of staying a loop this should suffice though. Essentially this will run the keyboard input loop until you hit q. Use the elifs to handle other inputs. The else will capture unknown input and provide feedback. The break statment will boot the program out of the while loop and will reach the end of code and terminate.

Should you feel fancy and want to handle a lot of input I would look to use what other languages have a switch statement to clean up a bunch of elifs

Oh and standard warranty applies, I may have missed a tab or : here and there.