Index:
      ------------>
  0   1   2   3   4
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
  0  -4  -3  -2  -1
      <------------

Slice:
    <---------------|
|--------------->
:   1   2   3   4   :
+---+---+---+---+---+
| a | b | c | d | e |
+---+---+---+---+---+
:  -4  -3  -2  -1   :
|--------------->
    <---------------|

我希望这将帮助您用Python建模列表。

参考：http://wiki.python.org/moin/MovingToPythonFromOtherLanguages

Python切片表示法：

a[start:end:step]

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

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

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

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

解释Python的切片表示法

简而言之，下标表示法（subscriptable[subscriptarg]）中的冒号（：）构成切片表示法，它具有可选的参数start、stop和step：

sliceable[start:stop:step]

Python切片是一种快速计算的方法，可以系统地访问部分数据。在我看来，要成为一名中级Python程序员，这是语言的一个必须熟悉的方面。

重要定义

首先，让我们定义几个术语：

start：切片的起始索引，除非它与stop相同，否则它将包含该索引处的元素，默认为0，即第一个索引。如果是负数，则表示从末尾开始n个项目。stop：切片的结束索引，它不包括该索引处的元素，默认为切片序列的长度，即，直到并包括结束。step：索引增加的量，默认为1。如果它是负的，那么你正在反向切片可迭代的。

索引的工作原理

你可以做这些正数或负数中的任何一个。正数的含义很简单，但对于负数，就像Python中的索引一样，从开始和停止的末尾开始向后计数，对于步骤，只需减少索引。此示例来自文档的教程，但我对其进行了轻微修改，以指示每个索引引用的序列中的哪个项：

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5 
  -6  -5  -4  -3  -2  -1

切片的工作原理

要对支持它的序列使用切片表示法，必须在序列后面的方括号中至少包含一个冒号（根据Python数据模型，这实际上实现了序列的__getitem_方法）

切片表示法的工作原理如下：

sequence[start:stop:step]

回想一下，start、stop和step都有默认值，所以要访问默认值，只需省略参数即可。

从列表（或任何其他支持它的序列，如字符串）中获取最后九个元素的切片表示法如下所示：

my_list[-9:]

当我看到这一点时，我把括号里的部分读成了“从结尾到结尾的第9个”（实际上，我在心里把它缩写为“-9，on”）

说明：

完整符号为

my_list[-9:None:None]

并替换默认值（实际上，当step为负值时，stop的默认值为-len（my_list）-1，因此None for stop实际上意味着它将转到任何结束步骤）：

my_list[-9:len(my_list):1]

冒号：是告诉Python你给它一个切片，而不是一个常规索引。这就是为什么在Python2中制作列表浅拷贝的惯用方法是

list_copy = sequence[:]

清除它们的方法是：

del my_list[:]

（Python 3获得list.copy和list.clear方法。）

当步骤为负时，启动和停止的默认值将更改

默认情况下，当step参数为空（或None）时，将其赋值为+1。

但是您可以传入一个负整数，列表（或大多数其他标准可切片）将从结尾到开头进行切片。

因此，负切片将更改开始和停止的默认值！

在源中确认

我希望鼓励用户阅读源代码和文档。切片对象和此逻辑的源代码位于此处。首先，我们确定步骤是否为负：

step_is_negative=step_sign<0；

如果是这样的话，下限是-1，意味着我们一直切到并包括开头，上限是长度减1，意味着从结尾开始。（注意，这个-1的语义不同于用户可以在Python中传递指示最后一项的索引的-1。）

if（step_is_negative）{lower=PyLong_FromLong（-1L）；if（下限==NULL）转到错误；上限=PyNumber_Add（长度，下限）；if（上限==NULL）转到错误；}

否则，step为正值，下限将为零，上限（我们将向上，但不包括）为切片列表的长度。

其他{lower=_PyLong_Zero；Py_INCREF（下部）；上限=长度；Py_INCREF（上部）；}

然后，我们可能需要应用start和stop的默认值。如果step为负值，那么start的默认值将计算为上限：

如果（self->start==Py_None）{start=step_is_negative？上部：下部；Py_INCREF（启动）；}

并停止，下限：

如果（self->stop==Py_None）{stop=step_is_negative？下：上；Py_INCREF（停止）；}

给你的切片起个描述性的名字！

您可能会发现将形成切片与将其传递到列表分开是很有用的__getitem_方法（这就是方括号的作用）。即使你不是新手，它也能让你的代码更可读，这样其他可能需要阅读你的代码的人就能更容易地理解你在做什么。

但是，不能只将一些用冒号分隔的整数分配给变量。您需要使用切片对象：

last_nine_slice = slice(-9, None)

第二个参数None是必需的，因此第一个参数被解释为开始参数，否则它将是停止参数。

然后可以将切片对象传递给序列：

>>> list(range(100))[last_nine_slice]
[91, 92, 93, 94, 95, 96, 97, 98, 99]

有趣的是，范围也可以分片：

>>> range(100)[last_nine_slice]
range(91, 100)

内存注意事项：

由于Python列表的切片会在内存中创建新的对象，因此需要注意的另一个重要函数是itertool.islice。通常，您需要对切片进行迭代，而不仅仅是在内存中静态创建。islice非常适合这个。需要注意的是，它不支持开始、停止或步骤的负参数，因此如果这是一个问题，您可能需要提前计算索引或反转可迭代项。

length = 100
last_nine_iter = itertools.islice(list(range(length)), length-9, None, 1)
list_last_nine = list(last_nine_iter)

现在：

>>> list_last_nine
[91, 92, 93, 94, 95, 96, 97, 98, 99]

列表切片复制是列表本身的一个特点。如果您正在切片像PandasDataFrame这样的高级对象，它可能会返回原始对象的视图，而不是副本。

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

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

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

首先了解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]只是整个字符串。

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

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

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