Slot Machine in Python

I'd say you should encapsulate as much of your code as possible into functions and classes, limiting the global state when possible. This serves two purposes - the first is that it improves debugging (by limiting the odds that something unintentionally alters global state) and readability (by making it easier to understand what everything does).

Encapsulate functionality in a class

I'd create a class called SlotMachine that holds the global state. It should store constants as class-level variables, and other values as instance-variables (or better yet properties). Then all of your methods should belong to that class.

Keep related constants in an Enum

You have a bunch of constants related to what the slot reel is showing - these can be better described as an Enum

class Reel(Enum):
    CHERRY = 1
    LEMON = 2
    ORANGE = 3
    PLUM = 4
    BELL = 5
    BAR = 6
    SEVEN = 7

and then use Reel.CHERRY, for example, in the future. This also helps avoid magic numbers. If you don't have Python 3.4 or later you'll have to make your own homegrown Enum class, or use something like

def enum(*sequential, **named):
    enums = dict(zip(sequential, range(1, len(sequential) + 1)), **named)
    return type('Enum', (), enums)

Reel = enum("CHERRY", "LEMON", "ORANGE", "PLUM", "BELL", "BAR", "SEVEN")

or use the enum34 library which is a backport of 3.4's version of Enum.

Simplify boolean expressions

You don't need parentheses around your boolean expressions - they make it more confusing. Instead of something like answer == "yes" or answer == "y" you can do answer in ["yes", "y"].

Be clever with properties

Now that we're using a class, we can use a property to encapsulate behavior that you want. For example,

@property
def keep_playing(self):
    while(True):
        os.system('cls' if os.name == 'nt' else 'clear')
        if self.current_jackpot <= 1:
            print("Machine balance reset.")
            balance = 1000

        print("The Jackpot is currently: £{}.".format(self.current_jackpot))
        answer = input("Would you like to play? Or check your money? ").lower()
        if answer in ["yes", "y"]:
            return True
        elif answer in ["no", "n"]:
            print("You ended the game with £{} in your hand. Great job!".format(self.current_stake))
            return False
        elif answer == "check":
            print("You currently have £{}.".format(stake))
        else:
            print("Whoops! Didn't get that.")

now any time you want to find out if they want to keep playing, just use

if self.keep_playing:
    ...

Use dictionaries to simplify payout logic

Instead of all of those if statements, do something like this

payout = {
    Reel.CHERRY: 7,
    Reel.ORANGE: 10,
    Reel.PLUM: 14,
    Reel.BELL: 20,
    Reel.BAR: 250,
    Reel.SEVEN: 'jackpot'
}

def _adjust_score(first, second, third):
        if first == SlotMachine.Reel.CHERRY:
            if second == SlotMachine.Reel.CHERRY:
                win = 7 if third == SlotMachine.Reel.CHERRY else 5
            else:
                win = 2
        else:
            if first == second == third:
                win = SlotMachine.payout[first]
                win = self.current_jackpot if win == 'jackpot' else win
            else:
                win = -1

        if win == self.current_jackpot:
            print("You won the JACKPOT!!")
        else:
            print('\t'.join(map(lambda x: x.name.center(6), (first, second, third))))
            print("You {} £{}".format("won" if win > 0 else "lost", win)
            self.current_stake += win
            self.current_jackpot -= win

Note - your payout in the instructions isn't consistent with your logic, but I just kept it as your logic is. You can adjust this function and the dictionary to have more complicated arrangements and expand the payouts. Also, you're missing payouts for Lemons.

Altogether

import random
import time
import os
from enum import Enum


class SlotMachine:
    INITIAL_STAKE = 50
    INITIAL_JACKPOT = 1000

    class Reel(Enum):
        CHERRY = 1
        LEMON = 2
        ORANGE = 3
        PLUM = 4
        BELL = 5
        BAR = 6
        SEVEN = 7

    _values = list(Reel)
    payout = {
        Reel.CHERRY: 7,
        Reel.ORANGE: 10,
        Reel.PLUM: 14,
        Reel.BELL: 20,
        Reel.BAR: 250,
        Reel.SEVEN: 'jackpot'
    }

    def __init__(self, stake=INITIAL_STAKE, jackpot=INITIAL_JACKPOT):
        self.current_stake = stake
        self.current_jackpot = jackpot

    @property
    def keep_playing(self):
        while(True):
            os.system('cls' if os.name == 'nt' else 'clear')
            if self.current_jackpot <= 1:
                print("Machine balance reset.")
                self.current_jackpot = SlotMachine.INITIAL_JACKPOT

            print("The Jackpot is currently: £{}.".format(self.current_jackpot))
            answer = input("Would you like to play? Or check your money? ").lower()
            if answer in ["yes", "y"]:
                return True
            elif answer in ["no", "n"]:
                print("You ended the game with £{} in your hand. Great job!".format(self.current_stake)
                return False
            elif answer == "check":
                print("You currently have £{}.".format(stake))
            else:
                print("Whoops! Didn't get that.")

    def _play_round(self):
        first, second, third = random.choice(SlotMachine._values), random.choice(SlotMachine._values), random.choice(SlotMachine._values)
        self._adjust_score(first, second, third)

    def _adjust_score(first, second, third):
        if first == SlotMachine.Reel.CHERRY:
            if second == SlotMachine.Reel.CHERRY:
                win = 7 if third == SlotMachine.Reel.CHERRY else 5
            else:
                win = 2
        else:
            if first == second == third:
                win = SlotMachine.payout[first]
                win = self.current_jackpot if win == 'jackpot' else win
            else:
                win = -1

        if win == self.current_jackpot:
            print("You won the JACKPOT!!")
        else:
            print('\t'.join(map(lambda x: x.name.center(6), (first, second, third))))
            print("You {} £{}".format("won" if win > 0 else "lost", win))
            self.current_stake += win
            self.current_jackpot -= win

    def play(self):
        while self.current_stake and self.keep_playing:
            self._play_round()


if __name__ == '__main__':
    print('''
Welcome to the Slot Machine
You'll start with £50. You'll be asked if you want to play.
Answer with yes/no. you can also use y/n
There is no case sensitivity, type it however you like!
To win you must get one of the following combinations:
BAR\tBAR\tBAR\t\tpays\t£250
BELL\tBELL\tBELL/BAR\tpays\t£20
PLUM\tPLUM\tPLUM/BAR\tpays\t£14
ORANGE\tORANGE\tORANGE/BAR\tpays\t£10
CHERRY\tCHERRY\tCHERRY\t\tpays\t£7
CHERRY\tCHERRY\t  -\t\tpays\t£5
CHERRY\t  -\t  -\t\tpays\t£2
7\t  7\t  7\t\tpays\t The Jackpot!
''')
    SlotMachine().play()