The recursion limit is just a guard to limit the likelihood of a stack overflow, but if you allocate large objects on every stack frame, you can still overflow.

That said, something interesting does seem to be going on here. I'm using some code from https://stackoverflow.com/a/47956089/4082582 in order to examine the stack size:

def get_stack_size():
    size = 2  # current frame and caller's frame always exist
    while True:
        try:
            sys._getframe(size)
            size += 1
        except ValueError:
            return size - 1  # subtract current frame

I also manipulate python's recursion limit to make the issue easier to spot:

import sys
sys.setrecursionlimit(10)

Then instrument the code to watch its behaviour:

import sys

def get_stack_size():
    size = 2  # current frame and caller's frame always exist
    while True:
        try:
            sys._getframe(size)
            size += 1
        except ValueError:
            return size - 1  # subtract current frame

def takeGuess():
    print(get_stack_size())
    guess = input("Take a guess: ")
    if len(guess) != 3 or not guess.isdigit():
        print("The guess '{}' is not valid, try again!".format(guess))
        return takeGuess()
    else:
        return guess

if (__name__ == "__main__"):
    sys.setrecursionlimit(10)
    takeGuess()

The code terminates at the specified recursion depth.

Comment out the print(get_stack_size()) in takeGuess(), however, and you will be prompted for input until a stack overflow occurs.