【Python】Python中的切片各种情况分析（注释最多、场景最全）

两种基本索引

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

注意a列表的下标索引序列有两种，非负索引系列是0到9,负索引系列-10到-1。索引下标的有效范围是-10到9，只要下标在这个范围都是合法的。
在实际切片时，如果出现了两种索引系列，可以秉承统一度量衡的原则，非负索引与负索引相互转换。
负索引 = 非负索引 - 序列对象长度
非负索引 = 负索引 + 序列对象长度

索引之间的转换

"""
1、从下面例子理解两种索引系列之间的转换
"""
# -1索引下标转换为正索引为9，
# -5索引下标转换为正索引为5，
# 5索引下标转换为负索引为-5，
# 9索引下标转换为负索引为-1，
# 以下四个例子均等价于a[5:9]
print(a[5:9])
print(a[5:-1])
print(a[-5:9])
print(a[-5:-1])

[5, 6, 7, 8]
[5, 6, 7, 8]
[5, 6, 7, 8]
[5, 6, 7, 8]

超出索引范围的情况

"""
从下面的例子举例说明切片时索引超过有效范围后的效果。也可以利用第一阶段将的"统一度量衡",
如果起始索引和终止索引是用不同的索引系列，则统一为同一索引系列后再分析。
超过索引范围的分析转换步骤如下
 1、超出范围的索引如果非负的话改为len(a),如果负的话改为-len(a)
 2、统一度量衡，全部采用非负索引系列

"""
print('-' * 10)
# a列表有效索引范围是-10到9的整数，
# 那么从5到100的整数递增的过程中索引值无效的元素取值为空，
# 于是索引值有效的是5 6 7 8 9，
# 所以等价于a[5:len(a)]
print(a[5:100])
print(a[5:len(a)])
print('-' * 10)

# a列表有效索引范围是-10到9的整数，
# 那么从-100到-5的整数递增的过程中索引值无效的元素取值为空，
# 于是索引值有效的是-10 -9 -8 -7 -6，
# 所以等价于a[-len(a):-5] 转换为非负索引表示为a[0:5]
print(a[-100:-5])
print(a[-len(a):-5])
print(a[-len(a) + len(a):-5 + len(a)])
print('-' * 10)

# a列表有效索引范围是-10到9的整数，
# 那么从-5到100的整数递增的过程中索引值无效的元素取值为空，
# 因为索引值-5对应的非负索引值为-5+len(a)=5
# 所以等价于a[-5:len(a)] 转换为非负索引表示为a[5:10]
print(a[-5:100])
print(a[-5:len(a)])
print(a[-5 + len(a):len(a)])
print('-' * 10)


# a列表有效索引范围是-10到9的整数，
# 那么从-100到5的整数递增的过程中索引值无效的元素取值为空，
# 于是索引值有效的是-10 -9 -8 -7 -6，
# 所以等价于a[-len(a):5] 转换为非负索引表示为a[0:5]
print(a[-100:5])
print(a[-len(a):5])
print(a[-len(a) + len(a):5])
print('-' * 10)

print(a[-100:100])
print(a[-len(a):len(a)])
print(a[-len(a) + len(a):len(a)])
print('-' * 10)

print(a[100:1000])
print(a[len(a):len(a)])
print('-' * 10)

print(a[-1000:-100])
print(a[-len(a):-len(a)])
print(a[-len(a) + len(a):-len(a) + len(a)])
print('-' * 10)

[5, 6, 7, 8, 9]
[5, 6, 7, 8, 9]
----------
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
----------
[5, 6, 7, 8, 9]
[5, 6, 7, 8, 9]
[5, 6, 7, 8, 9]
----------
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]
----------
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
----------
[]
[]
----------
[]
[]
[]
----------

起始索引大于终止索引时

print(a[6:5])
print(a[-4:5])
print(a[6:-5])
print(a[-4:-5])
print('-' * 10)

[]
[]
[]
[]
----------

起始索引和终止索引缺省

"""
起始索引和终止索引缺省时的情况
start的缺省值是无穷小(​)，stop的缺省值是无穷大(​)
"""

print(a[:5])
print(a[5:])
print(a[100:])
print('-' * 10)

[0, 1, 2, 3, 4]
[5, 6, 7, 8, 9]
[]
----------

拓展切片

"""
拓展切片
指的是这样的切片形式：a[start:stop:step]，其中step是一个非零整数，
即比简单切片多了调整步长的功能，此时切片的行为可概括为：
从start对应的位置出发，以step为步长索引序列，直至越过stop对应的位置，
且不包括stop本身。事实上，简单切片就是step=1的扩展切片的特殊情况。需要详细解释的是step分别为正数和负数的两种情况。

"""

# step为正数 无缺省 此种情况较容易理解
# 以下四组条代码是同一个效果
print(a[2:6:2])
print(a[-8:-4:2])
print(a[2:-4:2])
print(a[-8:6:2])
print('-' * 10)

# step为正数 缺省 此种情况较容易理解
# 以下两组组条代码是同一个效果
print(a[:6:2])
print(a[:-4:2])
print('-' * 10)

# 以下两组组条代码是同一个效果
print(a[2::2])
print(a[-8::2])
print('-' * 10)

# 以下两组组条代码是同一个效果
print(a[::2])
print(a[0:len(a):2])
print('-' * 10)

# step为负数 无缺省 步长为负数，表示逆序截取，转换后是同一索引系列后保证start>end, 否则取到的子字符串为空。
# 以下四条代码是同一个效果，把索引统一为非负索引后发现start<end 执行结果为空
print(a[2:6:-2])
print(a[-8:-4:-2])
print(a[2:-4:-2])
print(a[-8:6:-2])
print('-' * 10)

# 以下四条代码是同一个效果，把索引统一为非负索引后发现start>end 执行结果为从起始到终止从右往左方向的的序列
print(a[6:2:-2])
print(a[-4:2:-2])
print(a[6:-8:-2])
print(a[-4:-8:-2])
print('-' * 10)


# step为负数 缺省
# 缺省起始索引，起始索引填充正无穷，
# 缺省终止索引，终止索引填充负无穷，
# 以下两条代码是同一个效果
print(a[:6:-2])
print(a[:-4:-2])
print('-' * 10)

# 以下两组组条代码是同一个效果
print(a[2::-2])
print(a[-8::-2])
print('-' * 10)

#
print(a[::-2])
print('-' * 10)

[2, 4]
[2, 4]
[2, 4]
[2, 4]
----------
[0, 2, 4]
[0, 2, 4]
----------
[2, 4, 6, 8]
[2, 4, 6, 8]
----------
[0, 2, 4, 6, 8]
[0, 2, 4, 6, 8]
----------
[]
[]
[]
[]
----------
[6, 4]
[6, 4]
[6, 4]
[6, 4]
----------
[9, 7]
[9, 7]
----------
[2, 0]
[2, 0]
----------
[9, 7, 5, 3, 1]
----------