Palindromes that are sum of consecutive squares
The key problem with the performance of your code is get_quadratic_sums. This returns all sums of consecutive squares each of which is individually below the limit. But the vast majority of this work is wasted, because we are only interested in in sums of consecutive squares where the sum is below the limit.

So a very simple change to your code massively improves its performance. Where the code iterates over sums of squares:

for partial in partial_sums[0:i-1]:
    val = partial_sums[i] - partial
    dic[val] = 1


Iterate in reverse order (so that val is increasing) and stop when val is too large:

for partial in partial_sums[i-2::-1]:
    val = partial_sums[i] - partial
    if val &gt;= limit:
        break
    dic[val] = 1


Now it runs in less than a second on my laptop:

&gt;&gt;&gt; timeit(lambda:palindromic_square_summable(10**8), number=1)
0.7864874959923327


But we can do even better than that. Slicing a list in Python makes a copy of the sliced part of list. We can avoid the copy by iterating over the indices instead:

for j in xrange(i-2, -1, -1):
    val = partial_sums[i] - partial_sums[j]
    if val &gt;= limit:
        break
    dic[val] = 1


Now it runs in less than half a second:

&gt;&gt;&gt; timeit(lambda:palindromic_square_summable(10**8), number=1)
0.40678663086146116


A few more improvements:


int rounds towards zero, so you can write int(limit ** .5) instead of int(floor(limit ** .5)).
Since there have to be at least two squares in the sum, we only need to check up to int((limit / 2) ** .5).
get_quadratic_sums returns a dictionary whose keys are sums and whose values are always 1. But the values are never used, so it would make more sense to use Python's built-in sets:

def get_quadratic_sums(limit):
    """Return set of sums below limit of two or more consecutive squares."""
    max_square = int((limit / 2) ** .5) + 1
    partial_sums = [0] * max_square
    sums = set()
    _add = sums.add
    total = 0
    for i in xrange(1, max_square):
        total += i * i
        partial_sums[i] = total
        for j in xrange(i - 2, -1, -1):
            val = total - partial_sums[j]
            if val &gt;= limit:
                break
            _add(val)
    return sums


Note the use of the local variable _add to remember the sums.add method: this avoids looking it up again on each loop iteration.
Similarly, all_palindromes can be changed to return a set instead of a dictionary:

def all_palindromes(limit):
    """Return set of palindromes below limit."""
    palindromes = set()
    _add = palindromes.add
    for p in get_palindrome():
        if p &gt;= limit:
            break
        _add(p)
    return palindromes

Now that both of these functions return sets, you can just take their intersection, like this:

def palindromic_square_summable(limit=10**8):
    """Return the sum of palindromes below limit that are sums of two or
    more consecutive positive integers.

    """
    return sum(get_quadratic_sums(limit) &amp; all_palindromes(limit))


This is even faster:

&gt;&gt;&gt; timeit(palindromic_square_summable, number=1)
0.29244883195497096