在Python中，最基本的切片形式如下：

l[start:end]

其中l是一些集合，start是一个包含索引，end是一个独占索引。

In [1]: l = list(range(10))

In [2]: l[:5] # First five elements
Out[2]: [0, 1, 2, 3, 4]

In [3]: l[-5:] # Last five elements
Out[3]: [5, 6, 7, 8, 9]

当从开始切片时，可以省略零索引，而当切片到结束时，可以忽略最终索引，因为它是冗余的，所以不要冗长：

In [5]: l[:3] == l[0:3]
Out[5]: True

In [6]: l[7:] == l[7:len(l)]
Out[6]: True

负整数在相对于集合结尾进行偏移时非常有用：

In [7]: l[:-1] # Include all elements but the last one
Out[7]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [8]: l[-3:] # Take the last three elements
Out[8]: [7, 8, 9]

切片时可以提供超出范围的索引，例如：

In [9]: l[:20] # 20 is out of index bounds, and l[20] will raise an IndexError exception
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]: l[-20:] # -20 is out of index bounds, and l[-20] will raise an IndexError exception
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

请记住，分割集合的结果是一个全新的集合。此外，当在赋值中使用切片表示法时，切片赋值的长度不需要相同。将保留分配切片之前和之后的值，集合将收缩或增长以包含新值：

In [16]: l[2:6] = list('abc') # Assigning fewer elements than the ones contained in the sliced collection l[2:6]

In [17]: l
Out[17]: [0, 1, 'a', 'b', 'c', 6, 7, 8, 9]

In [18]: l[2:5] = list('hello') # Assigning more elements than the ones contained in the sliced collection l [2:5]

In [19]: l
Out[19]: [0, 1, 'h', 'e', 'l', 'l', 'o', 6, 7, 8, 9]

如果忽略开始索引和结束索引，则将创建集合的副本：

In [14]: l_copy = l[:]

In [15]: l == l_copy and l is not l_copy
Out[15]: True

如果在执行赋值操作时省略了开始和结束索引，则集合的整个内容将替换为引用内容的副本：

In [20]: l[:] = list('hello...')

In [21]: l
Out[21]: ['h', 'e', 'l', 'l', 'o', '.', '.', '.']

除了基本切片外，还可以应用以下符号：

l[start:end:step]

其中l是一个集合，start是一个包含索引，end是一个排他索引，step是一个步长，可以用来获取l中的每n个项目。

In [22]: l = list(range(10))

In [23]: l[::2] # Take the elements which indexes are even
Out[23]: [0, 2, 4, 6, 8]

In [24]: l[1::2] # Take the elements which indexes are odd
Out[24]: [1, 3, 5, 7, 9]

使用step提供了在Python中反转集合的有用技巧：

In [25]: l[::-1]
Out[25]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

也可以使用负整数作为步骤，如下例所示：

In[28]:  l[::-2]
Out[28]: [9, 7, 5, 3, 1]

然而，使用负值作为步长可能会变得非常混乱。此外，为了成为Pythonic，您应该避免在单个切片中使用start、end和step。如果需要这样做，可以考虑在两个任务中完成（一个任务是切片，另一个任务则是跨步）。

In [29]: l = l[::2] # This step is for striding

In [30]: l
Out[30]: [0, 2, 4, 6, 8]

In [31]: l = l[1:-1] # This step is for slicing

In [32]: l
Out[32]: [2, 4, 6]

1.切片符号

为了简单起见，请记住切片只有一种形式：

s[start:end:step]

下面是它的工作原理：

s： 可以切片的物体start：开始迭代的第一个索引end：最后一个索引，请注意，最终的切片中不会包含结束索引step：每个步骤索引拾取元素

另一个重要的事情：所有开始、结束和步骤都可以省略！如果省略它们，则将使用它们的默认值：0，len（s），1。

因此，可能的变化如下：

# Mostly used variations
s[start:end]
s[start:]
s[:end]

# Step-related variations
s[:end:step]
s[start::step]
s[::step]

# Make a copy
s[:]

注意：如果start>=end（仅在步骤>0时考虑），Python将返回一个空切片[]。

2.陷阱

上面的部分解释了切片如何工作的核心特性，它将在大多数情况下工作。然而，可能会有陷阱，您应该注意，本部分将对它们进行解释。

负面指数

让Python学习者困惑的第一件事是索引可以是负数！不要惊慌：负指数意味着倒数。

例如：

