Why is Python 3.1 slower than 2.6 for this code?

Question

Consider the following code (from here, with the number of tests increased):

from timeit import Timer

def find_invpow(x,n):
    """Finds the integer component of the n'th root of x,
    an integer such that y ** n <= x < (y + 1) ** n.
    """
    high = 1
    while high ** n < x:
        high *= 2
    low = high/2
    while low < high:
        mid = (low + high) // 2
        if low < mid and mid**n < x:
            low = mid
        elif high > mid and mid**n > x:
            high = mid
        else:
            return mid
    return mid + 1

def find_invpowAlt(x,n):
    """Finds the integer component of the n'th root of x,
    an integer such that y ** n <= x < (y + 1) ** n.
    """
    low = 10 ** (len(str(x)) / n)
    high = low * 10
    while low < high:
        mid = (low + high) // 2
        if low < mid and mid**n < x:
            low = mid
        elif high > mid and mid**n > x:
            high = mid
        else:
            return mid
    return mid + 1

x = 237734537465873465
n = 5
tests = 1000000

print "Norm", Timer('find_invpow(x,n)', 'from __main__ import find_invpow, x,n').timeit(number=tests)
print "Alt", Timer('find_invpowAlt(x,n)', 'from __main__ import find_invpowAlt, x,n').timeit(number=tests)

Using Python 2.6 (Python 2.6.5 (r265:79063, Apr 16 2010, 13:57:41) [GCC 4.4.3] on linux2), the times reported are:

Norm 9.73663210869
Alt 9.53973197937

However, on the same machine using Python 3.1 (Python 3.1.2 (r312:79147, Apr 15 2010, 15:35:48) [GCC 4.4.3] on linux2), the times are:

Norm 28.4206559658
Alt 26.8007400036

Does anyone know why this code runs three times slower on Python 3.1?

Answer 1

The // operator performs integer division (or floor division) in both python 2 and 3, whereas the / operator performs floor division in python 2 given integer operands and true division in python 3 given any operands.

Try replacing the / operator with the // operator.

Answer 2

I got steadily decreasing times from 2.5, 2.6, 2.7 and 3.1 (Windows XP SP2) ... with the "/" version. With the //, the 3.1 times were dramatically smaller than the 2.X times e.g. "Norm" dropped from 6.35 (py2.7) to 3.62 (py3.1).

Note that in 2.x, there are ints (machine word, 32 or 64 bits) and longs (variable length). In 3.x, long has been renamed int, and int went away. My guess is that converting from long to float may cause the extra time with /.

In any case, a much better "Alt" version would start off with this code:

high = 1
highpown = 1
while highpown < x:
    high <<= 1
    highpown <<= n