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

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

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

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

              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的默认值。

如果我们可以将切片与范围联系起来，这很容易理解，因为范围给出了索引。我们可以将切片分为以下两类：

---

1.无台阶或台阶>0。例如，[i:j]或[i:j:k]（k>0）

假设序列为s=[1,2,3,4,5]。

如果0<i<len（s）和0<j<len，则[i:j:k]->范围（i，j，k）

例如，[0:3:2]->范围（0,3,2）->0，2

如果i>len或j>len，则i=len或j=len

例如，[0:100:2]->范围（0，len（s），2）->范围（0,5,2）->0，2，4

如果i＜0或j＜0，则i＝max（0，len（s）+i）或j＝max

例如，[0:-3:2]->范围（0，len（s）-3,2）->范围（0,2,2）->0

例如，[0:-1:2]->范围（0，len（s）-1,2）->范围（0,4,2）->0，2

如果未指定i，则i=0

例如，[：4:2]->范围（0,4,2）->范围（4,2）->0，2

如果未指定j，则j=len（s）

例如，[0:：2]->范围（0，len（s），2）->范围（0,5,2）->0，2，4

---

2.步骤<0。例如，[i:j:k]（k<0）

假设序列为s=[1,2,3,4,5]。

如果0<i<len（s）和0<j<len，则[i:j:k]->范围（i，j，k）

例如，[5:0:-2]->范围（5,0，-2）->5，3，1

如果i>len或j>len，则i=len（s）-1或j=len（s）-1

例如，[100:0:-2]->范围（len（s）-1,0，-2）->范围（4,0，-2）->4，2

如果i＜0或j＜0，则i＝max（-1，len（s）+i）或j＝max（-1len（s）+j）

例如，[-2:-10:-2]->range（len（s）-2，-1，-2）->range（3，-1，-1）->3，1

如果未指定i，则i=len（s）-1

例如，[：0:-2]->范围（len（s）-1,0，-2）->范围（4,0，-2）->4，2

如果未指定j，则j=-1

例如，[2:：-2]->范围（2，-1，-2）->2，0

例如，[：：-1]->range（len（s）-1，-1，-1）->range（4，-1，1）->4，3，2，1，0

---

总而言之

我自己使用“元素之间的索引点”方法来思考它，但描述它的一种方式有时有助于其他人获得它：

mylist[X:Y]

X是所需的第一个元素的索引。Y是不需要的第一个元素的索引。

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

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