切片规则如下：

[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）。

语法为：

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（）对象的显式使用简化了切片的编程生成。

在我看来，如果您按照以下方式查看Python字符串切片表示法（继续阅读），您将更好地理解和记忆它。

让我们使用以下字符串。。。

azString = "abcdefghijklmnopqrstuvwxyz"

对于不知道的人，可以使用符号azString[x:y]从azString创建任何子字符串

来自其他编程语言，这是常识受到损害的时候。x和y是什么？

为了寻找一种记忆技巧，我不得不坐下来运行了几个场景，帮助我记住x和y是什么，并帮助我在第一次尝试时正确地切分字符串。

我的结论是，x和y应该被视为围绕我们想要增加的字符串的边界索引。因此，我们应该将表达式视为azString[index1，index2]，或者更清晰地视为azString[index_of_first_charactere，index_after_the_last_character]。

这是一个可视化的例子。。。

Letters   a b c d e f g h i j ...
         ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑
             ┊           ┊
Indexes  0 1 2 3 4 5 6 7 8 9 ...
             ┊           ┊
cdefgh    index1       index2

因此，您所要做的就是将index1和index2设置为所需子字符串周围的值。例如，要获得子字符串“cdefgh”，可以使用azString[2:8]，因为“c”左侧的索引是2，而“h”右侧的索引是8。

请记住，我们正在设置边界。这些边界是可以放置一些括号的位置，括号将像这样围绕子字符串。。。

a b[c d e f g h]i j公司

这个技巧一直有效，而且很容易记住。

我的大脑似乎很乐意接受lst[开始：结束]包含开始项。我甚至可以说这是一个“自然的假设”。

但偶尔会有一种怀疑悄悄出现，我的大脑会要求我保证它不包含结尾元素。

在这些时刻，我依靠这个简单的定理：

for any n,    lst = lst[:n] + lst[n:]

这个漂亮的属性告诉我，lst[start:end]不包含end-th项，因为它位于lst[end:]中。

注意，这个定理对任何n都是正确的。例如，您可以检查

lst = range(10)
lst[:-42] + lst[-42:] == lst

返回True。

上面的答案不讨论切片分配。为了理解切片分配，可以在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]

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

Python切片表示法：

a[start:end:step]

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

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

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

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