枚举序列x语法允许的可能性：

>>> x[:]                # [x[0],   x[1],          ..., x[-1]    ]
>>> x[low:]             # [x[low], x[low+1],      ..., x[-1]    ]
>>> x[:high]            # [x[0],   x[1],          ..., x[high-1]]
>>> x[low:high]         # [x[low], x[low+1],      ..., x[high-1]]
>>> x[::stride]         # [x[0],   x[stride],     ..., x[-1]    ]
>>> x[low::stride]      # [x[low], x[low+stride], ..., x[-1]    ]
>>> x[:high:stride]     # [x[0],   x[stride],     ..., x[high-1]]
>>> x[low:high:stride]  # [x[low], x[low+stride], ..., x[high-1]]

当然，如果（高低）%步幅！=0，则终点将略低于高1。

如果步幅为负，则由于我们正在倒计时，顺序会有点改变：

>>> x[::-stride]        # [x[-1],   x[-1-stride],   ..., x[0]    ]
>>> x[high::-stride]    # [x[high], x[high-stride], ..., x[0]    ]
>>> x[:low:-stride]     # [x[-1],   x[-1-stride],   ..., x[low+1]]
>>> x[high:low:-stride] # [x[high], x[high-stride], ..., x[low+1]]

扩展切片（带逗号和省略号）通常仅用于特殊数据结构（如NumPy）；基本序列不支持它们。

>>> class slicee:
...     def __getitem__(self, item):
...         return repr(item)
...
>>> slicee()[0, 1:2, ::5, ...]
'(0, slice(1, 2, None), slice(None, None, 5), Ellipsis)'

前面的大多数答案都解决了有关切片表示法的问题。

用于切片的扩展索引语法是aList[start:stop:step]，基本示例如下：

:

更多切片示例：15个扩展切片

前面的答案没有讨论使用著名的NumPy包可以实现的多维数组切片：

切片也可以应用于多维数组。

# Here, a is a NumPy array

>>> a
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])
>>> a[:2, 0:3:2]
array([[1, 3],
       [5, 7]])

逗号前的“：2”作用于第一维度，逗号后的“0:3:2”作用于第二维度。

还可以使用切片分配从列表中删除一个或多个元素：

r = [1, 'blah', 9, 8, 2, 3, 4]
>>> r[1:4] = []
>>> r
[1, 2, 3, 4]

关于序列的索引，需要记住的重要思想是

非负指数从序列中的第一项开始；负索引从序列的最后一项开始（因此仅适用于有限序列）。

换言之，负索引右移序列长度：

              0   1   2   3   4   5   6   7   ...
            -------------------------
            | a | b | c | d | e | f |
            -------------------------
...  -8  -7  -6  -5  -4  -3  -2  -1

考虑到这一点，订阅和切片很简单。

订阅

订阅使用以下语法：*

sequence[index]

订阅在索引处选择序列中的单个项目：

>>> 'abcdef'[0]
'a'
>>> 'abcdef'[-6]
'a'

订阅引发超出范围的索引的IndexError：

>>> 'abcdef'[100]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

切片

切片使用以下语法：**

sequence[start:stop:step]

切片选择序列中的一系列项目，从包含开始到不包含结束：

>>> 'abcdef'[0:2:1]
'ab'
>>> 'abcdef'[0:-4:1]
'ab'
>>> 'abcdef'[-6:-4:1]
'ab'
>>> 'abcdef'[-6:2:1]
'ab'
>>> 'abcdef'[1:-7:-1]
'ba'
>>> 'abcdef'[-5:-7:-1]
'ba'

切片默认为序列中最完整的项目范围，因此它对省略或等于“无”的任何开始、停止或步骤使用以下默认值：***

步骤默认为1；如果步骤为正start默认为0（第一项索引），stop默认为start+len（序列）（最后一项索引加一）；如果步骤为负start默认为-1（最后一项索引），stop默认为start-len（序列）（第一项索引减一）。

>>> 'abcdef'[0:6:1]
'abcdef'
>>> 'abcdef'[::]
'abcdef'
>>> 'abcdef'[-1:-7:-1]
'fedcba'
>>> 'abcdef'[::-1]
'fedcba'

切片为等于零的步骤引发ValueError：

>>> 'abcdef'[::0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: slice step cannot be zero

切片不会为超出范围的开始或停止引发IndexError（与订阅相反）：

>>> 'abcdef'[-100:100]
'abcdef'

---

*表达式sequence[index]和sequence__getitem_（索引）是等效的。

**表达式sequence[start:stop:step]、sequence[Sslice（start，stop，step）]和sequence__getitem_（slice（start，stop，step））是等效的，其中内置类slice实例包start，stop和step。

***表达式sequence[：]、sequence[：：]和sequence[None:None:None]使用start、stop和step的默认值。

在Python 2.7中

Python中的切片

[a:b:c]

len = length of string, tuple or list

c -- default is +1. The sign of c indicates forward or backward, absolute value of c indicates steps. Default is forward with step size 1. Positive means forward, negative means backward.

a --  When c is positive or blank, default is 0. When c is negative, default is -1.

b --  When c is positive or blank, default is len. When c is negative, default is -(len+1).

理解索引分配非常重要。

In forward direction, starts at 0 and ends at len-1

In backward direction, starts at -1 and ends at -len

当你说[a:b:c]时，你是说根据c的符号（向前或向后），从a开始，到b结束（不包括bth索引中的元素）。使用上面的索引规则，并记住您只能找到此范围内的元素：

-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1

但这一范围在两个方向上无限延伸：

...,-len -2 ,-len-1,-len, -len+1, -len+2, ..., 0, 1, 2,3,4 , len -1, len, len +1, len+2 , ....

例如：

             0    1    2   3    4   5   6   7   8   9   10   11
             a    s    t   r    i   n   g
    -9  -8  -7   -6   -5  -4   -3  -2  -1

如果在使用上面的a、b、c的规则进行遍历时，a、b和c的选择允许与上面的范围重叠，则会得到一个包含元素的列表（在遍历过程中被触摸），或者得到一个空列表。

最后一件事：如果a和b相等，那么也会得到一个空列表：

>>> l1
[2, 3, 4]

>>> l1[:]
[2, 3, 4]

>>> l1[::-1] # a default is -1 , b default is -(len+1)
[4, 3, 2]

>>> l1[:-4:-1] # a default is -1
[4, 3, 2]

>>> l1[:-3:-1] # a default is -1
[4, 3]

>>> l1[::] # c default is +1, so a default is 0, b default is len
[2, 3, 4]

>>> l1[::-1] # c is -1 , so a default is -1 and b default is -(len+1)
[4, 3, 2]


>>> l1[-100:-200:-1] # Interesting
[]

>>> l1[-1:-200:-1] # Interesting
[4, 3, 2]


>>> l1[-1:-1:1]
[]


>>> l1[-1:5:1] # Interesting
[4]


>>> l1[1:-7:1]
[]

>>> l1[1:-7:-1] # Interesting
[3, 2]

>>> l1[:-2:-2] # a default is -1, stop(b) at -2 , step(c) by 2 in reverse direction
[4]