Question

我正在通过递归编写一个简单的排序代码，我在Python 2.7.6和Python 3.3.3中测试它。但我得到了两个不同的结果。代码如下。

import math, copy, random, sys
call_count = 0;    # Keep track of number of times of stooge_sort() get called
swap_count = 0;    # Keep track of number of times swapping.
def stooge_sort(a, origin):
    global call_count, swap_count;
    call_count += 1;
    n = len(a);
    m = int(math.ceil(n*2/3));
    if(n == 2 and a[0] > a[1]):
        a[0], a[1] = a[1], a[0];
        swap_count += 1;
    elif (n > 2):
        first = copy.deepcopy(a[0:m]);
        a[0:m] = stooge_sort(first, origin);
        second = copy.deepcopy(a[n-m:]);
        a[n-m:] = stooge_sort(second, origin);
        first = copy.deepcopy(a[0:m]);
        a[0:m] = stooge_sort(first, origin);
    return a;

a = [int(random.random() * 100) for i in range(10)];
stooge_sort(a, a);
print("sort function call count = " + str(call_count))
print("swap count = " + str(swap_count));

1）如果我在Python 2.7.6中运行，我会得到错误的排序和

sort function call count = 40
swap count = 2

2）如果我在Python 3.3.3中运行，我会得到正确的排序和

sort function call count = 364
swap count = 18

所以我想知道Python 2.7.6中哪一部分出了问题？

Answer 1

这一切都是因为这一行

m = int(math.ceil(n*2/3));

在Python 2中，n*2/3为您提供的值比实际值小1，因为浮点值被截断（since / does floor division in Python 2.x），但在Python 3中，它将执行正确的浮动点分裂。

要使程序表现一致，只需确保使用浮点数

m = int(math.ceil(n*2.0/3.0))

Answer 2

正如其他人所指出的那样，你的表达式int(math.ceil(n*2/3))取决于/运算符的定义方式，以及Python 2和Python 3之间的变化。

在Python 2.2及更高版本中，您还可以将其添加到程序的开头：

from __future__ import division

将导致/始终执行浮点除法，无论其操作数如何。 //运算符将始终执行整数除法，无论您是否使用上述__future__导入（尽管在使用时仅必需）。

Answer 3

在Python中，为了让代码在版本之间保持明确，请使用//进行分区，并确保为经典分区设置浮点数：

Floor division（来自Python 3.3解释器）：

>>> 1//2
0
>>> 2//2
1

真正的分工（来自Python 2.7解释器）：

>>> float(1)/2
0.5

对于2.7，你也可以这样做：

>>> from __future__ import division
>>> 1/2
0.5

python 2.7.6和3.3.3导致不同的递归

3 个答案: