上面的答案不讨论切片分配。为了理解切片分配，可以在ASCII艺术中添加另一个概念：

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

>>> p = ['P','y','t','h','o','n']
# Why the two sets of numbers:
# indexing gives items, not lists
>>> p[0]
 'P'
>>> p[5]
 'n'

# Slicing gives lists
>>> p[0:1]
 ['P']
>>> p[0:2]
 ['P','y']

一种启发式方法是，对于从零到n的切片，思考：“零是开始，从开始开始，在列表中取n个项目”。

>>> p[5] # the last of six items, indexed from zero
 'n'
>>> p[0:5] # does NOT include the last item!
 ['P','y','t','h','o']
>>> p[0:6] # not p[0:5]!!!
 ['P','y','t','h','o','n']

另一种启发式方法是，“对于任何一个切片，用零替换开头，应用前面的启发式方法获得列表的结尾，然后将第一个数字向后计数，以从开头删除项目”

>>> p[0:4] # Start at the beginning and count out 4 items
 ['P','y','t','h']
>>> p[1:4] # Take one item off the front
 ['y','t','h']
>>> p[2:4] # Take two items off the front
 ['t','h']
# etc.

切片分配的第一个规则是，由于切片返回一个列表，所以切片分配需要一个列表（或其他可迭代的）：

>>> p[2:3]
 ['t']
>>> p[2:3] = ['T']
>>> p
 ['P','y','T','h','o','n']
>>> p[2:3] = 't'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable

切片分配的第二个规则（您也可以在上面看到）是，无论切片索引返回列表的哪个部分，都是由切片分配更改的相同部分：

>>> p[2:4]
 ['T','h']
>>> p[2:4] = ['t','r']
>>> p
 ['P','y','t','r','o','n']

切片分配的第三条规则是，分配的列表（可迭代）不必具有相同的长度；索引切片被简单地切片，并被分配的任何内容整体替换：

>>> p = ['P','y','t','h','o','n'] # Start over
>>> p[2:4] = ['s','p','a','m']
>>> p
 ['P','y','s','p','a','m','o','n']

最难习惯的部分是分配给空切片。使用启发式1和2，很容易让你的头脑围绕空切片进行索引：

>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
 ['P','y','t','h']
>>> p[1:4]
 ['y','t','h']
>>> p[2:4]
 ['t','h']
>>> p[3:4]
 ['h']
>>> p[4:4]
 []

然后，一旦您看到了这一点，将切片分配给空切片也是有意义的：

>>> p = ['P','y','t','h','o','n']
>>> p[2:4] = ['x','y'] # Assigned list is same length as slice
>>> p
 ['P','y','x','y','o','n'] # Result is same length
>>> p = ['P','y','t','h','o','n']
>>> p[3:4] = ['x','y'] # Assigned list is longer than slice
>>> p
 ['P','y','t','x','y','o','n'] # The result is longer
>>> p = ['P','y','t','h','o','n']
>>> p[4:4] = ['x','y']
>>> p
 ['P','y','t','h','x','y','o','n'] # The result is longer still

请注意，因为我们没有更改切片的第二个编号（4），所以插入的项目总是紧靠“o”堆叠，即使我们分配给空切片也是如此。因此，空切片分配的位置是非空切片分配位置的逻辑扩展。

稍微后退一点，当你继续进行我们的切片开始计数过程时会发生什么？

>>> p = ['P','y','t','h','o','n']
>>> p[0:4]
 ['P','y','t','h']
>>> p[1:4]
 ['y','t','h']
>>> p[2:4]
 ['t','h']
>>> p[3:4]
 ['h']
>>> p[4:4]
 []
>>> p[5:4]
 []
>>> p[6:4]
 []

通过切片，一旦你完成，你就完成了；它不会开始向后倾斜。在Python中，除非使用负数明确要求，否则不会获得负的步幅。

>>> p[5:3:-1]
 ['n','o']

