53

为什么执行startwith比切片慢？

In [1]: x = 'foobar'

In [2]: y = 'foo'

In [3]: %timeit x.startswith(y)
1000000 loops, best of 3: 321 ns per loop

In [4]: %timeit x[:3] == y
10000000 loops, best of 3: 164 ns per loop

令人惊讶的是，即使包括长度的计算，切片仍然显得更快：

In [5]: %timeit x[:len(y)] == y
1000000 loops, best of 3: 251 ns per loop

注意：此行为的第一部分在Python for Data Analysis（第 3 章）中有说明，但未提供任何解释。

.

如果有帮助：这里是 C 代码startswith；这是输出dis.dis：

In [6]: import dis

In [7]: dis_it = lambda x: dis.dis(compile(x, '<none>', 'eval'))

In [8]: dis_it('x[:3]==y')
  1           0 LOAD_NAME                0 (x)
              3 LOAD_CONST               0 (3)
              6 SLICE+2             
              7 LOAD_NAME                1 (y)
             10 COMPARE_OP               2 (==)
             13 RETURN_VALUE        

In [9]: dis_it('x.startswith(y)')
  1           0 LOAD_NAME                0 (x)
              3 LOAD_ATTR                1 (startswith)
              6 LOAD_NAME                2 (y)
              9 CALL_FUNCTION            1
             12 RETURN_VALUE
4

5 回答 5

41

一些性能差异可以通过考虑.操作员完成工作所花费的时间来解释：

>>> x = 'foobar'
>>> y = 'foo'
>>> sw = x.startswith
>>> %timeit x.startswith(y)
1000000 loops, best of 3: 316 ns per loop
>>> %timeit sw(y)
1000000 loops, best of 3: 267 ns per loop
>>> %timeit x[:3] == y
10000000 loops, best of 3: 151 ns per loop

另一部分差异可以用startswith一个函数来解释，即使是无操作函数调用也需要一些时间：

>>> def f():
...     pass
... 
>>> %timeit f()
10000000 loops, best of 3: 105 ns per loop

这并不能完全解释差异，因为使用切片和len调用函数的版本仍然更快（与sw(y)上面相比——267 ns）：

>>> %timeit x[:len(y)] == y
1000000 loops, best of 3: 213 ns per loop

我唯一的猜测是，也许 Python 优化了内置函数的查找时间，或者len调用被高度优化（这可能是真的）。可以使用自定义len函数对其进行测试。或者这可能是LastCoder确定的差异所在。还要注意larsmans的结果，这表明startswith对于较长的字符串实际上更快。上面的全部推理仅适用于我所说的开销实际上很重要的那些情况。

于 2012-11-07T13:48:59.767 回答
34

比较是不公平的，因为您只是在测量startswith返回的情况True。

>>> x = 'foobar'
>>> y = 'fool'
>>> %timeit x.startswith(y)
1000000 loops, best of 3: 221 ns per loop
>>> %timeit x[:3] == y  # note: length mismatch
10000000 loops, best of 3: 122 ns per loop
>>> %timeit x[:4] == y
10000000 loops, best of 3: 158 ns per loop
>>> %timeit x[:len(y)] == y
1000000 loops, best of 3: 210 ns per loop
>>> sw = x.startswith
>>> %timeit sw(y)
10000000 loops, best of 3: 176 ns per loop

此外，对于更长的字符串，startswith速度要快得多：

>>> import random
>>> import string
>>> x = '%030x' % random.randrange(256**10000)
>>> len(x)
20000
>>> y = r[:4000]
>>> %timeit x.startswith(y)
1000000 loops, best of 3: 211 ns per loop
>>> %timeit x[:len(y)] == y
1000000 loops, best of 3: 469 ns per loop
>>> sw = x.startswith
>>> %timeit sw(y)
10000000 loops, best of 3: 168 ns per loop

当没有匹配时，这仍然是正确的。

# change last character of y
>>> y = y[:-1] + chr((ord(y[-1]) + 1) % 256)
>>> %timeit x.startswith(y)
1000000 loops, best of 3: 210 ns per loop
>>> %timeit x[:len(y)] == y
1000000 loops, best of 3: 470 ns per loop
>>> %timeit sw(y)
10000000 loops, best of 3: 168 ns per loop
# change first character of y
>>> y = chr((ord(y[0]) + 1) % 256) + y[1:]
>>> %timeit x.startswith(y)
1000000 loops, best of 3: 210 ns per loop
>>> %timeit x[:len(y)] == y
1000000 loops, best of 3: 442 ns per loop
>>> %timeit sw(y)
10000000 loops, best of 3: 168 ns per loop

因此，startswith对于短字符串可能会更慢，因为它针对长字符串进行了优化。

（从这个答案中获取随机字符串的技巧。）

于 2012-11-07T14:03:18.493 回答
9

startswith比切片更复杂...

2924 result = _string_tailmatch(self,
2925 PyTuple_GET_ITEM(subobj, i),
2926 start, end, -1);

这不是大海捞针开始时发生的简单字符比较循环。我们正在查看一个 for 循环，它遍历一个向量/元组 (subobj) 并_string_tailmatch在其上调用另一个函数 ( )。多个函数调用在堆栈、参数完整性检查等方面有开销......

startswith是一个库函数，而切片似乎是内置在语言中的。

2919 if (!stringlib_parse_args_finds("startswith", args, &subobj, &start, &end))
2920 return NULL;
于 2012-11-07T13:43:59.370 回答
8

要引用文档，startswith您可能会想到更多：

str.startswith(prefix[, start[, end]])

True如果字符串以前缀开头，则返回，否则返回False。prefix 也可以是要查找的前缀元组。使用可选 的start，测试从该位置开始的字符串。使用可选的end，停止在该位置比较字符串。

于 2012-11-07T14:44:45.907 回答
0

调用函数非常昂贵。但是，我不知道用 C 编写的内置函数是否也是这种情况。

但请注意，切片也可能涉及函数调用，具体取决于所使用的对象。

于 2012-11-07T13:46:00.370 回答