以下是字符串索引的示例：

 +---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

str="Name string"

切片示例：[开始：结束：步骤]

str[start:end] # Items start through end-1
str[start:]    # Items start through the rest of the array
str[:end]      # Items from the beginning through end-1
str[:]         # A copy of the whole array

以下是示例用法：

print str[0] = N
print str[0:2] = Na
print str[0:7] = Name st
print str[0:7:2] = Nm t
print str[0:-1:2] = Nm ti

简单易懂：

在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

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

Python切片表示法：

a[start:end:step]

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

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

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

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

这里有一个简单的记忆方法，可以记住它是如何工作的：

S L*I*C*E*切片的“i”位于第一位，代表包容，“e”排在最后，代表独占。

所以array[j:k]将包括第j个元素，并排除第k个元素。

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

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

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

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