“一旦你完成了，你就完成了”规则会产生一些奇怪的后果：

>>> p[4:4]
 []
>>> p[5:4]
 []
>>> p[6:4]
 []
>>> p[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

事实上，与索引相比，Python切片具有奇怪的防错误性：

>>> p[100:200]
 []
>>> p[int(2e99):int(1e99)]
 []

这有时会派上用场，但也会导致一些奇怪的行为：

>>> p
 ['P', 'y', 't', 'h', 'o', 'n']
>>> p[int(2e99):int(1e99)] = ['p','o','w','e','r']
>>> p
 ['P', 'y', 't', 'h', 'o', 'n', 'p', 'o', 'w', 'e', 'r']

根据您的应用程序，这可能。。。或者可能不。。。成为你在那里所希望的！

---

以下是我的原始答案。它对很多人都很有用，所以我不想删除它。

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

这也可以澄清切片和索引之间的区别。

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

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

切片规则如下：

[lower bound : upper bound : step size]

I-将上限和下限转换为公共符号。

II-然后检查步长是正值还是负值。

（i） 如果步长为正值，则上限应大于下限，否则将打印空字符串。例如：

s="Welcome"
s1=s[0:3:1]
print(s1)

输出：

Wel

但是，如果我们运行以下代码：

s="Welcome"
s1=s[3:0:1]
print(s1)

它将返回一个空字符串。

（ii）如果步长为负值，则上限应小于下限，否则将打印空字符串。例如：

s="Welcome"
s1=s[3:0:-1]
print(s1)

输出：

cle

但如果我们运行以下代码：

s="Welcome"
s1=s[0:5:-1]
print(s1)

输出将为空字符串。

因此，在代码中：

str = 'abcd'
l = len(str)
str2 = str[l-1:0:-1]    #str[3:0:-1] 
print(str2)
str2 = str[l-1:-1:-1]    #str[3:-1:-1]
print(str2)

在第一个str2=str[l-1:0:-1]中，上限小于下限，因此打印dcb。

然而，在str2=str[l-1:-1:-1]中，上限不小于下限（将下限转换为负值，即-1：因为最后一个元素的索引是-1和3）。

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

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

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

              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到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中检索前两个元素。

语法为：

a[start:stop]  # items start through stop-1
a[start:]      # items start through the rest of the array
a[:stop]       # items from the beginning through stop-1
a[:]           # a copy of the whole array

还有一个步长值，可用于上述任何一项：

a[start:stop:step] # start through not past stop, by step

要记住的关键点是：stop值表示不在所选切片中的第一个值。因此，停止和开始之间的区别是所选元素的数量（如果步骤为1，则为默认值）。

另一个特点是start或stop可以是负数，这意味着它从数组的末尾开始计数，而不是从开始计数。因此：

a[-1]    # last item in the array
a[-2:]   # last two items in the array
a[:-2]   # everything except the last two items

类似地，步骤可以是负数：

a[::-1]    # all items in the array, reversed
a[1::-1]   # the first two items, reversed
a[:-3:-1]  # the last two items, reversed
a[-3::-1]  # everything except the last two items, reversed

如果项目比你要求的少，Python对程序员很友好。例如，如果您请求一个[：-2]，而一个只包含一个元素，则会得到一个空列表而不是一个错误。有时你会更喜欢错误，所以你必须意识到这可能会发生。

与切片对象的关系

切片对象可以表示切片操作，即：

a[start:stop:step]

相当于：

a[slice(start, stop, step)]

根据参数的数量，切片对象的行为也略有不同，类似于range（），即切片（stop）和切片（start，stop[，step]）都受支持。要跳过指定给定参数，可以使用None，例如[start:]等同于[sslice（start，None）]或[：：-1]等同于[Sslice（None，None，-1）]。

虽然基于：的表示法对简单切片非常有用，但slice（）对象的显式使用简化了切片的编程生成。