在找到这张很棒的桌子http://wiki.python.org/moin/MovingToPythonFromOtherLanguages

Python indexes and slices for a six-element list.
Indexes enumerate the elements, slices enumerate the spaces between the elements.

Index from rear:    -6  -5  -4  -3  -2  -1      a=[0,1,2,3,4,5]    a[1:]==[1,2,3,4,5]
Index from front:    0   1   2   3   4   5      len(a)==6          a[:5]==[0,1,2,3,4]
                   +---+---+---+---+---+---+    a[0]==0            a[:-2]==[0,1,2,3]
                   | a | b | c | d | e | f |    a[5]==5            a[1:2]==[1]
                   +---+---+---+---+---+---+    a[-1]==5           a[1:-1]==[1,2,3,4]
Slice from front:  :   1   2   3   4   5   :    a[-2]==4
Slice from rear:   :  -5  -4  -3  -2  -1   :
                                                b=a[:]
                                                b==[0,1,2,3,4,5] (shallow copy of a)

Python切片表示法：

a[start:end:step]

对于开始和结束，负值被解释为相对于序列的结束。结束的正索引表示要包含的最后一个元素之后的位置。空白值默认如下：[+0:-0:1]。使用否定步骤会颠倒开始和结束的解释

该符号扩展到（numpy）矩阵和多维数组。例如，要分割整个列，可以使用：

m[::,0:2:] ## slice the first two columns

切片保存数组元素的引用，而不是副本。如果您想单独复制一个数组，可以使用deepcopy（）。

基本的切片技术是定义起点、终点和步长（也称为步幅）。

首先，我们将创建一个用于切片的值列表。

创建两个要切片的列表。第一个是从1到9的数字列表（列表a）。第二个也是数字列表，从0到9（列表B）：

A = list(range(1, 10, 1)) # Start, stop, and step
B = list(range(9))

print("This is List A:", A)
print("This is List B:", B)

索引A中的数字3和B中的数字6。

print(A[2])
print(B[6])

基本切片

用于切片的扩展索引语法是aList[start:stop:step]。start参数和step参数都默认为None，唯一需要的参数是stop。您是否注意到这与使用范围定义列表A和B的方式类似？这是因为切片对象表示由范围（开始、停止、步骤）指定的索引集。

如您所见，仅定义stop返回一个元素。由于start默认为none，这意味着只检索一个元素。

需要注意的是，第一个元素是索引0，而不是索引1。这就是为什么我们在本练习中使用两个列表。列表A的元素根据序号位置进行编号（第一个元素是1，第二个元素是2，等等），而列表B的元素是用于对其进行索引的数字（对于第一个元素，[0]，等等）。

通过扩展索引语法，我们可以检索一系列值。例如，使用冒号检索所有值。

A[:]

要检索元素的子集，需要定义开始和停止位置。

给定模式aList[start:stop]，从列表A中检索前两个元素。

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

您可以使用切片语法返回字符序列。

指定用冒号分隔的开始和结束索引，以返回字符串的一部分。

例子：

获取从位置2到位置5的字符（不包括）：

b = "Hello, World!"
print(b[2:5])

从开始切片

通过省略起始索引，范围将从第一个字符开始：

例子：

获取从开始到位置5的字符（不包括）：

b = "Hello, World!"
print(b[:5])

切片到底

通过省略结束索引，范围将结束：

例子：

从位置2获取字符，一直到结尾：

b = "Hello, World!"
print(b[2:])

负索引

使用负索引从字符串末尾开始切片：实例

获取字符：

来自：“世界！”中的“o”（位置-5）

至，但不包括：“世界！”中的“d”（位置-2）：

b = "Hello, World!"
print(b[-5:-2])

这是我教新手切片的方法：

理解索引和切片之间的区别：

WikiPython有一幅惊人的图片，它清楚地区分了索引和切片。

这是一个包含六个元素的列表。为了更好地理解切片，请将该列表视为一组放在一起的六个框。每个盒子里都有一个字母表。

