python中将列表一分为二的时间复杂度

像

some_list[i:i+k]

这样的切片操作需要O（k）时间，因为在根据创建新列表时，它必须从i迭代到i+k

---

我对列表切片操作的时间复杂性感到困惑，比如

chunk\u 1，chunk\u 2=some\u list[：chunk\u size]，some\u list[chunk\u size:][/code>

相应地，此类操作的总体时间复杂度应为：

while some_list:
    chunk, some_list = some_list[:chunk_size], some_list[chunk_size:]

我想，在这个操作中，将元素复制到新块的成本也会增加总体成本

有没有更好的方法将一个大列表分成大小相等的块

更新：

执行了一些分析以检查while循环是否为O（n^2）操作。添加结果：

In [1]: def chunk(l, c):
   ...:     while l:
   ...:         l_c, l = l[:c], l[c:]
   ...:

In [2]: l = list(range(1000))

In [3]: %timeit chunk(l, 10)
134 µs ± 702 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [4]: l = list(range(10000))

In [5]: %timeit chunk(l, 10)
16.1 ms ± 99.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [6]: l = list(range(100000))

In [7]: %timeit chunk(l, 10)
1.91 s ± 14 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

就时间复杂性而言，有人能提出更好的方法吗？列表中的数据不是数字，因此不能使用Numpy。
您可以使用
generator
<代码>生成器将更加高效，因为它将
生成
块：

def chunks(lst, n):
    """Yield successive n-sized chunks from lst."""
    for i in range(0, len(lst), n):
        yield lst[i:i + n]

请看这里的原始答案。
chunk_1，chunk_2=some_list[：chunk_size]，some_list[chunk_size:][/code>不是一个切片操作，而是两个切片操作，每个操作都需要时间O（k）。要添加到@DYZ，每个操作都有不同的时间复杂度，因为k不同，
O（k_1）
和
O（k（k_2）
其中
k_1
+
k_2
是原始列表的总长度。顺便说一句，您编写的循环是错误的，
some\u list
和
chunk
应该反转。可能创建一个迭代器，如
some\u iter=iter（some\u list）
，然后使用？不，时间复杂度是
O（k\u 1）+O（k\u 2）
，应该接近
O（n）
而不是
O（n^2）
@adrio但这将是每个步骤的时间复杂性。因此，逻辑的复杂性应该是O（n*n/chunk\u size）~=O（n^2）。我说的是while循环，它甚至没有解决真正的问题。我担心操作的复杂性。我已经回答了您问题的这一部分
“是否有更好的方法将大列表分成大小均匀的块？”
当然，生成器将降低时间和内存复杂性。这不会降低时间复杂性。。只有记忆。