如何使用 Python 进行切片
Posted on Wed, 25 Dec 2024 16:09:24 +0800 by LiangMingJian
什么是切片
切片是 Python 用来解决从某个对象中抽取部分值这一问题的一种方法，切片在实际使用时表现为一种表达式。
切片的表达式
一个完整的切片表达式包含两个冒号，用来分隔三个参数 start_index、end_index、step。当只有一个冒号时，默认第三个参数 step=1；当一个冒号也没有时，start_index=end_index，表示切取 start_index 指定的那个元素。
object[start_index:end_index:step]
- step：正负数均可，其绝对值大小决定了切取数据时的步长，而正负号决定了切取方向，正表示从左往右取值，负表示从右往左取值。当 step 省略时，默认为1，即从左往右以步长1取值。
- start_index：表示起始索引（包含该索引对应值），该参数省略时，表示从对象端点开始取值，至于是从起点还是从终点开始，则由 step 参数的正负决定，step 为正从起点开始，为负从终点开始。
- end_index：表示终止索引（不包含该索引对应值），该参数省略时，表示一直取到数据端点，至于是到起点还是到终点，同样由 step 参数的正负决定，step 为正时直到终点，为负时直到起点。
索引的方式
切片的索引包括正索引和负索引两部分，如下图所示，以 list 对象 a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 为例，正索引从序号小到大，负索引从序号大到小。
示例
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a. 切取单个元素
>>>a[0]
>>>0
>>>a[-4]
>>>6
# 当索引只有一个数时，表示切取某一个元素。
b. 切取完整对象
>>>a[:] # 从左往右
>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a[::] # 从左往右
>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a[::-1] # 从右往左
>>> [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
c. start_index 和 end_index 全为正（+）索引的情况
step=1，从左往右取值，start_index=1 到 end_index=6 同样表示从左往右取值。
>>>a[1:6]
>>> [1, 2, 3, 4, 5]
step=-1，决定了从右往左取值，而 start_index=1 到 end_index=6 决定了从左往右取值，两者矛盾，所以为空。
>>>a[1:6:-1]
>>> []
step=1，决定了从左往右取值，而 start_index=6 到 end_index=2 决定了从右往左取值，两者矛盾，所以为空。
>>>a[6:2]
>>> []
step=1，表示从左往右取值，而 start_index 省略时，表示从端点开始，因此这里的端点是起点，即从起点值 0 开始一直取到 end_index=6（该点不包括）。
>>>a[:6]
>>> [0, 1, 2, 3, 4, 5]
step=-1，从右往左取值，而 start_index 省略时，表示从端点开始，因此这里的端点是终点，即从终点值 9 开始一直取到 end_index=6（该点不包括）。
>>>a[:6:-1]
>>> [9, 8, 7]
step=1，从左往右取值，从 start_index=6 开始，一直取到终点值 9。
>>>a[6:]
>>> [6, 7, 8, 9]
step=-1，从右往左取值，从 start_index=6 开始，一直取到起点 0。
>>>a[6::-1]
>>> [6, 5, 4, 3, 2, 1, 0]
d. start_index 和 end_index 全为负（-）索引的情况
step=1，从左往右取值，而 start_index=-1 到 end_index=-6 决定了从右往左取值，两者矛盾，所以为空。
>>>a[-1:-6]
>>> []
step=-1，从右往左取值，start_index=-1 到 end_index=-6 同样是从右往左取值。
>>>a[-1:-6:-1]
>>> [9, 8, 7, 6, 5]
step=1，从左往右取值，而 start_index=-6 到 end_index=-1 同样是从左往右取值。
>>>a[-6:-1]
>>> [4, 5, 6, 7, 8]
step=1，从左往右取值，从起点开始一直取到 end_index=-6（该点不包括）。
>>>a[:-6]
>>> [0, 1, 2, 3]
step=-1，从右往左取值，从终点开始一直取到 end_index=-6（该点不包括）。
>>>a[:-6:-1]
>>> [9, 8, 7, 6, 5]
step=1，从左往右取值，从 start_index=-6 开始，一直取到终点。
>>>a[-6:]
>>> [4, 5, 6, 7, 8, 9]
step=-1，从右往左取值，从 start_index=-6 开始，一直取到起点。
>>>a[-6::-1]
>>> [4, 3, 2, 1, 0]
e. start_index 和 end_index 正（+）负（-）混合索引的情况
start_index=1 在 end_index=-6 的左边，因此从左往右取值，而 step=1 同样决定了从左往右取值。
>>>a[1:-6]
>>> [1, 2, 3]
start_index=1 在 end_index=-6 的左边，因此从左往右取值，但 step=-1 则决定了从右往左取值，两者矛盾，因此为空。
>>>a[1:-6:-1]
>>> []
start_index=-1 在 end_index=6 的右边，因此从右往左取值，但 step=1 则决定了从左往右取值，两者矛盾，因此为空。
>>>a[-1:6]
>>> []
start_index=-1 在 end_index=6 的右边，因此从右往左取值，而 step=-1 同样决定了从右往左取值。
>>>a[-1:6:-1]
>>> [9, 8, 7]
f. 多层切片操作
理论上可无限次多层切片操作，只要上一次返回的是非空可切片对象即可。
>>>a[:8][2:5][-1:]
>>> [4]
# 相当于：
a[:8]=[0, 1, 2, 3, 4, 5, 6, 7]
a[:8][2:5]= [2, 3, 4]
a[:8][2:5][-1:] = [4]
g. 切片操作的三个参数可以用表达式
>>>a[2+1:3*2:7%3]
>>> [3, 4, 5]
# 即：a[2+1:3*2:7%3] = a[3:6:1]
h. 其他对象的切片操作
前面的切片操作以 list 对象为例进行说明，但实际上可进行切片操作的数据类型还有很多，包括元组、字符串等等。
>>> (0, 1, 2, 3, 4, 5)[:3]
>>> (0, 1, 2)
>>>'ABCDEFG'[::2]
>>>'ACEG'
i. 取偶数位置的切片
>>>b = a[::2]
[0, 2, 4, 6, 8]
j. 取奇数位置的切片
>>>b = a[1::2]
[1, 3, 5, 7, 9]
k. 通过切片拷贝对象
>>>b = a[:]
>>>print(b) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>print(id(a)) # 41946376
>>>print(id(b)) # 41921864
>>>b = a.copy()
>>>print(b) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>print(id(a)) # 39783752
>>>print(id(b)) # 39759176
需要注意的是：[:] 和 .copy() 都属于浅拷贝，只拷贝最外层元素，内层嵌套元素则通过引用方式共享，而非独立分配内存，如果需要彻底拷贝则需采用深拷贝方式，如下例所示：
>>>a = [1,2,['A','B']]
>>>print('a={}'.format(a))
>>>b = a[:]
>>>b[0] = 9 # 修改b的最外层元素，将1变成9
>>>b[2][0] = 'D' # 修改b的内嵌层元素
>>>print('a={}'.format(a))
>>>print('b={}'.format(b))
>>>print('id(a)={}'.format(id(a)))
>>>print('id(b)={}'.format(id(b)))
a=[1, 2, ['A', 'B']] # 原始a
a=[1, 2, ['D', 'B']] # b修改内部元素A为D后，a中的A也变成了D，说明共享内部嵌套元素，但外部元素1没变。
b=[9, 2, ['D', 'B']] # 修改后的b
id(a)=38669128
id(b)=38669192
l. 在某个位置插入元素
>>>a[3:3] = ['A','B','C']
[0, 1, 2, 'A', 'B', 'C', 3, 4, 5, 6, 7, 8, 9]
>>>a[0:0] = ['A','B']
['A', 'B', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
f. 替换一部分元素
>>>a[3:6] = ['A','B']
[0, 1, 2, 'A', 'B', 6, 7, 8, 9]