s[-5:]    # Start at the 5th index from the end of array,
          # thus returning the last 5 elements.
s[:-5]    # Start at index 0, and end until the 5th index from end of array,
          # thus returning s[0:len(s)-5].

负阶跃

让事情更令人困惑的是，这一步也可能是消极的！

负步骤意味着向后迭代数组：从结束到开始，包括结束索引，从结果中排除开始索引。

注意：当step为负值时，start的默认值为len（s）（而end不等于0，因为s[：：-1]包含s[0]）。例如：

s[::-1]            # Reversed slice
s[len(s)::-1]      # The same as above, reversed slice
s[0:len(s):-1]     # Empty list

超出范围错误？

请注意：当索引超出范围时，切片不会引发IndexError！

如果索引超出范围，Python将根据情况尽量将索引设置为0或len。例如：

s[:len(s)+5]      # The same as s[:len(s)]
s[-len(s)-5::]    # The same as s[0:]
s[len(s)+5::-1]   # The same as s[len(s)::-1], and the same as s[::-1]

3.示例

让我们用例子来完成这个回答，解释我们讨论的所有内容：

# Create our array for demonstration
In [1]: s = [i for i in range(10)]

In [2]: s
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: s[2:]   # From index 2 to last index
Out[3]: [2, 3, 4, 5, 6, 7, 8, 9]

In [4]: s[:8]   # From index 0 up to index 8
Out[4]: [0, 1, 2, 3, 4, 5, 6, 7]

In [5]: s[4:7]  # From index 4 (included) up to index 7(excluded)
Out[5]: [4, 5, 6]

In [6]: s[:-2]  # Up to second last index (negative index)
Out[6]: [0, 1, 2, 3, 4, 5, 6, 7]

In [7]: s[-2:]  # From second last index (negative index)
Out[7]: [8, 9]

In [8]: s[::-1] # From last to first in reverse order (negative step)
Out[8]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

In [9]: s[::-2] # All odd numbers in reversed order
Out[9]: [9, 7, 5, 3, 1]

In [11]: s[-2::-2] # All even numbers in reversed order
Out[11]: [8, 6, 4, 2, 0]

In [12]: s[3:15]   # End is out of range, and Python will set it to len(s).
Out[12]: [3, 4, 5, 6, 7, 8, 9]

In [14]: s[5:1]    # Start > end; return empty list
Out[14]: []

In [15]: s[11]     # Access index 11 (greater than len(s)) will raise an IndexError
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-15-79ffc22473a3> in <module>()
----> 1 s[11]

IndexError: list index out of range

语法为：

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（）对象的显式使用简化了切片的编程生成。

如果你觉得切片中的负指数令人困惑，这里有一个非常简单的方法来考虑：用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)]

简单易懂：

在Python中，切片符号a[start:stop:step]可以用于从序列中选择一系列元素（例如列表、元组或字符串）。

起始索引是包括在切片中的第一个元素，

停止索引是从切片中排除的第一个元素，也是最后一个元素

步长值是切片元素之间的索引数。

例如，考虑以下列表：

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

如果要选择a的所有元素，可以使用切片符号a[：]：

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

如果我们想选择a的所有元素，但跳过其他元素，我们可以使用切片符号a[：：2]：

>>> a[::2]
[0, 2, 4, 6, 8]

如果我们想选择从第三个元素（索引2）到第七个元素（索引号6）的所有元素，我们可以使用切片符号a[2:7]：

>>> a[2:7]
[2, 3, 4, 5, 6]

如果我们想选择从第三个元素（索引2）到第七个元素（索引号6）的所有元素，但跳过其他元素，我们可以使用切片符号a[2:7:2]：

>>> a[2:7:2]
[2, 4, 6]

如果我们想选择从第三个元素（索引2）到列表末尾的所有元素，我们可以使用切片符号a[2:]：

>>> a[2:]
[2, 3, 4, 5, 6, 7, 8, 9]

如果我们想选择从列表开头到第七个元素（索引6）的所有元素，我们可以使用切片符号a[：7]：

>>> a[:7]
[0, 1, 2, 3, 4, 5, 6]

如果您想了解有关切片表示法的更多信息，可以参考Python官方文档：链接1链接2

通常，使用大量硬编码索引值编写代码会提高可读性以及维护混乱。例如，如果一年后你回到代码，你会看看它，想知道你写的时候在想什么只是一种更清楚地说明代码实际在做什么的方式。通常，内置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.>>>