为什么切片和范围上限是排他的？

Question

免责声明：我不是在问如果slice() 和range() 的上限stopargument 是独占的，或者如何 使用这些功能。

对range和slice函数的调用，以及切片符号[start:stop]都指的是整数集。

range([start], stop[, step])
slice([start], stop[, step])

在所有这些中，stop 整数被排除在外。

我想知道为什么语言是这样设计的。

当start等于0或被省略时，是使stop等于表示的整数集合中的元素个数吗？

是否有：

for i in range(start, stop):

看起来像下面的 C 代码？

for (i = start ; i < stop; i++) {

Answer 1

documentation 暗示它有一些有用的属性：

word[:2]    # The first two characters
word[2:]    # Everything except the first two characters

这是一个有用的切片操作不变量：s[:i] + s[i:] 等于 s。

对于非负索引，如果两个索引都在范围内，则切片的长度是索引的差。比如word[1:3]的长度就是2。

我认为我们可以假设范围函数的行为相同以保持一致性。

Answer 2

这是某个 Google+ 用户的opinion：

[...] 我被半开音程的优雅所左右。特别是 不变的是，当两个切片相邻时，第一个切片的结尾 index 是第二个切片的起始索引太漂亮了 忽视。例如，假设您将一个字符串拆分为三个部分 索引 i 和 j - 部分将是 a[:i]、a[i:j] 和 a[j:]。

Google+ 已关闭，因此链接不再可用。剧透警告：那是 Guido van Rossum。

Answer 3

优雅 VS 明显

说实话，我认为 Python 中的切片方式非常违反直觉，它实际上是在用更多的大脑处理来交换所谓的 优雅，这就是为什么你可以看到this StackOverflow article 有超过 2Ks 的点赞，我想是因为很多人一开始并不理解。

举个例子，下面的代码已经让很多 Python 新手头疼了。

x = [1,2,3,4]
print(x[0:1])
# Output is [1]

不仅难以处理，而且难以正确解释，例如上面代码的解释是取第0个元素直到第一个元素之前的元素。

现在看看使用上限包容性的 Ruby。

x = [1,2,3,4]
puts x[0..1]
# Output is [1,2]

坦率地说，我真的认为 Ruby 的切片方式对大脑更好。

当然，当您根据索引将列表拆分为 2 部分时，独占上限 方法会产生更好看的代码。

# Python
x = [1,2,3,4]
pivot = 2
print(x[:pivot]) # [1,2]
print(x[pivot:]) # [3,4]

现在让我们看看包容性上限方法

# Ruby
x = [1,2,3,4]
pivot = 2
puts x[0..(pivot-1)] # [1,2]
puts x[pivot..-1] # [3,4]

显然，代码不太优雅，但这里没有太多的大脑处理。

结论

归根结底，这真的是优雅 VS 明显的问题，Python 的设计者更喜欢优雅而不是明显。为什么？因为Zen of Python 声明美胜于丑。

Answer 4

这个问题有点晚了，不过，这试图回答您问题的为什么部分：

部分原因是因为我们在寻址内存时使用从零开始的索引/偏移量。

最简单的例子是数组。将“6 个项目的数组”视为存储 6 个数据项的位置。如果这个数组的起始位置是内存地址 100，那么数据，比如 6 个字符 'apple\0' 的存储方式如下：

memory/
array      contains
location   data
 100   ->   'a'
 101   ->   'p'
 102   ->   'p'
 103   ->   'l'
 104   ->   'e'
 105   ->   '\0'

所以对于 6 个项目，我们的索引从 100 变为 105。地址是 使用 base + offset 生成，因此第一项位于 base memory location 100 + offset 0 （即 100 + 0），第二个在 100 + 1，第三个在 100 + 2，...，直到 100 + 5 是最后一个位置。

这是我们使用基于零的索引的主要原因，并导致 C语言中的for循环等语言结构：

for (int i = 0; i < LIMIT; i++)

或在 Python 中：

for i in range(LIMIT):

当您使用像 C 这样处理指针的语言进行编程时 更直接，或者更直接地组装，这个base+offset方案 变得更加明显。

由于上述原因，许多语言结构会自动使用从 start 到 length-1 的范围。

您可能会在 Wikipedia 上的 Zero-based numbering 和 this question from Software Engineering SE 上发现这篇文章很有趣。

示例：

例如，在 C 中，如果您有一个数组 ar 并将其下标为 ar[3]，这实际上等同于获取数组 ar 的（基）地址并将 3 添加到它 => @987654331 @ 可能会导致这样的代码打印数组的内容，显示简单的 base+offset 方法：

for(i = 0; i < 5; i++)
   printf("%c\n", *(ar + i));

真的等价于

for(i = 0; i < 5; i++)
   printf("%c\n", ar[i]);

Answer 5

以下是独占上限是一种更明智的方法的另一个原因：

假设您希望编写一个函数，将一些变换应用于列表中的项目子序列。如果间隔按照您的建议使用包含上限，您可能会天真地尝试将其写为：

def apply_range_bad(lst, transform, start, end):
     """Applies a transform on the elements of a list in the range [start, end]"""
     left = lst[0 : start-1]
     middle = lst[start : end]
     right = lst[end+1 :]
     return left + [transform(i) for i in middle] + right

乍一看，这似乎是直截了当和正确的，但不幸的是它是微妙的错误。

如果发生以下情况会发生什么：

• start == 0
• end == 0
• end < 0

？一般来说，您可能应该考虑更多的边界情况。谁愿意浪费时间思考所有这些？ （这些问题的出现是因为通过使用包含上下界，没有固有的方式来表示空区间。）

相反，通过使用上界互斥的模型，将列表分成单独的切片更简单、更优雅，因此不易出错：

def apply_range_good(lst, transform, start, end):
     """Applies a transform on the elements of a list in the range [start, end)"""
     left = lst[0:start]
     middle = lst[start:end]
     right = lst[end:]
     return left + [transform(i) for i in middle] + right

（请注意，apply_range_good 不会转换 lst[end]；它也将 end 视为独占上限。尝试使其使用包容性上限仍然会遇到我前面提到的一些问题。寓意是包容性的上限通常很麻烦。）

（大部分改编自an old post of mine about inclusive upper-bounds in another scripting language。）

Answer 6

这个上限排除极大地提高了代码理解。我希望它适用于其他语言。