字符串切片的时间复杂度

Question

切片 Python 字符串的时间复杂度是多少？ 鉴于 Python 字符串是不可变的，我可以想象将它们切片为O(1)或O(n)具体取决于切片的实现方式。

我需要编写一个函数来遍历（可能很大）字符串的所有后缀。 我可以通过将后缀表示为整个字符串的元组加上一个索引来开始读取字符来避免对字符串进行切片，但这很丑陋。 相反，如果我天真地写我的函数是这样的：

def do_something_on_all_suffixes(big_string):
    for i in range(len(big_string)):
        suffix = big_string[i:]
        some_constant_time_operation(suffix)

...它的时间复杂度是O(n)还是O(n 2 ) ，其中n是len(big_string) ？

Answer 1

简短的回答： str切片，一般来说，复制。 这意味着为每个字符串的n后缀做切片的n正在执行O(n 2 )工作。 也就是说，如果您可以使用memoryview来处理bytes like objects以获得原始 bytes data 的零副本视图，则可以避免副本。 请参阅下面的如何进行零拷贝切片以了解如何使其工作。

长答案：(C)Python str不通过引用数据子集的视图进行切片。 str切片正好有三种操作模式：

1. 完整切片，例如mystr[:] ：返回对完全相同str的引用（不仅仅是共享数据，相同的实际对象， mystr is mystr[:]因为str是不可变的，所以这样做没有风险）
2. 零长度切片和（取决于实现）缓存长度为 1 的切片； 空字符串是单例（ mystr[1:1] is mystr[2:2] is '' ），长度为 1 的低序数字符串也是缓存的单例（在 CPython 3.5.0 上，它看起来像所有字符都可以表示在 latin-1 中，即range(256) Unicode 序数，被缓存）
3. 所有其他切片：切片的str在创建时被复制，此后与原始str无关

#3 是一般规则的原因是为了避免将大str保存在内存中的一小部分的问题。 如果你有一个 1GB 的文件，读入它并像这样切片（是的，当你可以搜索时它是浪费的，这是为了说明）：

with open(myfile) as f:
    data = f.read()[-1024:]

那么您将有 1 GB 的数据保存在内存中以支持显示最后 1 KB 的视图，这是一种严重的浪费。 由于切片通常很小，因此在切片上复制而不是创建视图几乎总是更快。 这也意味着str可以更简单； 它需要知道它的大小，但它也不需要跟踪数据的偏移量。

如何进行零拷贝切片

有办法在Python执行视图基于切片，并在Python 2，它将上工作str （因为str是字节样在Python 2，支承缓冲协议）。 使用 Py2 str和 Py3 bytes （以及许多其他数据类型，如bytearray 、 array.array 、 numpy数组、 mmap.mmap等），您可以创建一个memoryview视图，它是原始对象的零副本视图，并且可以在不复制数据的情况下进行切片。 因此，如果您可以使用（或编码）到 Py2 str /Py3 bytes ，并且您的函数可以使用任意bytes类对象，那么您可以这样做：

def do_something_on_all_suffixes(big_string):
    # In Py3, may need to encode as latin-1 or the like
    remaining_suffix = memoryview(big_string)
    # Rather than explicit loop, just replace view with one shorter view
    # on each loop
    while remaining_suffix:  # Stop when we've sliced to empty view
        some_constant_time_operation(remaining_suffix)
        remaining_suffix = remaining_suffix[1:]

memoryview的切片确实创建了新的视图对象（它们只是超轻量级，固定大小与它们查看的数据量无关），只是没有任何数据，所以some_constant_time_operation可以在需要时存储一个副本，它不会稍后我们将其切碎时发生了变化。 如果你需要一个正确的副本作为 Py2 str /Py3 bytes ，你可以调用.tobytes()来获取原始bytes obj，或者（在 Py3 中只有它出现），将它直接解码为从缓冲区复制的str ，例如str(remaining_suffix[10:20], 'latin-1') 。

Answer 2

这完全取决于你的切片有多大。 我将以下两个基准放在一起。 第一个切片整个字符串，第二个只是一点点。 使用此工具进行曲线拟合可提供

# s[1:-1]
y = 0.09 x^2 + 10.66 x - 3.25

# s[1:1000]
y = -0.15 x + 17.13706461

对于高达 4MB 的字符串切片，第一个看起来非常线性。 我想这确实衡量了构建第二个字符串所需的时间。 第二个是相当稳定的，虽然它太快了，可能不是那么稳定。

import time

def go(n):
    start = time.time()
    s = "abcd" * n
    for j in xrange(50000):

        #benchmark one
        a = s[1:-1]

        #benchmark two
        a = s[1:1000]

    end = time.time()
    return (end - start) * 1000

for n in range(1000, 100000, 5000):
    print n/1000.0, go(n)

Answer 3

如果您只是将它们打包在一个对象中，则传递索引并不是那么糟糕

from dataclasses import dataclass

@dataclass
class StrSlice:
    str: str
    start: int
    end: int

def middle(slice):
    return slice.str[(slice.start + slice.end) // 2]

def reverse(slice):
    return slice.str[slice.start : slice.end][::-1]

def length(slice):
    return slice.end - slice.start

def chars(slice):
    yield from (slice.str[i] for i in range(slice.start, slice.end)

def equals(slice1, slice2):
    if length(slice1) != length(slice2):
        return False
    return all(c1 == c2 for c1, c2 in zip(chars(slice1), chars(slice2))