It's the number of operations required that makes it slow. Everything you do in a function takes a little time to execute, so the less operations you do, the faster the code (as a rule of thumb).

The recursive version creates three new strings, makes two function calls and three comparisons for every two characters in the input (for strings > 1 characters). Whereas the the non recursive version creates one new string, does one comparison and calls no functions -- for a string of any size.

It may be clever, but the recursion gains you nothing for this problem. The algorithm is basically 'compare each character from the first half of the string with the corresponding character from the second half' -- and that can be done more efficiently without recursion.

The following is essentially the same algorithm, but with an explicit loop:

def is_palindrome(s):
    for index, c in enumerate(s[:len(s)/2], 1):
        if c != s[-index]:
            return False
    return True

Still not as fast as 's == s[::-1]', but more efficient that the recursive code.