我个人认为这就像一个for循环：

a[start:end:step]
# for(i = start; i < end; i += step)

此外，请注意，start和end的负值是相对于列表末尾的，并且在上面的示例中通过given_index+a.shape[0]计算。

在我看来，如果您按照以下方式查看Python字符串切片表示法（继续阅读），您将更好地理解和记忆它。

让我们使用以下字符串。。。

azString = "abcdefghijklmnopqrstuvwxyz"

对于不知道的人，可以使用符号azString[x:y]从azString创建任何子字符串

来自其他编程语言，这是常识受到损害的时候。x和y是什么？

为了寻找一种记忆技巧，我不得不坐下来运行了几个场景，帮助我记住x和y是什么，并帮助我在第一次尝试时正确地切分字符串。

我的结论是，x和y应该被视为围绕我们想要增加的字符串的边界索引。因此，我们应该将表达式视为azString[index1，index2]，或者更清晰地视为azString[index_of_first_charactere，index_after_the_last_character]。

这是一个可视化的例子。。。

Letters   a b c d e f g h i j ...
         ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑
             ┊           ┊
Indexes  0 1 2 3 4 5 6 7 8 9 ...
             ┊           ┊
cdefgh    index1       index2

因此，您所要做的就是将index1和index2设置为所需子字符串周围的值。例如，要获得子字符串“cdefgh”，可以使用azString[2:8]，因为“c”左侧的索引是2，而“h”右侧的索引是8。

请记住，我们正在设置边界。这些边界是可以放置一些括号的位置，括号将像这样围绕子字符串。。。

a b[c d e f g h]i j公司

这个技巧一直有效，而且很容易记住。

当我第一次看到切片语法时，有一些事情不是很明显：

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

反转顺序的简单方法！

如果出于某种原因，您希望以相反的顺序进行每一项：

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

我有点沮丧，因为找不到一个准确描述切片功能的在线源代码或Python文档。

我接受了Aaron Hall的建议，阅读了CPython源代码的相关部分，并编写了一些Python代码，这些代码执行切片与CPython中的切片类似。我已经用Python 3对整数列表进行了数百万次随机测试。

您可能会发现我的代码中对CPython中相关函数的引用很有用。

def slicer(x, start=None, stop=None, step=None):
    """ Return the result of slicing list x.  

    See the part of list_subscript() in listobject.c that pertains 
    to when the indexing item is a PySliceObject.
    """

    # Handle slicing index values of None, and a step value of 0.
    # See PySlice_Unpack() in sliceobject.c, which
    # extracts start, stop, step from a PySliceObject.
    maxint = 10000000       # A hack to simulate PY_SSIZE_T_MAX
    if step is None:
        step = 1
    elif step == 0:
        raise ValueError('slice step cannot be zero')

    if start is None:
        start = maxint if step < 0 else 0
    if stop is None:
        stop = -maxint if step < 0 else maxint

    # Handle negative slice indexes and bad slice indexes.
    # Compute number of elements in the slice as slice_length.
    # See PySlice_AdjustIndices() in sliceobject.c
    length = len(x)
    slice_length = 0

    if start < 0:
        start += length
        if start < 0:
            start = -1 if step < 0 else 0
    elif start >= length:
        start = length - 1 if step < 0 else length

    if stop < 0:
        stop += length
        if stop < 0:
            stop = -1 if step < 0 else 0
    elif stop > length:
        stop = length - 1 if step < 0 else length

    if step < 0:
        if stop < start:
            slice_length = (start - stop - 1) // (-step) + 1
    else:
        if start < stop:
            slice_length = (stop - start - 1) // step + 1

    # Cases of step = 1 and step != 1 are treated separately
    if slice_length <= 0:
        return []
    elif step == 1:
        # See list_slice() in listobject.c
        result = []
        for i in range(stop - start):
            result.append(x[i+start])
        return result
    else:
        result = []
        cur = start
        for i in range(slice_length):
            result.append(x[cur])
            cur += step
        return result

如果你觉得切片中的负指数令人困惑，这里有一个非常简单的方法来考虑：用len-index替换负指数。例如，用len（list）-3替换-3。

说明切片在内部做什么的最佳方法是在实现此操作的代码中显示它：

def slice(list, start = None, end = None, step = 1):
  # Take care of missing start/end parameters
  start = 0 if start is None else start
  end = len(list) if end is None else end

  # Take care of negative start/end parameters
  start = len(list) + start if start < 0 else start
  end = len(list) + end if end < 0 else end

  # Now just execute a for-loop with start, end and step
  return [list[i] for i in range(start, end, step)]

这里有一个简单的记忆方法，可以记住它是如何工作的：

S L*I*C*E*切片的“i”位于第一位，代表包容，“e”排在最后，代表独占。

所以array[j:k]将包括第j个元素，并排除第k个元素。