提问人：Chris 提问时间：2/27/2011 最后编辑：nbroChris 更新时间：4/27/2023 访问量：76274
在 Python 中对列表进行切片而不生成副本
Slicing a list in Python without generating a copy
问：
我有以下问题。
给定一个整数列表，我需要生成所有的子列表，而不生成副本。
LL[k:]for k in [0, len(L) - 1]
如何在 Python 中完成此操作？以某种方式使用缓冲区对象？
答：
31赞
Amber
2/27/2011
#1
根据您正在执行的操作，您也许可以使用 islice。
由于它通过迭代运行，因此它不会创建新列表，而是简单地创建迭代器，这些迭代器是原始列表中的元素，根据其范围的要求。yield
评论
11赞
jgomo3
3/9/2017
这里的坏处是，islice 没有利用实现 getitem 方法的对象，将所有内容视为迭代器，因此它将始终从列表的第一个元素进行迭代，直到它到达列表的第一个位置，以开始生成范围内的值。
180赞
senderle
2/27/2011
#2
简短的回答
切片列表不会生成列表中对象的副本;它只是复制对它们的引用。这就是所问问题的答案。
长答案
测试可变值和不可变值
首先，让我们测试一下基本声明。我们可以证明，即使在像整数这样的不可变对象的情况下，也只复制引用。下面是三个不同的整数对象，每个对象都具有相同的值：
>>> a = [1000 + 1, 1000 + 1, 1000 + 1]
它们具有相同的值，但您可以看到它们是三个不同的对象，因为它们具有不同的 s：id
>>> map(id, a)
[140502922988976, 140502922988952, 140502922988928]
对它们进行切片时，引用保持不变。未创建任何新对象：
>>> b = a[1:3]
>>> map(id, b)
[140502922988952, 140502922988928]
使用具有相同值的不同对象表明复制过程不会打扰实习 - 它只是直接复制引用。
使用可变值进行测试会给出相同的结果：
>>> a = [{0: 'zero', 1: 'one'}, ['foo', 'bar']]
>>> map(id, a)
[4380777000, 4380712040]
>>> map(id, a[1:]
... )
[4380712040]
检查剩余内存开销
当然，参考文献本身是复制的。在 64 位计算机上，每个字节的成本为 8 个字节。每个列表都有自己的 72 字节内存开销：
>>> for i in range(len(a)):
... x = a[:i]
... print('len: {}'.format(len(x)))
... print('size: {}'.format(sys.getsizeof(x)))
...
len: 0
size: 72
len: 1
size: 80
len: 2
size: 88
正如 Joe Pinsonault 提醒我们的那样，这种开销会加起来。整数对象本身不是很大——它们比引用大三倍。因此，这在绝对意义上为您节省了一些内存，但渐近地，能够将多个列表作为“视图”放入同一内存中可能会很好。
使用视图节省内存
不幸的是，Python 没有提供简单的方法来将“视图”生成到列表中的对象。或者也许我应该说“幸运”！这意味着您不必担心切片来自哪里;对原始内容的更改不会影响切片。总的来说，这使得对程序行为的推理变得更加容易。
如果确实想通过使用视图来节省内存，请考虑使用数组。切片数组时，内存在切片和原始数组之间共享：numpynumpy
>>> a = numpy.arange(3)
>>> a
array([0, 1, 2])
>>> b = a[1:3]
>>> b
array([1, 2])
当我们修改并再次查看时会发生什么？ab
>>> a[2] = 1001
>>> b
array([ 1, 1001])
但这意味着你必须确保当你修改一个对象时，你不会无意中修改另一个对象。这就是使用时的权衡：计算机的工作量减少，程序员的工作量增加！numpy
评论
3赞
trichoplax is on Codidact now
3/19/2014
在不可变对象（如元组）中，引用是不可变的，但它们引用的项可以是可变的。因此，3 个列表的元组无法更改，它将始终引用相同的 3 个列表，但每个列表的内容可以像在任何列表中一样更改。
8赞
Exp HP
1/8/2016
虽然答案是正确的，但该示例实际上并没有演示它，因为小整数被拘禁了;尝试做甚至.一个更好的例子是使用 。id(2)id(1+1)a = [[], [], []]
2赞
Exp HP
1/8/2016
或者实际上，在进一步阅读后，这个问题实际上指定了列表是由整数组成的，所以我觉得很奇怪，作者甚至一开始就担心项目副本！（我很快就会认为 OP 没有完全理解您的澄清请求，实际上想将“意见”纳入原始列表）
2赞
Joe Pinsonault
12/10/2016
这个答案是正确的，但我认为值得指出的是，如果你有非常大的数组，复制指针数组仍然很昂贵
0赞
senderle
12/12/2016
@ExpHP，这可能是真的。我尽量不啰嗦，但我想对于这样的问题来说是不可能的！编辑。
8赞
Mateen Ulhaq
3/6/2020
#3
islice 的简单替代方法，它不需要循环访问列表项：
def listslice(xs, *args):
for i in range(len(xs))[slice(*args)]:
yield xs[i]
用法：
>>> xs = [0, 2, 4, 6, 8, 10]
>>> for x in listslice(xs, 2, 4):
... print(x)
4
6
4赞
Elliot Cameron
8/15/2020
#4
我写了一个类，甚至避免复制列表的脊柱：ListView
https://gist.github.com/3noch/b5f3175cfe39aea71ca4d07469570047
这支持嵌套切片，以便您可以继续切片到视图中以获得更窄的视图。例如：。ListView(list(range(10)))[4:][2:][1] == 7
请注意，这还没有完全完成，当基础列表与测试套件一起发生突变时，应该进行更多的错误检查。
7赞
gatopeich
10/15/2020
#5
通常，列表切片是最佳选择。
下面是一个快速的性能比较：
from timeit import timeit
from itertools import islice
for size in (10**4, 10**5, 10**6):
L = list(range(size))
S = size // 2
def sum_slice(): return sum(L[S:])
def sum_islice(): return sum(islice(L, S, None))
def sum_for(): return sum(L[i] for i in range(S, len(L)))
assert sum_slice() == sum_islice()
assert sum_slice() == sum_for()
for method in (sum_slice, sum_islice, sum_for):
print(f'Size={size}, method={method.__name__}, time={timeit(method, number=1000)} ms')
结果：
Size=10000, method=sum_slice, time=0.0298 ms
Size=10000, method=sum_islice, time=0.0449 ms
Size=10000, method=sum_for, time=0.2500 ms
Size=100000, method=sum_slice, time=0.3262 ms
Size=100000, method=sum_islice, time=0.4492 ms
Size=100000, method=sum_for, time=2.4849 ms
Size=1000000, method=sum_slice, time=5.4092 ms
Size=1000000, method=sum_islice, time=5.1139 ms
Size=1000000, method=sum_for, time=26.198 ms
评论