列表切片

lzb1001

>>> list = [1, 2, 3, 4, 5, 6]

哪位大神能讲解一下下面代码的意思？

>>> list[:-1]
[1, 2, 3, 4, 5]

>>> list[::-1]
[6, 5, 4, 3, 2, 1]

>>> list[2:-1]
[3, 4, 5]

>>> list[2::-1]
[3, 2, 1]

>>> list[2:-2]
[3, 4]

>>> list[2::-2]
[3, 1]

>>> list[3:-1]
[4, 5]

>>> list[4:-1]
[5]

>>> list[5:-1]
[]

>>> list[6:-1]
[]

>>> list[7:-1]
[]

>>> list[1:-1]
[2, 3, 4, 5]

>>> list[0:-1]
[1, 2, 3, 4, 5]

歌者文明清理员

list[起始:起始+切出来的元素个数]
-1=倒数第一个

lzb1001

歌者文明清理员 发表于 2023-3-26 09:15
list[起始:起始+切出来的元素个数]
-1=倒数第一个

感谢，还是没看懂意思呢，能否结合上面的例子和返回值介绍下，谢谢

歌者文明清理员

lzb1001 发表于 2023-3-26 09:17
感谢，还是没看懂意思呢，能否结合上面的例子和返回值介绍下，谢谢

可以这样理解：
list[起始:终止+1]
索引是0，1，2，3
所以起始是0，1，2，3
终止是1，2，3，4

liuhongrun2022

给你个例子解释下

>>> list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> list[:]
['a', 'b', 'c', 'd', 'e', 'f', 'g']    # 所有元素
>>> list[2:]
['c', 'd', 'e', 'f', 'g']              # 从索引 2 开始的所有元素
>>> list[:5]
['a', 'b', 'c', 'd', 'e']              # 索引 5 之前的所有元素（不包括索引 5）
>>> list[1:6:2]
['b', 'd', 'f']                        # 索引从 1 到 6，步长为 2 的所有元素

歌者文明清理员

1. -1代表最后一个，list[:-1]代表从第一个到最后一个，但是不包含最后一个，是1-5
2. 前两个参数省略，代表从最后一个到第一个（含），但是-1代表倒序，是6-1
3. 索引2（3）到第一个（含），但是-1，是3-1
4. 索引2（3）到倒数第二个（不含），是3-4
5. 索引2（3）到第一个（含），但是步长为-2，是3、1
6. 索引3（4）到倒数第一个（不含），是4-5
7. 索引4（5）到倒数第一个（不含），是5-5
8. 索引5（6）到倒数第一个（不含），啥都没有，是空列表

切片的语法：

list[start:]         #从start到最后一个（含）
list[:end]           #从第一个到end（不含）
list[start:end]      #从start到end（不含）
list[start:end:step] #从start到end（不含），步长为step（步长不能为0。如果步长是负数，则start>=end）
list[:end:step]      #start=0
list[start::step]    #end=len(list)

另外第八个是不是最后面，是：
[  ]  [  ]  [  ]  [  ]  [  ] || [  ]
是||那个地方的空

lzb1001

歌者文明清理员 发表于 2023-3-26 09:19
可以这样理解：
list[起始:终止+1]
索引是0，1，2，3

好像不对。

>>> list = [1, 2, 3, 4, 5, 6]
>>> list[2:5]
[3, 4, 5]

起始就是索引值对应的元素，终止应该是索引值-1后对应的元素

lzb1001

liuhongrun2022 发表于 2023-3-26 09:23
给你个例子解释下

谢谢，这个我理解

isdkz

这段代码是用Python编写的，它展示了如何使用切片（slicing）操作从列表（list）中提取元素。列表list包含从1到6的整数。接下来，我会解释每一行代码的含义：

1、list[:-1]：返回列表list中除了最后一个元素之外的所有元素。结果是[1, 2, 3, 4, 5]。
2、list[2:-1]：从列表list中的第三个元素（索引为2）开始，返回除了最后一个元素之外的所有元素。结果是[3, 4, 5]。
3、list[2:-2]：从列表list中的第三个元素（索引为2）开始，返回倒数第二个元素之前的所有元素。结果是[3, 4]。
4、list[3:-1]：从列表list中的第四个元素（索引为3）开始，返回除了最后一个元素之外的所有元素。结果是[4, 5]。
5、list[4:-1]：从列表list中的第五个元素（索引为4）开始，返回除了最后一个元素之外的所有元素。结果是[5]。
6、list[5:-1]：从列表list中的第六个元素（索引为5）开始，返回除了最后一个元素之外的所有元素。结果是[]（空列表）。
7、list[6:-1]：从列表list中的第七个元素（索引为6）开始，返回除了最后一个元素之外的所有元素。结果是[]（空列表）。
8、list[7:-1]：从列表list中的第八个元素（索引为7）开始，返回除了最后一个元素之外的所有元素。结果是[]（空列表）。
9、list[1:-1]：从列表list中的第二个元素（索引为1）开始，返回除了最后一个元素之外的所有元素。结果是[2, 3, 4, 5]。
10、list[0:-1]：从列表list中的第一个元素（索引为0）开始，返回除了最后一个元素之外的所有元素。结果是[1, 2, 3, 4, 5]。
11、list[:-1]：这一行代码重复了第一行代码，返回列表list中除了最后一个元素之外的所有元素。结果是[1, 2, 3, 4, 5]。

