Fundamental misunderstanding

The most significant problem with this code is a misunderstanding of functions. Functions are not goto labels. There is no reason for getWords and game to be mutually recursive. This leads to two problems:

• Your functions are inflexible and not reusable.
• If you play several rounds, the call stack gets deeper and deeper. Eventually, after many many rounds, the program can crash from stack overflow.

Each function should have a single purpose, and it should be documented in a docstring. If a function is named "getWords", then I expect it to return a list of words, and do nothing more than that. It shouldn't pick a word and proceed to play an entire game based on it.

A simple way to reorganize your code to use functions correctly might look like this:

def get_word():
    """
    Ask the user for the difficulty level, and return a randomly
    selected word from the dictionary.
    """
    # Do stuff …, then
    return word

def game(true_word):
    """
    Play a game of Mastermind, where the user needs to guess the
    given word.  Return True if the user guesses correctly within
    5 turns.
    """
    for turn in range(5):
        …
        if user_input == true_word:
            print("Well done, you guessed correctly")
            return True
        …
        print(hint)
    print("Bad luck! The answer was: " + true_word)
    return False

while True:
    game(get_word)

But we can do even better by breaking down those two functions into even smaller functions.

General remarks

• Commenting nearly every line is mildly obnoxious. For example:

  #num (used to store word lengths) is a random choice from the available lengths for the selected difficulty.
  

  That is just an indication that num is a vaguely named variable. A better choice would be word_length — and then you can eliminate the comment. (I wouldn't pick the word length first, though. What if the word bank happens to contain no 14-letter words?)

  with open('wordbank.txt', 'r') as file:
      #Open the file containing word-bank
  

  Python is quite readable. You don't have to tell me what the code obviously stated.

• Please follow the PEP 8 official style guide, in particular the naming conventions. Variables should be named like true_word or user_input unless you have a good reason to deviate.

• Be suspicious of global variables, and avoid using them at all. Your acceptedWord list keeps growing, but never gets cleared.

Specific suggestions

The difficulty dictionary could be better formatted for readability. Its purpose is not immediately obvious, so I'd add a comment.

import random

# Possible word lengths for each difficulty level
DIFFICULTY = {
    1: [4, 5, 6],
    2: [7, 8],
    3: [9, 10, 11],
    4: [12, 13],
    5: [14, 15],
}

getWords() should be turned into a function that reads and returns a data structure representing the entire file, so that you don't have to re-read the file every time before starting a game. Asking for the difficulty level and selecting words are separate tasks that deserve to be in their own functions.

def read_dictionary(filename='wordbank.txt'):
    """
    Read the file, containing one word per line.  Return a dictionary, keyed
    by word length.
    """
    dictionary = {}
    for lengths in DIFFICULTY.values():
        for length in lengths:
            dictionary[length] = []
    with open(filename) as f:
        for line in f:
            word = line.strip().upper()
            dictionary.get(len(word), []).append(word)
    return dictionary

def ask_level():
    """
    Ask the user for to select a valid difficulty level.
    """
    allowable_levels = [str(level) for level in sorted(DIFFICULTY.keys())]
    prompt = "What difficulty would you like? ({}) ".format(
        ','.join(allowable_levels)
    )
    while True:
        choice = input(prompt)
        if choice in allowable_levels:
            return int(choice)
        print("Invalid choice")

def select_words(level, dictionary):
    """
    Pick a sample of words from the dictionary with an appropriate length
    for the difficulty level.  The number of words chosen is equal to the
    length of the chosen word.
    """
    length = random.choice(DIFFICULTY[level])
    return random.sample(dictionary[length], length)

game() could be better named. Hard-coded arbitrary values are often better written as default parameters (turns=5 in this case). There is no point in converting strings to lists. The for loop can be more elegantly written as a single expression.

def mastermind_game(words, turns=5):
    """
    Play a game of Worded Mastermind, where the user has to guess which of the
    words is correct within the specified number of turns.  Return the number
    of remaining guesses (0 if the user lost, non-zero if the user won).
    """
    print("Possible answers:")
    print('\n'.join(words))
    word = random.choice(words)
    for remaining_guesses in range(turns, 0, -1):
        print("Guesses left: {}".format(remaining_guesses))
        guess = input("Guess: ").upper()
        if guess == word:
            print("Well done, you guessed correctly")
            return remaining_guesses
        correct_letter_count = sum(g == w for g, w in zip(guess, word))
        print("{} out of {} correct.".format(correct_letter_count, len(word)))
    print("Bad luck! The answer was: {}".format(word))
    return 0

The main code should obviously give a high-level view of what the program does. In this case, it reads the dictionary once, then loops forever playing Mastermind games. It's customary to write if __name__ == '__main__' so that the code can be safely imported into other Python programs without immediately executing it.

def main(wordlist_filename='wordbank.txt'):
    dictionary = read_dictionary(wordlist_filename)
    while True:
        level = ask_level()
        words = select_words(level, dictionary)
        mastermind_game(words)

if __name__ == '__main__':
    main()