索引就像处理盒子的内容。您可以检查任何框的内容。但是你不能同时检查多个盒子的内容。你甚至可以替换盒子里的东西。但你不能在一个盒子里放两个球，也不能一次换两个球。

In [122]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [123]: alpha
Out[123]: ['a', 'b', 'c', 'd', 'e', 'f']

In [124]: alpha[0]
Out[124]: 'a'

In [127]: alpha[0] = 'A'

In [128]: alpha
Out[128]: ['A', 'b', 'c', 'd', 'e', 'f']

In [129]: alpha[0,1]
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-129-c7eb16585371> in <module>()
----> 1 alpha[0,1]

TypeError: list indices must be integers, not tuple

切片就像处理盒子一样。你可以拿起第一个盒子放在另一张桌子上。要拿起盒子，你只需要知道盒子的开始和结束位置。

您甚至可以选择前三个框或最后两个框，或1到4之间的所有框。所以，如果你知道开始和结束，你可以选择任何一组框。这些位置称为开始和停止位置。

有趣的是，您可以同时替换多个框。此外，您可以在任何地方放置多个盒子。

In [130]: alpha[0:1]
Out[130]: ['A']

In [131]: alpha[0:1] = 'a'

In [132]: alpha
Out[132]: ['a', 'b', 'c', 'd', 'e', 'f']

In [133]: alpha[0:2] = ['A', 'B']

In [134]: alpha
Out[134]: ['A', 'B', 'c', 'd', 'e', 'f']

In [135]: alpha[2:2] = ['x', 'xx']

In [136]: alpha
Out[136]: ['A', 'B', 'x', 'xx', 'c', 'd', 'e', 'f']

切片步骤：

到目前为止，您已连续拾取箱子。但有时你需要单独拾取。例如，您可以每隔一秒钟拾取一个盒子。你甚至可以从最后每隔三个盒子取一个。该值称为步长。这代表了您连续拾取之间的差距。如果您从开始到结束拾取框，则步长应为正值，反之亦然。

In [137]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [142]: alpha[1:5:2]
Out[142]: ['b', 'd']

In [143]: alpha[-1:-5:-2]
Out[143]: ['f', 'd']

In [144]: alpha[1:5:-2]
Out[144]: []

In [145]: alpha[-1:-5:2]
Out[145]: []

Python如何找出缺少的参数：

切片时，如果忽略了任何参数，Python会尝试自动计算。

如果您检查CPython的源代码，您会发现一个名为PySlice_GetIndices Ex（）的函数，它计算出任何给定参数的切片索引。下面是Python中的逻辑等价代码。

此函数采用Python对象和可选参数进行切片，并返回所请求切片的开始、停止、步骤和切片长度。

def py_slice_get_indices_ex(obj, start=None, stop=None, step=None):

    length = len(obj)

    if step is None:
        step = 1
    if step == 0:
        raise Exception("Step cannot be zero.")

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

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

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

    return (start, stop, step, slice_length)

这就是切片背后的智慧。由于Python有一个名为slice的内置函数，您可以传递一些参数，并检查它如何巧妙地计算缺少的参数。

In [21]: alpha = ['a', 'b', 'c', 'd', 'e', 'f']

In [22]: s = slice(None, None, None)

In [23]: s
Out[23]: slice(None, None, None)

In [24]: s.indices(len(alpha))
Out[24]: (0, 6, 1)

In [25]: range(*s.indices(len(alpha)))
Out[25]: [0, 1, 2, 3, 4, 5]

In [26]: s = slice(None, None, -1)

In [27]: range(*s.indices(len(alpha)))
Out[27]: [5, 4, 3, 2, 1, 0]

In [28]: s = slice(None, 3, -1)

In [29]: range(*s.indices(len(alpha)))
Out[29]: [5, 4]

注：这篇文章最初写在我的博客《Python切片背后的智能》中。