我发现更容易记住它是如何工作的，然后我可以找出任何特定的开始/停止/步骤组合。

首先了解range（）是很有启发性的：

def range(start=0, stop, step=1):  # Illegal syntax, but that's the effect
    i = start
    while (i < stop if step > 0 else i > stop):
        yield i
        i += step

从起点开始，一步一步递增，不要到达终点。非常简单。

关于消极步骤，需要记住的一点是，停止总是被排除的终点，无论它是高还是低。如果您希望相同的切片以相反的顺序进行，则单独进行反转会更为简单：例如，“abcde”[1:-2][:：-1]从左侧切下一个字符，从右侧切下两个字符，然后反转。（另请参见reversed（）。）

序列切片是相同的，只是它首先规范了负索引，并且它永远不能超出序列：

TODO:当abs（step）>1时，下面的代码出现了一个错误：“从不超出序列”；我认为我修补了它是正确的，但很难理解。

def this_is_how_slicing_works(seq, start=None, stop=None, step=1):
    if start is None:
        start = (0 if step > 0 else len(seq)-1)
    elif start < 0:
        start += len(seq)
    if not 0 <= start < len(seq):  # clip if still outside bounds
        start = (0 if step > 0 else len(seq)-1)
    if stop is None:
        stop = (len(seq) if step > 0 else -1)  # really -1, not last element
    elif stop < 0:
        stop += len(seq)
    for i in range(start, stop, step):
        if 0 <= i < len(seq):
            yield seq[i]

不要担心“无”的细节——只需记住，省略开始和/或停止总是正确的做法，以提供整个序列。

首先规范化负索引允许开始和/或停止从结尾独立计数：'abcde'[1:-2]=='abcde'[1:3]=='bc'，尽管范围（1，-2）==[]。标准化有时被认为是“对长度取模”，但注意它只增加了一次长度：例如，“abcde”[-53:42]只是整个字符串。

通常，使用大量硬编码索引值编写代码会提高可读性以及维护混乱。例如，如果一年后你回到代码，你会看看它，想知道你写的时候在想什么只是一种更清楚地说明代码实际在做什么的方式。通常，内置slice（）创建一个切片对象，可以在切片的任何位置使用允许。例如：

>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]
>>> del items[a]
>>> items
[0, 1, 4, 5, 6]

如果您有一个切片实例，您可以通过查看它的s.start、s.stop和s.step属性。例如：

>>>a=切片（10、50、2）>>>a.启动10>>>a.停止50>>>a.台阶2.>>>

我想加一个你好，世界！为初学者解释切片基础知识的示例。这对我帮助很大。

让我们列出六个值[“P”、“Y”、“T”、“H”、“O”、“N”]：

+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
  0   1   2   3   4   5

现在，该列表中最简单的部分是其子列表。符号是[<index>：<index>]，关键是这样读：

[ start cutting before this index : end cutting before this index ]

现在，如果你从上面的列表中选择一个片段[2:5]，就会发生这种情况：

        |           |
+---+---|---+---+---|---+
| P | Y | T | H | O | N |
+---+---|---+---+---|---+
  0   1 | 2   3   4 | 5

在索引为2的元素之前进行了一次切割，在索引为5的元素之前又进行了一个切割。因此，结果将是这两个剪辑之间的一个片段，一个列表['T'，'H'，'O']。

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

>>> 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]

以下是字符串索引的示例：

 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

str="Name string"

切片示例：[开始：结束：步骤]

str[start:end] # Items start through end-1
str[start:]    # Items start through the rest of the array
str[:end]      # Items from the beginning through end-1
str[:]         # A copy of the whole array

以下是示例用法：

print str[0] = N
print str[0:2] = Na
print str[0:7] = Name st
print str[0:7:2] = Nm t
print str[0:-1:2] = Nm ti

语法为：

a[start:stop]  # items start through stop-1
a[start:]      # items start through the rest of the array
a[:stop]       # items from the beginning through stop-1
a[:]           # a copy of the whole array

还有一个步长值，可用于上述任何一项：

a[start:stop:step] # start through not past stop, by step

要记住的关键点是：stop值表示不在所选切片中的第一个值。因此，停止和开始之间的区别是所选元素的数量（如果步骤为1，则为默认值）。

另一个特点是start或stop可以是负数，这意味着它从数组的末尾开始计数，而不是从开始计数。因此：

a[-1]    # last item in the array
a[-2:]   # last two items in the array
a[:-2]   # everything except the last two items

类似地，步骤可以是负数：

a[::-1]    # all items in the array, reversed
a[1::-1]   # the first two items, reversed
a[:-3:-1]  # the last two items, reversed
a[-3::-1]  # everything except the last two items, reversed

如果项目比你要求的少，Python对程序员很友好。例如，如果您请求一个[：-2]，而一个只包含一个元素，则会得到一个空列表而不是一个错误。有时你会更喜欢错误，所以你必须意识到这可能会发生。

与切片对象的关系

切片对象可以表示切片操作，即：

a[start:stop:step]

相当于：

a[slice(start, stop, step)]

根据参数的数量，切片对象的行为也略有不同，类似于range（），即切片（stop）和切片（start，stop[，step]）都受支持。要跳过指定给定参数，可以使用None，例如[start:]等同于[sslice（start，None）]或[：：-1]等同于[Sslice（None，None，-1）]。

虽然基于：的表示法对简单切片非常有用，但slice（）对象的显式使用简化了切片的编程生成。