Python 为什么这种回文测试方法会慢得多？

我有两种不同的回文测试方法。一个是：

def palindrome(text):
    return text == text[::-1]

当然非常简单，但我曾想象它会很慢，因为它（当然）必须在反转后将

text[：：-1]

的值存储在某个地方，然后检查这两个字符中的每个字符。因此，我尝试了另一种方法：

def palindrome_2(text):
    left = 0
    right = len(text) - 1
    while left < right:
        if text[left] != text[right]:
            return False
        right -= 1
        left += 1
    return True

def回文2（文本）：
左=0
右=长（文本）-1
当左<右：
如果文本[左]！=文本[右]：
返回错误
右-=1
左+=1
返回真值

---

它从起点和终点开始，一直延伸到中心。据我所知，这应该更快，因为它只检查

[0，n//2）

，反之亦然。然而，当我使用timeit测试这些时，第一个是

0.32

，第二个是

1.34

。为什么？

我认为使用它来查看这里生成的字节码是有益的：

import dis
dis.dis(palindrome)
dis.dis(palindrome_2)

回文：

  4           0 LOAD_FAST                0 (text)
              3 LOAD_FAST                0 (text)
              6 LOAD_CONST               0 (None)
              9 LOAD_CONST               0 (None)
             12 LOAD_CONST               2 (-1)
             15 BUILD_SLICE              3
             18 BINARY_SUBSCR
             19 COMPARE_OP               2 (==)
             22 RETURN_VALUE

回文2：

 10           0 LOAD_CONST               1 (0)
              3 STORE_FAST               1 (left)

 11           6 LOAD_GLOBAL              0 (len)
              9 LOAD_FAST                0 (text)
             12 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             15 LOAD_CONST               2 (1)
             18 BINARY_SUBTRACT
             19 STORE_FAST               2 (right)

 12          22 SETUP_LOOP              60 (to 85)
        >>   25 LOAD_FAST                1 (left)
             28 LOAD_FAST                2 (right)
             31 COMPARE_OP               0 (<)
             34 POP_JUMP_IF_FALSE       84

 13          37 LOAD_FAST                0 (text)
             40 LOAD_FAST                1 (left)
             43 BINARY_SUBSCR
             44 LOAD_FAST                0 (text)
             47 LOAD_FAST                2 (right)
             50 BINARY_SUBSCR
             51 COMPARE_OP               3 (!=)
             54 POP_JUMP_IF_FALSE       61

 14          57 LOAD_CONST               3 (False)
             60 RETURN_VALUE

 15     >>   61 LOAD_FAST                2 (right)
             64 LOAD_CONST               2 (1)
             67 INPLACE_SUBTRACT
             68 STORE_FAST               2 (right)

 16          71 LOAD_FAST                1 (left)
             74 LOAD_CONST               2 (1)
             77 INPLACE_ADD
             78 STORE_FAST               1 (left)
             81 JUMP_ABSOLUTE           25
        >>   84 POP_BLOCK

 17     >>   85 LOAD_CONST               4 (True)
             88 RETURN_VALUE

10 0负载常数1（0）
3商店快速1（左）
11 6加载_全局0（len）
9加载快速0（文本）
12调用函数1（1个位置，0个关键字对）
15荷载常数2（1）
18二进制减法
19商店2（右）
12 22设置回路60（至85）
>>25装载快速1（左）
28装载快速2（右）
31比较操作0（>61加载速度2（右）
64负载常数2（1）
67就地减法
68商店快速2（右）
16 71装载快速1（左）
74荷载常数2（1）
77就地添加
78商店快速1（左）
81绝对值25
>>84波普卢大厦
17>>85负载常数4（真实）
88返回值

基本上，当做相同的工作量时，C代码将比相应的python代码更快。

---

正如您所看到的，第一种方法调用一个内置函数，该函数是用fast C编写的。第二种方法必须用python代码完成更多的工作，包括处理循环构造开销，这将比调用C慢。

因为C代码比python代码快，这为您提供了一个详细的示例，说明了不同im的方式和原因在您的特定情况下，第二个必须处理30个左右的函数调用，而第一个只处理3个。