1. 基础回顾：负索引怎么算的

Python 里负索引是从右往左数的，-1是最后一个元素，-len(lst)是第一个元素。这个大家都懂。

切片语法 lst[start:stop:step]里，start 和 stop 都可以是负数。Python 的处理方式是：先把负索引转换成对应的正索引，然后再做切片。

a = [0, 1, 2, 3, 4, 5]

# a[-1] -> a[5] -> 5

# a[-3:-1] -> a[3:5] -> [3, 4]

到这里都很正常。

2. 第一个坑：负索引超出范围的情况

正索引超出范围会报 IndexError，但切片不会。负索引也有类似的"宽容"行为。

a = [0, 1, 2, 3, 4, 5]

# 这个没问题，-10 比 -len(a) 还小

print(a[-10:]) # [0, 1, 2, 3, 4, 5]

# Python 自动把 -10 截断成 -6（即索引 0）

# 反过来也一样

print(a[:-10]) # []

# -10 被截断成 -6，等价于 a[:0]

原理： Python 在处理切片时，对超出范围的索引做了 clamp（截断），而不是抛异常。负索引同样适用这条规则，只是 clamp 的范围变成了 [-len, len-1]。

3. 第二个坑：step 为负时的负索引

这才是真正的鬼故事现场。当 step 为负数时，切片的遍历方向是从右往左。这时候负索引的含义虽然不变，但 start 和 stop 的边界逻辑完全反过来了。

a = [0, 1, 2, 3, 4, 5]

# 从索引 4 向左走到索引 1（不含）

print(a[4:1:-1]) # [4, 3, 2]

# 用负索引写同样的逻辑

print(a[-2:-5:-1]) # [4, 3, 2]

# -2 -> 4, -5 -> 1, 步长 -1，从 4 走到 1（不含）

# 这个呢？

print(a[-1:-7:-1]) # [5, 4, 3, 2, 1, 0]

# -1 -> 5, -7 超出范围被截断成 -6 -> 0，从 5 走到 0（不含），完美反转

但注意这个：

print(a[-7:-1:-1]) # []

为什么？-7被截断成 -6（即索引 0），-1是索引 5。step 为 -1 表示从索引 0 往左走，但索引 0 左边已经没有元素了，所以结果是空列表。

关键点：负 step 时，start 必须在 stop 的右边（按原始顺序），否则得到空列表。负索引转换完以后，这个逻辑依然成立。

4. 第三个坑：start 和 stop 都是负且相等

a = [0, 1, 2, 3, 4, 5]

print(a[-3:-3]) # []

print(a[-3:-3:1]) # []

print(a[-3:-3:-1]) # []

三个都是空列表。这跟正索引的逻辑一致：切片区间是左闭右开，start 等于 stop 时区间为空。

但等一下，step 为负的情况呢？

# 从 -3 往左走到 -3，还是空

print(a[-3:-3:-1]) # []

没错，即使方向变了，起点和终点是同一个点，区间长度为零。

5. 第四个坑：省略 start 或 stop 时的默认值

省略 start 或 stop 时，Python 会用 None代替，然后根据 step 的正负来决定默认值。

step > 0：start 默认 0，stop 默认 len(a)

step < 0：start 默认 len(a)-1，stop 默认 -len(a)-1（即第一个元素左边的位置）

这就导致了下面这个经典操作：

a = [0, 1, 2, 3, 4, 5]

# 反转列表

print(a[::-1]) # [5, 4, 3, 2, 1, 0]

# step=-1, start 默认 -1, stop 默认 -7（被截断成 -6）

# 这个跟上面等价

print(a[-1::-1]) # [5, 4, 3, 2, 1, 0]

# 但这个不一样

print(a[:-1:-1]) # []

# 等价于 a[0:-1:-1]，从 0 往左走到 5（不含），走不了，空

注意 a[::-1]和 a[:-1:-1]的区别：

a[::-1]：从头到尾反向取，全量反转

a[:-1:-1]：从开头反向取到倒数第一个（不含），结果是空

这个很多人会搞混。

6. 第五个坑：字符串的负索引切片

字符串的行为跟列表一样，但因为字符串不可变，有些人会误以为切片行为不同。

s = "hello"

# 这个没问题

print(s[-3:-1]) # "ll"

# 这个呢？

print(s[-1:-3:-1]) # "ol"

# 从最后一个字符往左走到倒数第三个（不含）

# 经典反转

print(s[::-1]) # "olleh"

都一样，没什么特殊的。

7. 实战经验：调试负索引切片的技巧

如果你在写代码时被负索引切片搞晕了，有两个调试方法：

方法一：手动转成正索引再推理

# 遇到 a[-5:-2:2]

# -5 -> len(a)-5, -2 -> len(a)-2

# 假设 len(a)=8，那就是 a[3:6:2]

方法二：用 range 模拟切片逻辑

def slice_indices(length, start, stop, step):

"""模拟切片索引计算"""

if step is None:

step = 1

if start is None:

start = length - 1 if step < 0 else 0

elif start < 0:

start = max(length + start, 0)

if stop is None:

stop = -length - 1 if step < 0 else length

elif stop < 0:

stop = max(length + stop, 0)

return list(range(start, stop, step))

print(slice_indices(6, -2, -5, -1)) # [4, 3, 2]

这样你就知道切片会取出哪些索引了。

总结

场景

结果

原因

a[-10:]

整个列表

负索引被 clamp 到有效范围

a[-2:-5:-1]

[4, 3, 2]

负转正后从 4 走到 1

a[-1:-7:-1]

反转列表

从末尾走到开头

a[:-1:-1]

空列表

从 0 往左走不到 -1

a[-3:-3]

空列表

区间长度为零

一句话记住：负索引先转正，再按正索引的切片规则处理，step 为负时方向相反，边界 clamp 到有效范围内。

ITPub博客

Python 负索引与切片组合的微妙边缘情况

最新文章