切片操作的基本格式是list[start:end]，其中start是起始索引（包含），end是结束索引（不包含）。如果省略start，则默认从列表的第一个元素开始；如果省略end，则默认切片到列表的最后一个元素。当使用负数作为end时，它表示从列表末尾开始计算的索引。例如，-1表示列表的最后一个元素，-2表示倒数第二个元素，依此类推。

在这个示例中，你可以看到负数索引用于end参数，用于指定从列表末尾开始计算的位置。这允许你轻松地操作列表的尾部元素。注意，当起始索引大于等于列表长度时，切片操作返回一个空列表。例如，在这个例子中，list[6:-1]和list[7:-1]都返回空列表[]。

总之，这段代码通过使用Python列表切片操作，展示了如何从列表中提取部分元素。通过调整起始索引（start）和结束索引（end），你可以选择性地获取列表中的任何元素子集。

歌者文明清理员

lzb1001 发表于 2023-3-26 09:45
好像不对。

>>> list = [1, 2, 3, 4, 5, 6]

看六楼的消息，顺便设个最佳答案

lzb1001

歌者文明清理员 发表于 2023-3-26 09:32
1. -1代表最后一个，list[:-1]代表从第一个到最后一个，但是不包含最后一个，是1-5
2. 前两个参数省略，代 ...

问题1：切片的语法是否适用于以下？

>>> list[::-1]
[6, 5, 4, 3, 2, 1]

>>> list[2::-1]
[3, 2, 1]

>>> list[2::-2]
[3, 1]

>>> list[2::4 -2]
[3, 5]

>>> list[2::2]
[3, 5]


问题2：大神你说

另外第八个是不是最后面，是：
[  ]  [  ]  [  ]  [  ]  [  ] || [  ]
是||那个地方的空

我没看懂你的意思……

歌者文明清理员

lzb1001 发表于 2023-3-28 16:34
问题1：切片的语法是否适用于以下？

>>> list[::-1]

问题1：yes
问题2：你慢慢学就知道了，不理解不影响写程序

lzb1001

歌者文明清理员 发表于 2023-3-28 17:13
问题1：yes
问题2：你慢慢学就知道了，不理解不影响写程序

你好大神：

以下四个结合切片的语法愣是没看懂，可否指点：

>>> list[2::-1]
[3, 2, 1]

>>> list[2::-2]
[3, 1]

>>> list[2::4 -2]
[3, 5]

>>> list[2::2]
[3, 5]

歌者文明清理员

lzb1001 发表于 2023-3-28 17:47
你好大神：

以下四个结合切片的语法愣是没看懂，可否指点：

1. 没有end参数，就代表最后一个，因为step是-1，所以这里end其实是“第一个”的意思
2. 同1，但是step=-2，即两个元素中只取索引大的那个
3. 4-2是2，从索引2开始到最后一个步长是二，两个元素中取索引小的那个
4. 同3

星际的远客

这些代码都是在 Python 中使用的 List（列表）的切片操作。

List 是一个有序的序列，可以包含任何类型的数据。切片是从列表中提取一部分元素的操作。它可以通过指定开始和结束索引来实现。开始索引是需要包含的第一个元素的索引，结束索引是不包含在结果中的第一个元素的索引。

现在我们来解释这些切片操作的含义：

list[:-1] 返回列表中除最后一个元素外的所有元素，即 [1, 2, 3, 4, 5]。

list[::-1] 返回列表的反转版本，即 [6, 5, 4, 3, 2, 1]。

list[2:-1] 返回从第 2 个元素开始到倒数第 2 个元素之前的所有元素，即 [3, 4, 5]。

list[2::-1] 返回从第 2 个元素开始到列表的开头的所有元素的反转版本，即 [3, 2, 1]。

list[2:-2] 返回从第 2 个元素开始到倒数第 2 个元素之前的所有元素，即 [3, 4]。

list[2::-2] 返回从第 2 个元素开始到列表的开头的每隔一个元素的所有元素的反转版本，即 [3, 1]。

list[3:-1] 返回从第 3 个元素开始到倒数第 2 个元素之前的所有元素，即 [4, 5]。

list[4:-1] 返回从第 4 个元素开始到倒数第 2 个元素之前的所有元素，即 [5]。

list[5:-1] 返回从第 5 个元素开始到倒数第 2 个元素之前的所有元素，即 []，因为开始索引比结束索引晚。

list[6:-1] 返回从第 6 个元素开始到倒数第 2 个元素之前的所有元素，即 []，因为开始索引比结束索引晚。

list[7:-1] 返回从第 7 个元素开始到倒数第 2 个元素之前的所有元素，即 []，因为开始索引比结束索引晚。

list[1:-1] 返回从第 1 个元素开始到倒数第 2 个元素之前的所有元素，即 [2, 3, 4, 5]。

list[0:-1] 返回从第 0 个元素开始到倒数第 2 个元素之前的所有元素，即 [1, 2, 3, 4, 5]。这个切片包括列表的所有元素，除了最后一个元素。

在这些切片操作中，冒号左边的数字表示开始索引，冒号右边的数字表示结束索引。如果开始索引被省略，它默认为 0；如果结束索引被省略，它默认为列表的长度。

切片还支持步长参数。步长是指提取元素时从一个元素到下一个元素的跨度。例如，在 list[2::-2] 中，步长为 -2，因此返回的列表包含从第 2 个元素开始的每隔一个元素的所有元素的反转版本。